Java 文字特徵挖掘

轉載以備查閱

特徵選擇指的是按照一定的規則從原來的特徵集合中選擇出一小部分最為有效的特徵。通過特徵選擇，一些和任務無關或是冗餘的特徵被刪除，從而提高資料處理的效率。
文字資料的特徵選擇研究的重點就是用來衡量單詞重要性的評估函式，其過程就是首先根據這個評估函式來給每一個單詞計算出一個重要性的值，然後根據預先設定好的閾值來選擇出所有其值超過這個閾值的單詞。
根據特徵選擇過程與後續資料探勘演算法的關聯，特徵選擇方法可分為過濾、封裝和嵌入。
（1）過濾方法（Filter Approach）：使用某種獨立於資料探勘任務的方法，在資料探勘演算法執行之前進行特徵選擇，即先過濾特徵集產生一個最有價值的特徵子集。或者說，過濾方法只使用資料集來評價每個特徵的相關性, 它並不直接優化任何特定的分類器, 也就是說特徵子集的選擇和後續的分類演算法無關。
（2）封裝方法（Wrapper Approach）：將學習演算法的結果作為特徵子集評價準則的一部分，根據演算法生成規則的分類精度選擇特徵子集。該類演算法具有使得生成規則分類精度高的優點，但特徵選擇效率較低。封裝方法與過濾方法正好相反, 它直接優化某一特定的分類器, 使用後續分類演算法來評價候選特徵子集的質量。
一般說來, 過濾方法的效率比較高, 結果與採用的分類演算法沒有關係, 但效果稍差;封裝方法佔用的運算時間較多, 結果依賴於採用的分類演算法, 也因為這樣其效果較好。
（3）嵌入方法（embedded Approach）：特徵選擇作為資料探勘演算法的一部分自然地出現。在資料探勘演算法執行期間，演算法本身決定使用哪些屬性和忽略哪些特徵，如決策樹C4.5分類演算法。
如果將過濾方法和封裝方法結合，就產生了第四種方法：
（4）混合方法（Hybrid Approach）：過濾方法和封裝方法的結合，先用過濾方法從原始資料集中過濾出一個候選特徵子集，然後用封裝方法從候選特徵子集中得到特徵子集。該方法具有過濾方法和封裝方法兩者的優點，即效率高，效果好。

根據特徵選擇過程是否用到類資訊的指導，即其評估函式是否依賴類資訊，特徵選擇可分為監督式特徵選擇（需要依賴類資訊的有監督特徵選擇，只能用於文字分類）、無監督式特徵選擇（不需要依賴類資訊的無監督特徵選擇，用於文字分類和文字聚類）。
（1）監督式特徵選擇（supervised feature selection）：使用類資訊來進行指導，通過度量類資訊與特徵之間的相互關係來確定子集大小。
（2）無監督式特徵選擇（unsupervised feature selection）：在沒有類資訊的指導下，使用樣本聚類或特徵聚類對聚類過程中的特徵貢獻度進行評估，根據貢獻度的大小進行特徵選擇。

下面，我先介紹有監督特徵選擇方法IG（Information Gain資訊增益）和CHI（X2 statistic卡方統計）及它們相應的

Java實現。由於這兩者需要的資料是相同的：clusterMember類別成員類，特徵所在文字集，DF集，需要做的事情是相同的：進行特徵選擇得到特徵重要性集，所以我寫了一個抽象父類Supervisor：

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 *
 * @author Angela
 */
public abstract class Supervisor {

    protected Map<Integer,List<String>> clusterMember;//簇成員  

    protected Map<String,Set<String>> featureIndex;//特徵-文字名集
    protected Map<String,Integer> DF;//DF集
    protected int textNum;//總文字數
    protected Set<String> featureSet;//特徵集
    protected Map<String,Double> featureMap;//特徵重要性集

