（6）文本挖掘（三）——文本特征TFIDF权重计算及文本向量空间VSM表示

最新推荐文章于 2024-01-04 23:53:55 发布
最新推荐文章于 2024-01-04 23:53:55 发布
阅读量732 收藏 7
点赞数 1
文章标签： java 人工智能
原文链接：http://www.cnblogs.com/mfmdaoyou/p/7182680.html
版权

建立文本数据数学描写叙述的过程分为三个步骤：文本预处理、建立向量空间模型和优化文本向量。

文本预处理主要採用分词、停用词过滤等技术将原始的文本字符串转化为词条串或者特点的符号串。文本预处理之后，每个文本的词条串被进一步转换为一个文本向量，向量的每一维相应一个词条，其值反映的是这个词条与这个文本之间的类似度。类似度有非常多不同的计算方法。所以优化文本向量就是採用最为合适的计算方法来规范化文本向量，使其能更好地应用于文本分类和文本聚类等方面。
TFIDF算法
TF-IDF使得一个单词能尽量与文本在语义上相关。TF-IDF算法的实现步骤：
这里写图片描写叙述
这里写图片描写叙述

经过试验发现，用TFIDF/max(TFIDF)的方法效果是最好的。详细代码例如以下：

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * 经过试验发现，用TFIDF/max(TFIDF)的方法效果是最好的
 * @author Angela
 */
public class TFIDF {

    private Map<String,Integer> TF;//文本词频集 
    private Map<String,Double> IDF;//特征-逆文档频率集  

    /**
     * 构造方法，初始化TF和IDF
     */
    public TFIDF(Map<String,Integer> TF,Map<String,Double> IDF){   
        this.TF=TF;
        this.IDF=IDF;             
    }     

    /**
     * 计算文本特征集的tf-idf权值
     * @return filePath文件的特征-TFIDF集
     */
    public Map<String,Double> getTFIDF(){
        Map<String,Double> tfidf=new HashMap<String,Double>();       
        for(Map.Entry<String,Integer> me: TF.entrySet()){
            String f=me.getKey();
            double weight=me.getValue()*IDF.get(f);
            tfidf.put(f, weight);
        }
        return tfidf;
    }

    /**
     * 计算文本特征集的对数tf-idf权值
     * @return filePath文件的特征-TFIDF集
     */
    public Map<String,Double> getLogTFIDF(){
        Map<String,Double> tfidf=new HashMap<String,Double>();       
        for(Map.Entry<String,Integer> me: TF.entrySet()){
            String f=me.getKey();
            double tf=1+Math.log(me.getValue());
            double weight=tf*IDF.get(f);
            tfidf.put(f, weight);
        }
        return tfidf;
    }

    /**
     * 进行规一化，每个特征除以这篇文本TFIDF值之和，构成新的TFIDF集
     * @return filePath文件的特征-标准化TFIDF集
     */
    public Map<String,Double> getNormalTFIDF(){
        Map<String,Double> tfidf=new HashMap<String,Double>();
        Map<String,Double> weight=getTFIDF();
        double sum=MathUtil.calSum(weight);//计算TFIDF总和
        for(Map.Entry<String, Double> me: weight.entrySet()){
            String f=me.getKey();
            double w=me.getValue()/sum;
            tfidf.put(f, w);
        }
        return MapUtil.descend(tfidf);
    } 

    /**
     * 进行标准化，每个特征除以这篇文本中最大的TFIDF值，构成新的TFIDF集
     * @return filePath文件的特征-标准化TFIDF集
     */
    public Map<String,Double> getStandardTFIDF(){
        Map<String,Double> tfidf=new HashMap<String,Double>();
        Map<String,Double> weight=getTFIDF();
        Map<String,Double> temp=MapUtil.descend(weight);
        Set<Map.Entry<String, Double>> set = temp.entrySet();
        Iterator<Map.Entry<String,Double>> it = set.iterator();
        double max=0;
        if(it.hasNext()){
            max=it.next().getValue();
        }
        for(Map.Entry<String, Double> me: weight.entrySet()){
            String f=me.getKey();
            double w=me.getValue()/max;
            tfidf.put(f, w);
        }
        return MapUtil.descend(tfidf);
    }  

