如何實現一個基本的微信文章分類器

時間 2019-11-07

標籤如何實現一個基本微信文章分類器简体版

原文原文鏈接

本文源地址： http://www.fullstackyang.com/...，轉發請註明該地址或segmentfault地址，謝謝！

微信公衆號發佈的文章和通常門戶網站的新聞文本類型有所不一樣，一般不能用現有的文本分類器直接對這些文章進行分類，不過文本分類的原理是相通的，本文以微信公衆號文章爲對象，介紹樸素貝葉斯分類器的實現過程。html

文本分類的科學原理和數學證實在網上有不少，這裏就不作贅述，本文儘可能使用通熟易懂的表述方式，簡明扼要地梳理一下文本分類器的各個知識點。java

參考了一下Github，發現少有Java 8風格的實現，因此這裏的實現儘可能利用Java 8的特性，相比以前優點有不少，例如stream在統計聚合等運算上比較方便，代碼不只簡潔，並且更加語義化，另外在多線程並行控制上也省去很多的工做。git

本項目的地址：https://github.com/fullstacky...github

1、文本分類器的概述

文本分類器能夠看做是一個預測函數，在給定的文本時，在預約的類別集合中，判斷該文本最可能屬於哪一個類。算法

這裏須要注意兩個問題：segmentfault

在文本中含有比較多的標點符號和停用詞（的，是，了等），直接使用整段文本處理確定會產生不少沒必要要的計算，並且計算量也很是大，所以須要把給定的文本有效地進行表示，也就是選擇一系列的特徵詞來表明這篇文本，這些特徵詞既能夠比較好地反應所屬文本的內容，又能夠對不一樣文本有比較好的區分能力。
在進行文本表示以後，如何對這些特徵詞進行預測，這就是分類器的算法設計問題了，比較常見的模型有樸素貝葉斯，基於支持向量機（SVM），K-近鄰（KNN），決策樹等分類算法。這裏咱們選擇簡單易懂的樸素貝葉斯算法。在機器學習中，樸素貝葉斯建模屬於有監督學習，所以須要收集大量的文本做爲訓練語料，並標註分類結果

綜上，實現一個分類器一般分爲如下幾個步驟：微信

收集並處理訓練語料，以及最後測試用的測試語料
在訓練集上進行特徵選擇，獲得一系列的特徵項（詞），這些特徵項組成了所謂的特徵空間
爲了表示某個特徵項在不一樣文檔中的重要程度，計算該特徵項的權重，經常使用的計算方法有TF-IDF，本文采用的是「經典」樸素貝葉斯模型，這裏不考慮特徵項的權重（固然，必定要作也能夠）
訓練模型，對於樸素貝葉斯模型來講，主要的是計算每一個特徵項在不一樣類別中的條件機率，這點下面再作解釋。
預測文本，模型訓練完成以後能夠保存到文件中，在預測時直接讀入模型的數據進行計算。

2、準備訓練語料

這裏須要的語料就是微信公衆號的文章，咱們能夠抓取搜狗微信搜索網站（http://weixin.sogou.com/）首頁上已經分類好的文章，直接採用其分類結果，這樣也省去了標註的工做。至於如何開發爬蟲去抓取文章，這裏就再也不討論了。多線程

「熱門」這類別下的文章不具備通常性，所以不把它看成一個類別。剔除「熱門」類別以後，最終咱們抓取了30410篇文章，總共20個類別，每一個類別的文章數並不均衡，其中最多的是「養生堂」類別，有2569篇文章，最少的是「軍事」類別，有654篇，大致符合微信上文章的分佈狀況。在保存時，咱們保留了文章的標題，公衆號名稱，文章正文。機器學習

3、特徵選擇

如前文所述，特徵選擇的目的是下降特徵空間的維度，避免維度災難。簡單地說，假設咱們選擇了2萬個特徵詞，也就是說計算機經過學習，獲得了一張有2萬個詞的「單詞表」，之後它遇到的全部文本能夠夠用這張單詞表中的詞去表示其內容大意。這些特徵詞針對不一樣的類別有必定的區分能力，舉例來講，「殲擊機」可能來自「軍事」，「越位」可能來自「體育」，「漲停」可能來自「財經」等等，而一般中文詞彙量要比這個數字大得多，一本常見的漢語詞典收錄的詞條數可達數十萬。ide