    /**
     * 建構函式，初始化各個資料
     * @param clusterMember 類別成員
     * @param featureIndex 
     * @param DF 
     */
    public Supervisor(Map<Integer,List<String>> clusterMember,
            Map<String,Set<String>> featureIndex,Map<String,Integer> DF){
        this.clusterMember=clusterMember;
        textNum=0;
        for(Map.Entry<Integer,List<String>> me: clusterMember.entrySet()){
            textNum+=me.getValue().size();//計算文字數
        }
        this.featureIndex=featureIndex;
        this.DF=DF;
        featureSet=DF.keySet();//得到特徵集
        featureMap=new HashMap<String,Double>();
    }

    /**
     * 進行特徵選擇，得到featureMap
     * @return 特徵-重要性集
     */
    public abstract Map<String,Double> selecting();

}

IG
這裡寫圖片描述

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 *
 * @author Angela
 */
public class IG extends Supervisor{

    public IG(Map<Integer,List<String>> clusterMember,
            Map<String,Set<String>> featureIndex,Map<String,Integer> DF){
        super(clusterMember,featureIndex,DF);
    }

    /**
     * 計算文字集的熵
     * @return 總熵
     */
    public double computeEntropyOfCluster(){
        double entropy=0;//文字集的熵
        double pro;//類的概率
        double temp;//類的熵
        for(Map.Entry<Integer,List<String>> me:clusterMember.entrySet()){
            pro=(double)me.getValue().size()/textNum;
            temp=pro*Math.log(pro);
            entropy+=temp;
        }
        return -entropy;
    }

    /**
     * 計算特徵的條件熵
     * @param f 特徵
     * @return 特徵f的條件熵
     */
    public double computeConditionalEntropy(String f){
        double ce=0;        
        double df=DF.get(f); //含有特徵f的文字總數
        double nf=textNum-df;
        Set<String> text=featureIndex.get(f);//含有特徵f的文字

        double proOfCF1;//P(Ci|T)
        double proOfCF2;//P(Ci|!T)
        double value1=0;//P(Ci|T)log2(P(Ci|T))的和
        double value2=0;//P(Ci|!T)log2(P(Ci|!T))的和

        for(Map.Entry<Integer,List<String>> me:clusterMember.entrySet()){
            int count=0;
            List<String> member=me.getValue();//簇中的文字
            int size=member.size();
            for(String path: member){
                if(text.contains(path)){
                    count++;//含有特徵f並屬於該簇的文字數
                }
            }
            double temp1=0;//P(Ci|T)log2(P(Ci|T))
            double temp2=0;//P(Ci|!T)log2(P(Ci|!T))
            if(count!=0&&count!=size){
                //屬於類Ci且含有詞t的文字數除以含有詞t的文字數
                proOfCF1=count/df;
                temp1=proOfCF1*Math.log(proOfCF1);
                proOfCF2=(size-count)/nf;
                temp2=proOfCF2*Math.log(proOfCF2);               
            }
            value1+=temp1;
            value2+=temp2;
        }        
        ce=(df*value1+nf*value2)/textNum;

        return ce;
    }

     /**
     * 進行特徵選擇，計算所有特徵的IG,得到featureMap
     * @return 特徵-重要性集
     */
    @Override
    public Map<String,Double> selecting(){
        double e=computeEntropyOfCluster();
        for(String f: featureSet){
            double ce=computeConditionalEntropy(f);
            double value=e+ce;
            featureMap.put(f, value);
        }
        return featureMap;
    }
}

CHI
這裡寫圖片描述

這裡我選擇的是計算CHI總和

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 *
 * @author Angela
 */
public class CHI extends Supervisor{

    public CHI(Map<Integer,List<String>> clusterMember,
            Map<String,Set<String>> featureIndex,Map<String,Integer> DF){
        super(clusterMember,featureIndex,DF);
    }