    /**
     * 保存文本的TFIDF结果
     * @param tf 文本的TF集
     * @param idf IDF集
     * @param savePath 保存路径
     */
    public static void saveTFIDF(Map<String,Integer> tf,
            Map<String,Double> idf,String savePath){
        TFIDF tfidf=new TFIDF(tf,idf);
        Map<String,Double> weight=tfidf.getStandardTFIDF();
        Writer.saveMap(weight, savePath);
    }

    /**
     * 保存TFIDF结果
     * @param filePath 文本集的TF集路径
     * @param idfPath IDF路径
     * @param tarPath 保存路径
     */
    public static void saveTFIDF(String TFPath,String IDFPath,String tarPath){
        File tar=new File(tarPath);
        if(!tar.exists()) tar.mkdir(); 
        Map<String,Double> idf=Reader.toDoubleMap(IDFPath);//IDF
        File file=new File(TFPath);
        File[] labels=file.listFiles();//类别            
        for(File label: labels){
            String labelpath=tarPath+File.separator+label.getName();                
            File labelPath=new File(labelpath);
            if(!labelPath.exists()) labelPath.mkdir();
            File[] texts=label.listFiles();//文本
            for(File text: texts){
                String savePath=labelpath+File.separator+text.getName();
                Map<String,Integer> tf=Reader.toIntMap(text.getAbsolutePath());
                saveTFIDF(tf,idf,savePath);  
                System.out.println("Saved "+savePath);
            }
        }
    }

    public static void main(String args[]){
        String TFPath="data\\r8trainTF";
        String IDFPath="data\\r8trainIDF.txt";
        String tarPath="data\\r8trainTFIDF3";
        saveTFIDF(TFPath,IDFPath,tarPath);
    }

}

向量空间模型VSM
这里写图片描写叙述

余弦类似度
文本与文本之间的类似度不能简单地用欧式距离来计算。更合理的计算方式是余弦类似度。
这里写图片描写叙述

以下就是涉及这两个知识点的工具类。

MathUtil存放通用的计算公式方法

import java.util.Map;

/**
 *
 * @author Angela
 */
public class MathUtil {

    /**
     * 计算Map的键值之和
     * @param map
     * @return 
     */
    public static double calSum(Map<String,Double> map){
        double sum=0;
        for(Map.Entry<String,Double> me: map.entrySet()){
            sum+=me.getValue();
        }
        return sum;
    }

    /**
     * 计算两篇文本的类似度
     * @param text1 文本1
     * @param text2 文本2
     * @return text1和text2的余弦类似度。值越大越类似
     */
    public static double calSim(Map<String,Double> text1,
            Map<String,Double> text2){
        double sim=0;//类似度
        double sum=0;//同样特征的权重相乘之和
        double len1=0;//文本1的长度
        double len2=0;//文本2的长度
        for(Map.Entry<String,Double> me: text1.entrySet()){
            String f=me.getKey();
            double value=me.getValue();
            if(text2.containsKey(f)){
                sum+=value*text2.get(f);
            }
            len1+=value*value;
        }
        for(Map.Entry<String,Double> me: text2.entrySet()){
            double value=me.getValue();
            len2+=value*value;
        }
        sim=sum/(Math.sqrt(len1)*Math.sqrt(len2));
        return sim;
    }

}

GetData获取DF、TFIDF即VSM、类别成员clusterMember、类别列表LabelList及由TFIDF构造的其他数据

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 *
 * @author Angela
 */
public class GetData {