常見的特徵選擇方法有兩個，信息增益法和卡方檢驗法。

3.1 信息增益

信息增益法的衡量標準是，這個特徵項能夠爲分類系統帶來多少信息量，所謂的信息增益就是該特徵項包含的可以幫預測類別的信息量，這裏所說的信息量能夠用熵來衡量，計算信息增益時還須要引入條件熵的概念，公式以下

可能有些見到公式就頭大的小夥伴不太友好，不過這個公式雖然看起來有點複雜，其實在計算中仍是比較簡單的，解釋一下：

P(Cj)：Cj類文檔在整個語料中出現的機率；

P(ti)：語料中包含特徵項ti的文檔的機率，取反就是不包含特徵項ti的文檔的機率；

P(Cj|ti)：文檔包含特徵項ti且屬於Cj類的條件機率，取反就是文檔不包含特徵項ti且屬於Cj類的條件機率

上面幾個機率值，均可以比較方便地從訓練語料上統計獲得。若還有不明白的小夥伴，推薦閱讀這篇博客：文本分類入門（十一）特徵選擇方法之信息增益

3.2 卡方檢驗

卡方檢驗，基於χ2統計量(CHI)來衡量特徵項ti和類別Cj之間的相關聯程度，CHI統計值越高，該特徵項與該類的相關性越大，若是二者相互獨立，則CHI統計值接近零。計算時須要根據一張相依表（contingency table），公式也比較簡單：

其中N就是文檔總數，若是想繼續討論這個公式，推薦閱讀這篇博客：特徵選擇（3）-卡方檢驗

3.3 算法實現

不論何種方式都須要對每一個特徵項進行估算，而後根據所得的數值進行篩選，一般能夠設定一個閾值，低於閾值的特徵項能夠直接從特徵空間中移除，另外也能夠按照數值從高到低排序，並指定選擇前N個。這裏咱們採用後者，總共截取前2萬個特徵項。

特徵選擇實現類的代碼以下，其中，不一樣特徵選擇方法需實現Strategy接口，以得到不一樣方法計算獲得的估值，這裏在截取特徵項時爲了不沒必要要的麻煩，剔除了字符串長度爲1的詞。

Doc對象表示一篇文檔，其中包含了該文檔的所屬分類，以及分詞結果（已經濾掉了停用詞等），即Term集合；

Term對象主要包含3個字段，詞自己的字符串，詞性（用於過濾），詞頻TF；

Feature表示特徵項，一個特徵項對應一個Term對象，還包含兩個hashmap，一個用來統計不一樣類別下該特徵項出現的文檔數量（categoryDocCounter），另外一個用來統計不一樣類別下該特徵項出現的頻度（categoryTermCounter）（對應樸素貝葉斯兩種不一樣模型，下文詳述）

統計時引入FeatureCounter對象，使用stream的reduce方法進行歸約。主要的思想就是把每個文檔中的Term集合，映射爲Term和Feature的鍵值對，而後再和已有的Map進行合併，合併時若是遇到相同的Term，則調用Feature的Merge方法，該方法會將雙方term的詞頻，以及categoryDocCounter和categoryTermCounter中的統計結果進行累加。最終將全部文檔所有統計完成返回Feature集合。

@AllArgsConstructor
public class FeatureSelection {

    interface Strategy {
        Feature estimate(Feature feature);
    }

    private final Strategy strategy;
    private final static int FEATURE_SIZE = 20000;

    public List<Feature> select(List<Doc> docs) {
        return createFeatureSpace(docs.stream())
                .stream()
                .map(strategy::estimate)
                .filter(f -> f.getTerm().getWord().length() > 1)
                .sorted(comparing(Feature::getScore).reversed())
                .limit(FEATURE_SIZE)
                .collect(toList());
    }