    /**
     * 計算特徵的CHI值
     * @param feature 特徵
     * @return 特徵f的CHI值
     */
    public double computeCHI(String feature){      
        double macro_chi=0;
        double pf=DF.get(feature);//包含特徵f的文字數
        double nf=textNum-pf;//不包含特徵f的文字數
        Set<String> text=featureIndex.get(feature);//含有特徵f的文字
        for(Map.Entry<Integer,List<String>> me:clusterMember.entrySet()){
            List<String> member=me.getValue();
            double pc=member.size();//簇中的文字
            double nc=textNum-pc;//不屬於簇cluster的文字數
            double value1=pf*nf*pc*nc;

            double pf_pc=0;                          
            for(String path: member){            
                if(text.contains(path)){
                    pf_pc++;//含有特徵f且屬於該簇的文字數
                }
            }

            double pf_nc=pf-pf_pc; //含有特徵f但不屬於該簇的文字數
            double nf_pc=pc-pf_pc;//不含有特徵f但屬於該簇的文字數
            double nf_nc=nc-pf_nc; //不含有特徵f且不屬於該簇的文字數
            double value2=Math.pow(pf_pc*nf_pc-pf_nc*nf_nc,2);

            double chi=pc*value2/value1;
            macro_chi+=chi;
        }        
        return macro_chi;
    }

    /**
     * 進行特徵選擇，計算所有特徵的CHI,得到featureMap
     * @return 特徵-重要性集
     */
    public Map<String,Double> selecting(){
        for(String feature: featureSet){
            double value=computeCHI(feature);
            featureMap.put(feature, value);
        }
        return featureMap;
    }

}

然後我們寫一個方法來將特徵選擇後的結果儲存到arff檔案中：

public static void supervisor(String segmentPath,String DFPath,
            int num,String TFIDFPath,String savePath){
        //先進行DF特徵選擇，去掉DF值大於3小於3000的特徵，減少特徵數量
         Map<String,Integer> DF=Reader.toIntMap(DFPath);
        Map<String,Integer> subDF=MapUtil.getSubMap(DF, 3, 3000);
        //讀取資料集
        Map<String,Set<String>> dataSet=Reader.readDataSet(segmentPath);      
        Map<String,Set<String>> featureIndex=
                GetData.getFeatureIndex(dataSet, subDF.keySet());
        //讀取類別成員及
        Map<Integer,List<String>> clusterMember=
                GetData.getClusterMember(segmentPath);
        //進行特徵選擇
        //Supervisor sv=new IG(clusterMember,featureIndex,subDF);
        Supervisor sv=new CHI(clusterMember,featureIndex,subDF);
        Map<String,Double> featureMap=sv.selecting();
        //MapUtil.print(featureMap, 100);
        Set<String> featureSet=MapUtil.getSubMap(featureMap, num).keySet();
        //根據特徵子集構造VSM
        Map<String,Map<String,Double>> tfidf=
                GetData.getTFIDF(TFIDFPath, featureSet);
        //讀取類別集
        List<String> labelList=GetData.getLabelList(TFIDFPath);
        String[] labels=new String[labelList.size()];
        labelList.toArray(labels);
        //寫出arff檔案，進行測試
        Writer.saveAsArff(tfidf, featureSet, labels, savePath);
    }

下面，介紹無監督特徵選擇方法TC（Term Contribution單詞貢獻度）、TS（Term Strength單詞權）、IIG（Improved Information Gain改進的用於無監督的IG）及它們各自的Java實現。三者的分類效果都很好，但TS的時間複雜度是N*N（N為文字集的文字總數），花費的時間高於TC和IIG。