    /**
     * 依据TFIDF得到相应的DF集合
     * 假设你的TFIDF集仅仅是原始的一部分，就用这种方法来获取相应的DF集
     * @param tfidf TFIDF集合
     * @return 
     */
    public static Map<String,Integer> getDF(Map<String,Map<String,Double>> tfidf){
        Map<String,Integer> map=new HashMap<String,Integer>();
        for(Map.Entry<String,Map<String,Double>> me: tfidf.entrySet()){
            Map<String,Double> text=me.getValue();
            for(Map.Entry<String,Double> t: text.entrySet()){
                String feature=t.getKey();
                if(map.containsKey(feature)){
                    map.put(feature,map.get(feature)+1);
                }else{
                    map.put(feature, 1);
                }
            }
        }                   
        return map;
    }

    /**
     * 读取文本集，返回Map<类别+文件名称，Map<特征，权重>>
     * 当你进行特征选择后，得到特征子集，能够用这种方法
     * 从文本集中构建新的VSM
     * @param filePath TFIDF存放路径
     * @param featureSet 特征集
     * @return 
     */
    public static Map<String,Map<String,Double>> getTFIDF(String filePath,
            Set<String> featureSet){
        Map<String,Map<String,Double>> map=new HashMap<String,Map<String,Double>>();
        File path=new File(filePath);
        File[] files=path.listFiles();//类别
        for(File file: files){
            String label=file.getName();
            File[] texts=file.listFiles();//文本
            for(File text: texts){
                Map<String,Double> tfidf=Reader.toDoubleMap(text.getAbsolutePath());
                Map<String,Double> temp=new HashMap<String,Double>();
                for(Map.Entry<String,Double> me: tfidf.entrySet()){
                    String feature=me.getKey();
                    if(featureSet.contains(feature)){
                        temp.put(feature,me.getValue());
                    }
                }
                map.put(label+File.separator+text.getName(), temp);
            }
        }
        return map;
    }

    /**
     * 依据特征集构建新的VSM，返回Map<类别+文件名称，Map<特征，权重>>
     * 当你进行特征选择后，得到特征子集，能够用这种方法
     * 从原始的VSM中构建新的VSM
     * @param tfidf 原始的VSM
     * @param featureSet 特征集
     * @return 
     */
    public static Map<String,Map<String,Double>> getTFIDF(
            Map<String,Map<String,Double>> tfidf,Set<String> featureSet){
        Map<String,Map<String,Double>> map=new HashMap<String,Map<String,Double>>();
        for(Map.Entry<String,Map<String,Double>> me: tfidf.entrySet()){
            Map<String,Double> text=me.getValue();
            Map<String,Double> temp=new HashMap<String,Double>();
            for(Map.Entry<String,Double> t: text.entrySet()){
                String feature=t.getKey();
                if(featureSet.contains(feature)){
                    temp.put(feature,t.getValue());
                }
            }
            map.put(me.getKey(), temp);
        }                   
        return map;
    }  

    /**
     * 依据TFIDF文本集和特征集构建
     * Map<特征，Map<文本路径名，特征在该文本中的TFIDF值>>
     * @param tfidf TFIDF文本集
     * @param featureSet 特征集
     * @return 
     */
    public static Map<String,Map<String,Double>> getTermIndex(
            Map<String,Map<String,Double>> tfidf,Set<String> featureSet){
        Map<String,Map<String,Double>> termIndex=
                new HashMap<String,Map<String,Double>>();
        for(String f: featureSet){//特征
            //包括有特征f的全部文本及特征f在该文本中的权重
            Map<String,Double> feature=new HashMap<String,Double>();
            for(Map.Entry<String,Map<String,Double>> me: tfidf.entrySet()){
                Map<String,Double> text=me.getValue();//文本
                if(text.containsKey(f)){//假设文本包括特征f
                    //将文本的路径和特征f的值赋给feature
                    feature.put(me.getKey(), text.get(f));                   
                }
            }
            //将特征及feature赋给termIndex
            termIndex.put(f,feature);
        }
        return termIndex;
    }