    private Collection<Feature> createFeatureSpace(Stream<Doc> docs) {

        @AllArgsConstructor
        class FeatureCounter {
            private final Map<Term, Feature> featureMap;

            private FeatureCounter accumulate(Doc doc) {
                Map<Term, Feature> temp = doc.getTerms().parallelStream()
                        .map(t -> new Feature(t, doc.getCategory()))
                        .collect(toMap(Feature::getTerm, Function.identity()));
                if (!featureMap.isEmpty())
                    featureMap.values().forEach(f -> temp.merge(f.getTerm(), f, Feature::merge));
                return new FeatureCounter(temp);
            }

            private FeatureCounter combine(FeatureCounter featureCounter) {
                Map<Term, Feature> temp = Maps.newHashMap(featureMap);
                featureCounter.featureMap.values().forEach(f -> temp.merge(f.getTerm(), f, Feature::merge));
                return new FeatureCounter(temp);
            }
        }

        FeatureCounter counter = docs.parallel()
                .reduce(new FeatureCounter(Maps.newHashMap()),
                        FeatureCounter::accumulate,
                        FeatureCounter::combine);
        return counter.featureMap.values();
    }
}
public class Feature {
...
    public Feature merge(Feature feature) {
        if (this.term.equals(feature.getTerm())) {
            this.term.setTf(this.term.getTf() + feature.getTerm().getTf());
            feature.getCategoryDocCounter()
                    .forEach((k, v) -> categoryDocCounter.merge(k, v, (oldValue, newValue) -> oldValue + newValue));
            feature.getCategoryTermCounter()
                    .forEach((k, v) -> categoryTermCounter.merge(k, v, (oldValue, newValue) -> oldValue + newValue));
        }
        return this;
    }
}

信息增益實現以下，在計算條件熵時，利用了stream的collect方法，將包含和不包含特徵項的兩種狀況用一個hashmap分開再進行歸約。

@AllArgsConstructor
public class IGStrategy implements FeatureSelection.Strategy {

    private final Collection<Category> categories;

    private final int total;

    public Feature estimate(Feature feature) {
        double totalEntropy = calcTotalEntropy();
        double conditionalEntrogy = calcConditionEntropy(feature);
        feature.setScore(totalEntropy - conditionalEntrogy);
        return feature;
    }

    private double calcTotalEntropy() {
        return Calculator.entropy(categories.stream().map(c -> (double) c.getDocCount() / total).collect(toList()));
    }

    private double calcConditionEntropy(Feature feature) {
        int featureCount = feature.getFeatureCount();
        double Pfeature = (double) featureCount / total;

        Map<Boolean, List<Double>> Pcondition = categories.parallelStream().collect(() -> new HashMap<Boolean, List<Double>>() {{
                    put(true, Lists.newArrayList());
                    put(false, Lists.newArrayList());
                }}, (map, category) -> {
                    int countDocWithFeature = feature.getDocCountByCategory(category);
                    //出現該特徵詞且屬於類別key的文檔數量/出現該特徵詞的文檔總數量
                    map.get(true).add((double) countDocWithFeature / featureCount);
                    //未出現該特徵詞且屬於類別key的文檔數量/未出現該特徵詞的文檔總數量
                    map.get(false).add((double) (category.getDocCount() - countDocWithFeature) / (total - featureCount));
                },
                (map1, map2) -> {
                    map1.get(true).addAll(map2.get(true));
                    map1.get(false).addAll(map2.get(false));
                }
        );
        return Calculator.conditionalEntrogy(Pfeature, Pcondition.get(true), Pcondition.get(false));
    }
}

卡方檢驗實現以下，每一個特徵項要在每一個類別上分別計算CHI值，最終保留其最大值

@AllArgsConstructor
public class ChiSquaredStrategy implements Strategy {

    private final Collection<Category> categories;

    private final int total;