這裡寫圖片描述

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import utility.GetData;
import utility.MapUtil;
import utility.Reader;
import utility.Writer;

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

    /**
     * 計算特徵的TC值
     * @param index 包含有某個特徵的所有文字及在文字中的權重的集合
     * @return 該特徵的TC值
     */
    private static double computeTC(Map<String,Double> index){
        double tc=0;
        double value1=0;
        double value2=0;
        for(Map.Entry<String,Double> me: index.entrySet()){
            double value=me.getValue();
            value1+=value;
            value2+=value*value;
        }
        tc=(value1*value1-value2)/2;
        return tc;
    }

    /**
     * 進行特徵選擇，計算所有特徵的TC貢獻度，得到featureMap
     * @return 特徵-重要性集
     */
    public static Map<String,Double> selecting(
            Map<String,Map<String,Double>> termIndex){
        Map<String,Double> featureMap=new HashMap<String,Double>();
        for(Map.Entry<String,Map<String,Double>> me:termIndex.entrySet()){
            String f=me.getKey();
            double value=computeTC(me.getValue());     
            featureMap.put(f, value);
        }
        return featureMap;
    }

    public static void main(String args[]){
        String segmentPath="data\\r8-train-stemmed";
        String DFPath="data\\r8trainDF.txt";
        int num=1000;
        String TFIDFPath="data\\r8trainTFIDF2";
        String savePath="E:\\tc.arff";
        Map<String,Integer> DF=Reader.toIntMap(DFPath);
        Set<String> subSet=MapUtil.getSubMap(DF, 3, 3000).keySet();
        Map<String,Map<String,Double>> TFIDF=
                GetData.getTFIDF(TFIDFPath, subSet);
        Map<String,Map<String,Double>> termIndex=
                GetData.getTermIndex(TFIDF, subSet);
        Map<String,Double> featureMap=TC.selecting(termIndex);
        //MapUtil.print(featureMap, 100);
        Set<String> featureSet=MapUtil.getSubMap(featureMap, num).keySet();
        Map<String,Map<String,Double>> tfidf=
                GetData.getTFIDF(TFIDF, featureSet);
        List<String> labelList=GetData.getLabelList(TFIDFPath);
        String[] labels=new String[labelList.size()];
        labelList.toArray(labels);
        Writer.saveAsArff(tfidf, featureSet, labels, savePath);
    }

}

TS
這裡寫圖片描述

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import utility.GetData;
import utility.MapUtil;
import utility.MathUtil;
import utility.Reader;
import utility.Writer;

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

    public static Map<String,Double> selecting(      
             Map<String,Map<String,Double>> TFIDF,double threshold){
        int textNum=TFIDF.size();//文字總數
        List<Map<String,Double>> textVSM=new 
                ArrayList<Map<String,Double>>(TFIDF.values());
        Map<String,Integer> termSimTextNum=new HashMap<String,Integer>();
        int simTextCount=0;//相關文字對數量
        for(int i=0;i<textNum;i++){
            List<String> simText=new ArrayList<String>();
            Map<String,Double> text1=textVSM.get(i);
            Set<String> featureSet=text1.keySet();//text1含有的特徵
            for(int j=0;j<textNum;j++){
                if(i!=j){    
                    Map<String,Double> text2=textVSM.get(j);
                    //計算text1和text2的文字相似度
                    double cos=MathUtil.calSim(text1,text2);
                    if(cos>threshold){                       
                        simTextCount++;   
                        //計算含有特徵feature的相關文字對數
                        for(String feature: featureSet){
                            if(text2.containsKey(feature)){
                                if(termSimTextNum.containsKey(feature)){
                                    termSimTextNum.put(feature, 
                                            termSimTextNum.get(feature)+1);
                                }else{
                                    termSimTextNum.put(feature, 1);
                                }
                            }
                        }
                    }
                }
            }            
        }
        System.out.println("相關文字對總數："+simTextCount);
        Map<String,Double> featureMap=new HashMap<String,Double>();
        for(Map.Entry<String,Integer> me: termSimTextNum.entrySet()){
            String f=me.getKey();
            //計算TS值
            double value=me.getValue()*1.0/simTextCount;
            featureMap.put(f, value);
        }
        return featureMap;
    }

    public static void main(String args[]){
        String segmentPath="data\\r8-train-stemmed";
        String DFPath="data\\r8trainDF.txt";
        int num=1000;
        String TFIDFPath="data\\r8trainTFIDF2";
        String savePath="E:\\ts.arff";
        Map<String,Integer> DF=Reader.toIntMap(DFPath);
        Map<String,Integer> subDF=MapUtil.getSubMap(DF, 3, 3000);
        Set<String> subSet=subDF.keySet();
        Map<String,Map<String,Double>> TFIDF=
                GetData.getTFIDF(TFIDFPath, subSet);
        Map<String,Double> featureMap=TS.selecting(TFIDF,0.5);
        //MapUtil.print(featureMap, 100);
        Set<String> featureSet=MapUtil.getSubMap(featureMap, num).keySet();
        Map<String,Map<String,Double>> tfidf=
                GetData.getTFIDF(TFIDF, featureSet);
        List<String> labelList=GetData.getLabelList(TFIDFPath);
        String[] labels=new String[labelList.size()];
        labelList.toArray(labels);
        Writer.saveAsArff(tfidf, featureSet, labels, savePath);
    }

}