    /**
     * 依据文本特征集和特征集构建Map<特征，Set<文本路径名>>
     * @param dataSet Map<文本，Set<特征>>
     * @param featureSet 特征集
     * @return 
     */
    public static Map<String,Set<String>> getFeatureIndex(
            Map<String,Set<String>> dataSet,Set<String> featureSet){
        Map<String,Set<String>> featureIndex=
                new HashMap<String,Set<String>>();
        for(String f: featureSet){//特征
            Set<String> textSet=new HashSet<String>();
            for(Map.Entry<String,Set<String>> me: dataSet.entrySet()){
                String textPath=me.getKey();//文本路径
                Set<String> feature=me.getValue();//文本的特征集
                //假设文本包括特征f
                if(feature.contains(f)){
                    textSet.add(textPath);
                }
            }
            //将特征及文本集赋给termText
            featureIndex.put(f,textSet);
        }
        return featureIndex;
    }

    /**
     * 文本集的类别成员
     * @param filePath 
     * @return 
     */
    public static Map<Integer,List<String>> getClusterMember(String filePath){
        Map<Integer,List<String>> clusterMember=new HashMap<Integer,List<String>>();
        File file=new File(filePath);
        File[] labels=file.listFiles();
        int labelNum=labels.length;
        for(int i=0;i<labelNum;i++){
            File[] texts=labels[i].listFiles();
            String label=labels[i].getName();
            List<String> member=new ArrayList<String>();
            for(File text: texts){
                member.add(label+File.separator+text.getName());
            }
            clusterMember.put(i, member);
        }
        return clusterMember;
    }    

    /**
     * 类别集
     * @param filePath
     * @return 
     */
    public static List<String> getLabelList(String filePath){
        List<String> labelList=new ArrayList<String>();
        File files=new File(filePath);
        File[] file=files.listFiles();
        for(File f: file){
            labelList.add(f.getName());
        }
        return labelList;
    } 

    /**
     * 依据TFIDF集构造类别集
     * @param TFIDF
     * @return 
     */
    public static List<String> getLabelList(Map<String,Map<String,Double>> TFIDF){
        Set<String> labels=new HashSet<String>();
        for(Map.Entry<String,Map<String,Double>> me: TFIDF.entrySet()){
            String path=me.getKey();
            String label=path.substring(0,path.lastIndexOf(File.separator));
            labels.add(label);
        }
        List<String> labelList=new ArrayList<String>(labels);
        return labelList;
    }     

}

由于文本数据量一般非常大，并且VSM具有高维稀疏的特点。所以一般须要进行特征选择。来降低特征的数量。

下一节，我将介绍几种特征选择方法。

转载于:https://www.cnblogs.com/mfmdaoyou/p/7182680.html