    @Override
    public Feature estimate(Feature feature) {

        class ContingencyTable {
            private final int A, B, C, D;

            private ContingencyTable(Feature feature, Category category) {
                A = feature.getDocCountByCategory(category);
                B = feature.getFeatureCount() - A;
                C = category.getDocCount() - A;
                D = total - A - B - C;
            }
        }

        Double chisquared = categories.stream()
                .map(c -> new ContingencyTable(feature, c))
                .map(ct -> Calculator.chisquare(ct.A, ct.B, ct.C, ct.D))
                .max(Comparator.comparingDouble(Double::valueOf)).get();
        feature.setScore(chisquared);
        return feature;
    }
}

4、樸素貝葉斯模型

4.1 原理簡介

樸素貝葉斯模型之因此稱之「樸素」，是由於其假設特徵之間是相互獨立的，在文本分類中，也就是說，一篇文檔中出現的詞都是相互獨立，彼此沒有關聯，顯然文檔中出現的詞都是有邏輯性的，這種假設在現實中幾乎是不成立的，可是這種假設卻大大簡化了計算，根據貝葉斯公式，文檔Doc屬於類別Ci的機率爲：

P(Ci|Doc)是所求的後驗機率，咱們在斷定分類時，根據每一個類別計算P(Ci|Doc)，最終把P(Ci|Doc)取得最大值的那個分類做爲文檔的類別。其中，P(Doc)對於類別Ci來講是常量，在比較大小時能夠不用參與計算，而P(Ci)表示類別Ci出現的機率，咱們稱之爲先驗機率，這能夠方便地從訓練集中統計得出，至於P(Doc|Ci)，也就是類別的條件機率，若是沒有樸素貝葉斯的假設，那麼計算是很是困難的。

舉例來講，假設有一篇文章，內容爲「王者榮耀：兩款傳說品質皮膚將優化，李白最新模型海報爆料」，通過特徵選擇，文檔能夠表示爲Doc=(王者榮耀，傳說，品質，皮膚，優化，李白，最新，模型，海報，爆料)，那麼在預測時須要計算P(王者榮耀，傳說，品質，皮膚，優化，李白，最新，模型，海報，爆料|Ci)，這樣一個條件機率是不可計算的，由於第一個特徵取值爲「王者榮耀」，第二個特徵取值「傳說」……第十個特徵取值「爆料」的文檔極可能爲沒有，那麼機率就爲零，而基於樸素貝葉斯的假設，這個條件機率能夠轉化爲：

P(王者榮耀，傳說，品質，皮膚，優化，李白，最新，模型，海報，爆料|Ci)=P(王者榮耀|Ci)P(傳說|Ci)……P(爆料|Ci)

因而咱們就能夠統計這些特徵詞在每一個類別中出現的機率了，在這個例子中，遊戲類別中「王者榮耀」這個特徵項會頻繁出現，所以P(王者榮耀|遊戲)的條件機率要明顯高於其餘類別，這就是樸素貝葉斯模型的樸素之處，粗魯的聰明。

4.2 多項式模型與伯努利模型

在具體實現中，樸素貝葉斯又能夠分爲兩種模型，多項式模型（Multinomial）和伯努利模型（Bernoulli），另外還有高斯模型，主要用於處理連續型變量，在文本分類中不討論。

多項式模型和伯努利模型的區別在於對詞頻的考察，在多項式模型中文檔中特徵項的頻度是參與計算的，這對於長文原本說是比較公平的，例如上面的例子，「王者榮耀」在遊戲類的文檔中頻度會比較高，而伯努利模型中，全部特徵詞都均等地對待，只要出現就記爲1，未出現就記爲0，二者公式以下：

在伯努利模型計算公式中，N(Doc(tj)|Ci)表示Ci類文檔中特徵tj出現的文檔數，|D|表示類別Ci的文檔數，P(Ci)能夠用類別Ci的文檔數/文檔總數來計算，

在多項式模型計算公式中，TF(ti,Doc)是文檔Doc中特徵ti出現的頻度，TF(ti,Ci)就表示類別Ci中特徵ti出現的頻度，|V|表示特徵空間的大小，也就是特徵選擇以後，不一樣（即去掉重複以後）的特徵項的總個數，而P(Ci)能夠用類別Ci中特徵詞的總數/全部特徵詞的總數，全部特徵詞的總數也就是全部特徵詞的詞頻之和。