IIG

這裡寫圖片描述


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import utility.GetData;
import utility.MapUtil;
import utility.Reader;
import utility.Writer;

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

    /**
     * 進行特徵選擇，計算所有特徵的IIG,得到featureMap
     * @return 特徵-重要性集
     */
    public static Map<String,Double> selecting(
            Map<String,Set<String>> dataSet,Map<String,Integer> DF){
        Set<String> featureSet=DF.keySet();
        Map<String,Set<String>> featureIndex=GetData.
                getFeatureIndex(dataSet,featureSet);
        Map<String,List<Integer>> featureNum=new HashMap<String,List<Integer>>();
        Map<String,Integer> featureSum=new HashMap<String,Integer>();
        for(Map.Entry<String,Set<String>> me: featureIndex.entrySet()){
            String f=me.getKey();
            Set<String> texts=me.getValue();
            List<Integer> list=new ArrayList<Integer>();
            int sum=0;
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    Java 文字特徵挖掘
      

轉載以備查閱

特徵選擇指的是按照一定的規則從原來的特徵集合中選擇出一小部分最為有效的特徵。通過特徵選擇，一些和任務無關或是冗餘的特徵被刪除，從而提高資料處理的效率。 
文字資料的特徵選擇研究的重點就是用來衡量單詞重要性的評估函式，其過程就是首先根據這個評估函式來給每一個單詞計算出一個重要性的值，然後根據 

  
 

    

    
    Java文字檔案的按行讀取
       
 
 package my;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStrea 

  
 

    

    
    用SPSS Modeler-對電商的重購買家特徵挖掘
       
 
 寫在開頭的話，這是筆者在上資料探勘課的時候分析的書中的案例，格式是按照小論文的寫法寫的，所以章節分的很詳細。 
 通過實驗瞭解淘寶（電商）的業務運營模式、運營資料特徵。通過此次試驗，理解資料分析的思路、過程；掌握RFM模型、營銷中“最佳聯絡人”和“重購買家的特徵”的分析方法；掌握SPSS   

  
 

    

    
    Java文字影象識別 1
       
  
  
 分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow
 
 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！
 
 
          

  
 

    

    
    機器學習——特徵工程和文字特徵工程提取
       
 
 機器學習的資料:檔案csv 
 可用的資料集: 
 
  scikit-learn  ：資料量小，方便學習 
  kaggle: 大資料競賽平臺，真實資料，資料量巨大 
  UCI:收錄了360個數據集，覆蓋科學、生活、經濟等領域，資料量幾十萬 
 
 常用資料集資料的結構組成 
 
   

  
 

    

    
    Java新特徵學習
       
 
 
 
 Java新特徵學習 
 一. try-with-resources jdk1.7 
 前 
  後 
 
   
 二. JDK 8 中介面允許有預設實現，那麼這個 default 方法，是對所有實現類都有價值的預設實現。jdk 8 
 三. lambda表示式 

  
 

    

    
    文字特徵提取方法研究
      
                一、課題背景概述

文字挖掘是一門交叉性學科,涉及資料探勘、機器學習、模式識別、人工智慧、統計學、計算機語言學、計算機網路技術、資訊學等多個領域。文字挖掘就是從大量的文件中發現隱含知識和模式的一種方法和工具,它從資料探勘發展而來,但與傳統的資料探勘又有許多不同。文字挖掘的物件 

  
 

    

    
    機器學習-2.特徵工程和文字特徵提取
       
  
  
 1. 資料集的組成 
  
  前面講了，機器學習是從歷史資料當中獲得規律，那這些歷史資料的組成是個什麼格式？大都儲存在哪裡？ – 在機器學習裡大多數資料不會存在資料庫中，大都存在檔案中（比如csv檔案） – 不存在資料庫原因：1. 讀取速度導致存在效能瓶頸。2. 儲存的格式不太符合機器學習 

  
 

    

    
    NLP原理，本質，資訊理論，文字特徵抽取和預處理
      
							
							
							
自然語言處理基本概念
語言的數學本質
語言的出現是為了通訊，通訊的本質是為了傳遞資訊。字母，文字，數字都是資訊編碼的不同單元。任何一種語言都是一種編解碼演算法。
我們通過語言把要表達的意思傳遞出來，實際上就是用語言將大腦中的資訊進行了一次編碼，形成了一串文字。 

  
 

    

    
    CountVectorizer與TfidfVectorizer 對文字特徵的特徵抽取
       
 
 對新聞文字資料使用CountVectorizer與TfidfVectorizer  抽取特徵，使用樸素貝葉斯進行分類。 
 # -*- coding:utf-8 -*-
if __name__ == '__main__':
    print "hello"
    # 從sklearn. 

  
 

    

    
    sklearn基礎（一）文字特徵提取函式CountVectorizer()和TfidfVectorizer()
       
 
 CountVectorizer()函式 
 CountVectorizer()函式只考慮每個單詞出現的頻率；然後構成一個特徵矩陣，每一行表示一個訓練文字的詞頻統計結果。其思想是，先根據所有訓練文字，不考慮其出現順序，只將訓練文字中每個出現過的詞彙單獨視為一列特徵，構成一個詞彙表(vocabulary 

  
 

    

    
    Java 文字從下向上滾動特效實現
       
 
 
  
   
 package com.image

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit 

  
 

    

    
    用Python開始機器學習（5：文字特徵抽取與向量化）
      
假設我們剛看完諾蘭的大片《星際穿越》，設想如何讓機器來自動分析各位觀眾對電影的評價到底是“贊”（positive）還是“踩”（negative）呢？
這類問題就屬於情感分析問題。這類問題處理的第一步，就是將文字轉換為特徵。
因此，這章我們只學習第一步，如何從文字中抽取特徵，並將其向量化。
由於中文的處理涉及 

  
 

    

    
    java 文字生成圖片
      
                
直接上程式碼:

import java.awt.*;   
import java.awt.image.*;   
import java.awt.font.*;   
import java.awt.geom.*; 
import java.io.File;
impor 

  
 

    

    
    基於sklearn的文字特徵提取與分類
      
                
文章開的比較久但內容沒怎麼寫，不好意思！

題目是80萬條簡訊作為訓練資料，10%的垃圾簡訊(label = 1)，90%正常簡訊(label = 0),然後在20萬條資料作為測試物件，找出垃圾簡訊與正常簡訊。我最終的評分是0.985，相對於第一0.997還是有很大差距，排 

  
 

    

    
    Java文字識別軟體-呼叫百度ocr實現文字識別
      java_baidu_ocr 
Java呼叫百度OCR文字識別API實現圖片文字識別軟體 
專案原始碼在文末，放到了GitHub上 - https://github.com/Ymy214/java_baidu_ocr 
 
 識別圖一  
 圖一識別結果  
 識別圖二  
 圖二識別結果  
 識別圖三   

  
 

    

    
    NLP11-基於Gensim的文字相似性挖掘[LsiModel]
      
                摘要：通過對資料的抓取，基於jieba分詞，去掉停用詞，運用Gensim建立詞典，生成BOW語料，執行tfidf模型計算詞權重，採用LsiModel進行降維，最後運用Gensim提供的MatrixSimilarity類來計算兩文件的相似性【基於餘弦的距離的計算】。1. 爬取資 

  
 

    

    
    總結 | 常用文字特徵選擇
      
                    

                    

                    
                    
                    在機器學習中，特徵屬性的選擇通常關係到訓練結果的可靠性，一個好的特徵屬性通常能起到滿意的分類效果 

  
 

    

    
    Java文字檔案讀寫
      
								
								            
						
                String filePath = new File("").getAbsolutePath() + "/src/file/" + "waitUse" + ".txt";
            Fil 

  
 

    

    
    文字特徵提取_03：基於詞頻數的文件向量CountVectorizer
      
							
							
							王小草SparkML筆記



筆記整理時間：2017年1月10日 
筆記整理者：王小草



1. 基於詞頻數的文件向量

在文字特徵提取_01和02中分別介紹了TF-IDF文件矩陣和基於神經網路的word2vec詞嵌入矩陣。本文我們要介紹的是一個非常基礎非常