aodiyi6351
关注
[Python从零到壹] 十五.文本挖掘之数据预处理、Jieba工具和文本聚类万字详解
杨秀璋的专栏
08-06 2万+
前一篇文章讲述了分类算法的原理知识级案例，包括决策树、KNN、SVM，并通过详细的分类对比实验和可视化边界分析与大家总结。本文将详细讲解数据预处理、Jieba分词和文本聚类知识，这篇文章可以说是文本挖掘和自然语言处理的入门文章。两万字基础文章，希望对您有所帮助。欢迎大家来到“Python从零到壹”，在这里我将分享约200篇Python系列文章，带大家一起去学习和玩耍，看看Python这个有趣的世界。所有文章都将结合案例、代码和作者的经验讲解，真心想把自己近十年的编程经验分享给大家，希望对您有所帮助，文章中不
tfidf算法python计算权重_使用不同的方法计算TF-IDF值
weixin_39941792的博客
01-14 2153
欢迎大家访问我的博客以及简书本博客所有内容以学习、研究和分享为主，如需转载，请联系本人，标明作者和出处，并且是非商业用途，谢谢！一. 摘要这篇文章主要介绍了计算TF-IDF的不同方法实现，主要有三种方法：用gensim库来计算tfidf值用sklearn库来计算tfidf值用python手动实现tfidf的计算关于TFIDF的算法原理我就不过多介绍了，看这篇博客即可——TF-IDF原理。阮一峰大佬...
TF-IDF: 文本的一种向量表示
newcolour_USTC
05-02 2111
TF-IDF是Term Frequency-Inverse Document Frequency的简称。她是一种非常常见的用于将文本转化为有意义的数字表示的算法。这个技术被广泛的应用与NLP的各个方面。本文将会介绍怎样计算和应用TF-IDF。 文本的向量表示 为了将机器学习算法或统计技术应用到任何形式的文本上，应当将文本转化为数字或向量形式。这种数字表示应当能够描绘出本文的显著特征。有很多技术都可...
向量空间模型VSM—特征抽取算法—TF-IDF
sanmi8276的博客
04-04 843
原文作者：lucky小东西 原文地址：基于tf-idf的小说主题特征抽取算​法 1.主题特征抽取做什么 在当前个性化推荐大行其道的时候，那就不得不提用户画像。用户画像的主要工作内容就是将用户标签化，对于我们现有的数据来说，用户本身的固有属性很难获取到，或者说即使获取到了，也是不够准确的。那我们只能从“用户到底看了啥”这个角度，尝试去描述一个用户了。那么，我们想要知道一个用户“看了啥”，那么我们首先需要确定“他看的书到底是啥”。换言之，我们需要知道他读的小说是什么小说，所以，我们先得清楚文章的主题，我们
文本特征抽取的向量空间模型（VSM）和TF/IDF方法
程序猿视角
05-06 2万+
文本特征抽取由两组小说，一组是爱情的，另一组是科幻的。我们能否用支持向量机训练一个模型，用来识别小说类型呢？这个并不容易。因为支持向量机这类机器学习算法只能接受数学里面的向量作为输入。如果用它来做文本分类，必须先把文本转化成向量才行。这就是涉及到一个很重要的话题，如何把文本转化成向量？把文本转化成数学模型，是用数学方法处理文本的先决条件，这个过程成为文本特征抽取。向量作为一种基本的数学模型，是文本特
结合词义的文本特征词权重计算方法 (2012年)
05-16
传统的基于向量空间模型的文本相似度计算方法，用TF-IDF计算文本特征词的权重，忽略了特征词之间的词义相似关系，不能准确地反映文本之间的相似程度。针对此问题，提出了结合词义的文本特征词权重计算方法，基于Chinese WordNet采用词义向量余弦计算特征词的词义相似度，根据词义相似度对特征词的TF-IDF权重进行修正，修正后的权重同时兼顾词频和词义信息。在哈尔滨工业大学信息检索研究室多文档自动文摘语料库上的实验结果表明，根据修正后的特征词权重计算文本相似度，能够有效地提高文本的类区分度。
[转载]文本特征TFIDF权重计算及文本向量空间VSM表示
dreamzuora的博客
12-03 501
https://blog.csdn.net/Fighting_No1/article/details/51000066
VSM信息检索模型（向量空间模型）
01-13
向量空间模型（Vector Space Model，VSM）是一种在信息检索和自然语言处理领域广泛应用的模型，它将文档和查询转化为向量的形式，通过计算这些向量之间的相似度来评估文档与查询的相关性。在本项目中，我们将探讨VSM...
基于Hadoop+TFIDF+VSM+Kmeans的文本聚类程序.zip
最新发布
03-13
【向量空间模型（VSM）】是将文本数据转换成数值向量的过程，每个向量代表一个文档，其中的每个维度对应一个词项，向量的长度表示文档的特征，向量的各分量表示词项在文档中的TF-IDF值。VSM使得我们可以使用数学方法...
基于Hadoop的文本相似度计算
06-11
总结来说，基于Hadoop的文本相似度计算涉及了分布式计算、文本处理和机器学习等多个方面，其中包括Hadoop的MapReduce编程模型、TF-IDF权重计算、向量空间模型的构建以及IKAnalyzer的中文分词技术。这些技术共同构成...
机器学习之特征提取 TF-IDF
baidu_1234567的博客
01-04 198
机器学习之特征提取 TF-IDF
自然语言处理——TF-IDF文本表示
日积月累，天道酬勤
08-11 5889
本文介绍了TF-IDF的原理以及Python实现。
NLP --- 文本分类（向量空间模型（Vector Space Model）VSM）
热门推荐
进击的菜鸟
12-28 4万+
本节主要介绍文本分类中的一种算法即向量空间模型，这个算法很经典，包含文本预处理、特征选择、特征权值计算、分类算法、这是VSM的几个主要步骤，在宗老师的书里都有详细的讲解，这里也会进行深入的讲解，浅显易懂的是目的，深入理解是目标，下面给出这个VSM模型的方框流程图： 其中分词和词袋的建立我们在前两节进行解释了，这一节将主要介绍特征词选择、文本模型表示（VSM），分类算法的建立。下面就系统的进行...
TF-IDF词向量表示
tianzhiya121的博客
12-12 3186
TF-IDF的英文表示是term frequency（词频），inverse document frequency（逆文件频率）。tf-idf是一个权重，其常被用于信息检索和文本挖掘。此权重是一个统计量度，字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。 词频 (term frequency, TF)指的是某一个给定的词语在该文件中出现的次数。这个...
文本分类学习（三） 特征权重（TF/IDF）和特征提取
weixin_30347335的博客
04-03 1129
上一篇中，主要说的就是词袋模型。回顾一下，在进行文本分类之前，我们需要把待分类文本先用词袋模型进行文本表示。首先是将训练集中的所有单词经过去停用词之后组合成一个词袋，或者叫做字典，实际上一个维度很大的向量。这样每个文本在分词之后，就可以根据我们之前得到的词袋，构造成一个向量，词袋中有多少个词，那这个向量就是多少维度的了。然后就把这些向量交给计算机去计算，而不再需要文本啦。而向量中的数字表示的是每个...
文本TF-IDF特征获取方法及文本向量化方法
ai-july
03-05 4728
一 获取文本的TF-IDF特征 1. 文本向量化特征的不足 　　　　在将文本分词并向量化后，我们可以得到词汇表中每个词在各个文本中形成的词向量，比如在文本挖掘预处理之向量化与Hash Trick这篇文章中，我们将下面4个短文本做了词频统计： corpus=["I come to China to travel", "This is a car polupar in China",...
词权重计算及应用
公众号（猴子数据分析）
03-26 5195
本文讨论如何计算词（有时候称特征向量）权重和向量空间模型及其应用。本文的“文档”是指查询对象，它们可以使一条条单独的记录或者是一本书的各章，还可以是一个网页，或者xml文件等。 1 归一化     在讨论词权重和向量空间模型前需要先了解下归一化的概念。归一化（normailization）方法有两种形式。第一种形式是把数变为（0，1）之间的小数,方便计算。第二种是把有量纲（量纲是指单位）表达式
TF-IDF权重策略
Evan_QB的博客
09-29 2495
TF-IDF：词频逆文档权重方案。 含义:如果某个词或者短语在一篇文章中出现频率高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。 TF(词频): 指的是某一个给定词语在文件中出现的频率。 TF = 该词在文件中出现的次数/在文件中所有字词的次数之和 IDF(逆向文本频率): 是一个词语普遍重要性的度量。 IDF = log(总文件
改进TFIDF与Labeled-LDA结合的文本分类方法
为了解决这个问题，文章提出了一种改进的TFIDF算法，该算法考虑了特征项在类别间的分布情况，通过引入文档权重比例来修正权重计算，从而更好地提取类别特征词。此外，论文还结合了Labeled-LDA（有标签的latent ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值