至於分子和分母都加上必定的常量，這是爲了防止數據稀疏而產生結果爲零的現象，這種操做稱爲拉普拉斯平滑，至於背後的原理，推薦閱讀這篇博客：貝葉斯統計觀點下的拉普拉斯平滑

4.3 算法實現

這裏使用了枚舉類來封裝兩個模型，並實現了分類器NaiveBayesClassifier和訓練器NaiveBayesLearner中的兩個接口，其中Pprior和Pcondition是訓練器所需的方法，前者用來計算先驗機率，後者用來計算不一樣特徵項在不一樣類別下的條件機率；getConditionProbability是分類器所需的方法，NaiveBayesKnowledgeBase對象是模型數據的容器，它的getPconditionByWord方法就是用於查詢不一樣特徵詞在不一樣類別下的條件機率

public enum NaiveBayesModels implements NaiveBayesClassifier.Model, NaiveBayesLearner.Model {
    Bernoulli {
        @Override
        public double Pprior(int total, Category category) {
            int Nc = category.getDocCount();
            return Math.log((double) Nc / total);
        }

        @Override
        public double Pcondition(Feature feature, Category category, double smoothing) {
            int Ncf = feature.getDocCountByCategory(category);
            int Nc = category.getDocCount();
            return Math.log((double) (1 + Ncf) / (Nc + smoothing));
        }

        @Override
        public List<Double> getConditionProbability(String category, List<Term> terms, final NaiveBayesKnowledgeBase knowledgeBase) {
            return terms.stream().map(term -> knowledgeBase.getPconditionByWord(category, term.getWord())).collect(toList());
        }
    },
    Multinomial {
        @Override
        public double Pprior(int total, Category category) {
            int Nt = category.getTermCount();
            return Math.log((double) Nt / total);
        }

        @Override
        public double Pcondition(Feature feature, Category category, double smoothing) {
            int Ntf = feature.getTermCountByCategory(category);
            int Nt = category.getTermCount();
            return Math.log((double) (1 + Ntf) / (Nt + smoothing));
        }

        @Override
        public List<Double> getConditionProbability(String category, List<Term> terms, final NaiveBayesKnowledgeBase knowledgeBase) {
            return terms.stream().map(term -> term.getTf() * knowledgeBase.getPconditionByWord(category, term.getWord())).collect(toList());
        }
    };
}

5、訓練模型

根據樸素貝葉斯模型的定義，訓練模型的過程就是計算每一個類的先驗機率，以及每一個特徵項在不一樣類別下的條件機率，NaiveBayesKnowledgeBase對象將訓練器在訓練時獲得的結果都保存起來，訓練完成時寫入文件，啓動分類時從文件中讀入數據交由分類器使用，那麼在分類時就能夠直接參與到計算過程當中。

訓練器的實現以下：

public class NaiveBayesLearner {
    ……
    ……
    public NaiveBayesLearner statistics() {
        log.info("開始統計...");
        this.total = total();
        log.info("total : " + total);
        this.categorySet = trainSet.getCategorySet();
        featureSet.forEach(f -> f.getCategoryTermCounter().forEach((category, count) -> category.setTermCount(category.getTermCount() + count)));
        return this;
    }

    public NaiveBayesKnowledgeBase build() {
        this.knowledgeBase.setCategories(createCategorySummaries(categorySet));
        this.knowledgeBase.setFeatures(createFeatureSummaries(featureSet, categorySet));
        return knowledgeBase;
    }

    private Map<String, NaiveBayesKnowledgeBase.FeatureSummary> createFeatureSummaries(final Set<Feature> featureSet, final Set<Category> categorySet) {
        return featureSet.parallelStream()
                .map(f -> knowledgeBase.createFeatureSummary(f, getPconditions(f, categorySet)))
                .collect(toMap(NaiveBayesKnowledgeBase.FeatureSummary::getWord, Function.identity()));
    }

    private Map<String, Double> createCategorySummaries(final Set<Category> categorySet) {
        return categorySet.stream().collect(toMap(Category::getName, c -> model.Pprior(total, c)));
    }

    private Map<String, Double> getPconditions(final Feature feature, final Set<Category> categorySet) {
        final double smoothing = smoothing();
        return categorySet.stream()
                .collect(toMap(Category::getName, c -> model.Pcondition(feature, c, smoothing)));
    }

    private int total() {
        if (model == Multinomial)
            return featureSet.parallelStream().map(Feature::getTerm).mapToInt(Term::getTf).sum();//總詞頻數
        else if (model == Bernoulli)
            return trainSet.getTotalDoc();//總文檔數
        return 0;
    }

    private double smoothing() {
        if (model == Multinomial)
            return this.featureSet.size();
        else if (model == Bernoulli)
            return 2.0;
        return 0.0;
    }

    public static void main(String[] args) {
        TrainSet trainSet = new TrainSet(System.getProperty("user.dir") + "/trainset/");

        log.info("特徵選擇開始...");
        FeatureSelection featureSelection = new FeatureSelection(new ChiSquaredStrategy(trainSet.getCategorySet(), trainSet.getTotalDoc()));
        List<Feature> features = featureSelection.select(trainSet.getDocs());
        log.info("特徵選擇完成,特徵數:[" + features.size() + "]");

        NaiveBayesModels model = NaiveBayesModels.Multinomial;
        NaiveBayesLearner learner = new NaiveBayesLearner(model, trainSet, Sets.newHashSet(features));
        learner.statistics().build().write(model.getModelPath());
        log.info("模型文件寫入完成,路徑:" + model.getModelPath());
    }
}

在main函數中執行整個訓練過程，首先執行特徵選擇，這裏使用卡方檢驗法，而後將獲得特徵空間，樸素貝葉斯模型（多項式模型），以及訓練集TrainSet對象做爲參數，初始化訓練器，接着訓練器開始進行統計的工做，事實上有一部分的統計工做，在初始化訓練集對象時，就已經完成了，例如總文檔數，每一個類別下的文檔數等，這些能夠直接拿過來使用，最終將數據都裝載到NaiveBayesKnowledgeBase對象當中去，並寫入文件，格式爲第一行是不一樣類別的先驗機率，餘下每一行對應一個特徵項，每一列對應不一樣類別的條件機率值。

六，測試模型

分類器預測過程就相對於比較簡單了，經過NaiveBayesKnowledgeBase讀入數據，而後將指定的文本進行分詞，匹配特徵項，而後計算在不一樣類別下的後驗機率，返回取得最大值對應的那個類別。

public class NaiveBayesClassifier {
    ……
    private final Model model;

    private final NaiveBayesKnowledgeBase knowledgeBase;

    public NaiveBayesClassifier(Model model) {
        this.model = model;
        this.knowledgeBase = new NaiveBayesKnowledgeBase(model.getModelPath());
    }

    public String predict(String content) {
        Set<String> allFeatures = knowledgeBase.getFeatures().keySet();
        List<Term> terms = NLPTools.instance().segment(content).stream()
                .filter(t -> allFeatures.contains(t.getWord())).distinct().collect(toList());

        @AllArgsConstructor
        class Result {
            final String category;
            final double probability;
        }

        Result result = knowledgeBase.getCategories().keySet().stream()
                .map(c -> new Result(c, Calculator.Ppost(knowledgeBase.getCategoryProbability(c),
                        model.getConditionProbability(c, terms, knowledgeBase))))
                .max(Comparator.comparingDouble(r -> r.probability)).get();
        return result.category;
    }
}

在實際測試時，咱們又單獨抓取了搜狗微信搜索網站上的文章，按照100篇一組，一共30組進行分類的測試，最終結果每一組的準確率均在90%以上，最高達98%，效果良好。固然正規的評測須要同時評估準確率和召回率，這裏就偷懶不作了。

另外還須要說明一點的是，因爲訓練集是來源於搜狗微信搜索網站的文章，類別僅限於這20個，這不足以覆蓋全部微信公衆號文章的類別，所以在測試其餘來源的微信文章準確率必定會有所影響。固然若是有更加豐富的微信文章訓練集的話，也能夠利用這個模型從新訓練，那麼效果也會愈來愈好。