朴素貝葉斯演算法

一、朴素貝葉斯分類演算法簡述

　　1、貝葉斯公式和全概率公式

　　舉一個概率論中的例子。設某工廠有甲、乙、丙三個車間生產同一種產品，已知各車間的產量分別占全廠產量的25%、35%、40%，而且各車間的次品率依次為5%、4%、2%。現問：

　　(1)生產的產品是次品的概率是多少？

　　(2)如果是次品，該次品是甲工廠生產的概率是多少？

　　顯然：

　　設一個產品屬於甲、乙、丙工廠的概率分別為P(A) = 0.25, P(B) = 0.35, P(C) = 0.4。如果用no 表示次品，則有p(no|A) = 0.05, p(no|B) = 0.04, p(no|C) = 0.02。

　　那麼對於第一問，可以用全概率公式計算:

　　p(no) = p(no|A)*p(A) + p(no|B)*p(B) + p(no|C)*p(C) = 0.25*0.05 + 0.35*0.04 + 0.4*0.02 = 0.0345

　　對於第二問，則計算p(no)中出現p(no|A)*p(A)的概率即可:

　　p(A|no) = p(no|A)*p(A) / p(no) = 0.3623

　　2、朴素貝葉斯之核

　　貝葉斯分類演算法的一個核心思想是：如果知道某些特征，怎麼可以確定它屬於哪個類別？

　　觀察貝葉斯公式:

　　　　　　$$P(Y|X) = \frac{P(X|Y)P(Y)}{P(X)}$$

　　我們可以借用貝葉斯公式，將貝葉斯分類器表達為:

　　　　　　$$ P("屬於某類"|"具有某些特征") = \frac{P("具有某些特征"|"屬於某類") P("屬於某類")}{P("具有某特征")} $$

　　對於上面的一些概率，作如下解釋:

　　　　1.P("具有某些特征"|"屬於某類")：在已知某樣本"屬於某類"的條件下，該樣本"具有某特征"的概率。對於已有的訓練集，這個條件是已知的。

　　　　2.P("屬於某類")：在未知某樣本"具有某特征"的條件下，該樣本"屬於某類"的概率。對於已有的訓練集，這個條件也是已知的。比如100個樣本，有60個是a，有40個是b。那麼在不知道新樣本的具體數值時，我們認為它屬於a的概率是60%，屬於b的概率是40%。它叫作先驗概率。

　　　　3.P("具有某特征")：在未知某樣本"屬於某類"的條件下，該樣本"具有某特征"的概率。對於一個給定的樣本，我們認為它具有某特征的概率恆為1，因為它的特征已完全給定。

　　　　4.P("屬於某類"|"具有某特征")：在已知某樣本"具有某特征"的條件下，該樣本"屬於某類"的概率。它叫作後驗概率。這是我們想要得到的結果。

　　由此可見，對於P("屬於某類"|"具有某特征")的計算，只需要計算P("具有某些特征"|"屬於某類") P("屬於某類")即可。而P("屬於某類")在給定帶標簽的數據集時可以很簡便的計算得到，所以計算P("具有某些特征"|"屬於某類")才是朴素貝葉斯分類器的核心。

　　值得註意的是：全概率公式要求條件概率兩兩獨立。為了滿足其要求，朴素貝葉斯分類器在套用貝葉斯公式時，也假定所有的特征兩兩獨立。儘管在現實中這是不可能的，但在某些應用場景中，朴素貝葉斯的分類效果仍然令人驚嘆。

　　3、朴素貝葉斯之刃

　　朴素貝葉斯分類器通常出現在文本處理中。提到文本處理就應想到它的一系列流程：獲取文檔、切詞(用戶字典)、清洗(包括停用詞、特殊字元、標點符號等)、降維(稀疏矩陣)、構建向量空間模型(TF-IDF)、建模(LDA等), 或者構建word2Vec、建模(RNN、LSTM)。

　　朴素貝葉斯既然認為詞與詞之間的是相互獨立的，顯然要立足於向量空間模型(Vector space model)。

　　向量空間模型做法如下：

　　　　將所有語句中的詞生成唯一值(bag of words)序列，作為特征向量。每條語句(文本)出現詞的頻數作為行向量。從而構成向量空間模型。

　　舉個例子：

import numpy as np
import pandas as pd
lis = [
    ["dog", "cat", "fish"],
    ["lion", "tiger"],
    ["cat", "fish"],
    ["dog"],
]
bags = list(set([word for row in lis for word in row]))
vsm = np.zeros([len(lis), len(bags)])
for i, row in enumerate(lis):
    for word in row:
        vsm[i, bags.index(word)] += 1
vsm = pd.DataFrame(vsm, columns=bags)
print(vsm)

　　列印結果為：

　　TF-IDF在向量空間模型的基礎上，對每個詞的權重做了一些處理。它認為，如果一個詞在該條句子(對應上表中的一行)中出現的頻率非常高，並且在其它句子中出現的頻率又非常低，那麼這個詞代表的信息量就越大，其權重值也越大。TF(詞頻)用於計算一個詞在該條句子中的頻率，IDF(反文檔頻率)用於計算一個詞在每個句子中出現的頻率。

　　例如：

　　　　第0行dog的TF詞頻為:$\frac{[0, dog]}{[0, dog] + [0, fish] + [0, cat]} = 0.33$

　　　　第0行dog的IDF反文檔頻率為:$\log \frac{數據集長度}{[0, dog] + [3, dog]} = \log(4/2) = 0.69$

　　　　第0行dog的TF-IDF權重值為:$ 0.33 * 0.69 = 0.228 $

　　向量空間模型中所有元素的TF-IDF權重值構成的矩陣，稱為TF-IDF權重矩陣。TF-IDF權重矩陣為p("屬於某類"|"具有某些特征")的計算提供了基礎。

　　4、朴素貝葉斯演算法的流程

　　　　計算每個類別中的文檔數目和其頻率  # 實際計算P("屬於某類”)

　　　　對每篇訓練文檔：
        　 對每個類別：
            　　如果詞條出現在文檔中，增加該詞條的計數值
            　　增加所有詞條的計數值
        　 對每個類別：
            　　對每個詞條：
                  將該詞條的數目除以總詞條數目得到條件概率
        　返回每個類別的條件概率   # 實際計算P("具有某些特征"|"屬於某類")

二、python3實現朴素貝葉斯

　　1、python3實現朴素貝葉斯

　　創建LoadDataSet類，用於生成數據集；創建NavieBayes類，用於實現朴素貝葉斯。

　　　　NavieBayes：

　　　　train：訓練數據集

　　　　predict：測試數據集

　　　　_calc_wordfreq：

import numpy as np
import pandas as pd

class LoadDataSet(object):
    def get_dataSet(self):
        """lis是一行行文字切詞後的文檔集合，內容是斑點犬評論"""
        lis = [
            ["my", "dog", "has", "flea", "problems", "help", "please"],
            ["maybe", "not", "take", "him", "to", "dog", "park", "stupid"],
            ["my", "dalmation", "is", "so", "cute", "I", "love", "him"],
            ["stop", "posting", "stupid", "worthless", "garbage"],
            ["mr", "licks", "ate", "my", "steak", "how", "to", "stop", "him"],
            ["quit", "buying", "worthless", "dog", "food", "stupid"],
        ]
        vec= [0, 1, 0, 1, 0, 1]  # 1代表侮辱性文字，0代表正常言論；對應lis的6行數據
        return lis, vec

class NavieBayes(object):
    def __init__(self):
        self.Pcates = {}
        self.vocabulary  = None
        self.tf = None
    def train(self, trainSet, classVec):
        """訓練集計算"""
        self.Pcates = {
            label:{
                "prob": classVec.count(label)/len(classVec),  # 記錄P("屬於某類")
                "tdm": None                                   # 記錄p("具有某特征"|"屬於某類")
            } for label in set(classVec)
}  # 計算每個類別的先驗概率，保存成字典格式
        self.vocabulary = list(set([word for doc in trainSet for word in doc]))  # 生成詞袋
        self.tf = self._tf_idf(trainSet)
        self._bulid_tdm(trainSet, classVec)
    
    def _tf_idf(self, trainSet):
        """生成tf和idf"""
        # 心中要有tf-idf矩陣
        vocLength = len(self.vocabulary)
        docLength = len(trainSet)
        idf = np.zeros([1, vocLength])  # 因為vocabulary是特征向量,所以寫1 x N的向量,用以表示一個文檔向量中葛格慈的頻率
        tf = np.zeros([docLength, vocLength])  # tf矩陣：每個詞的詞頻矩陣
        for i, doc in enumerate(trainSet):
            for word in doc:   # 統計每一行中的每個詞在該行中出現的次數
                tf[i, self.vocabulary.index(word)] += 1  # 遍歷每個詞，計算其出現的次數並寫到tf矩陣對應的位置
            tf[i] = tf[i] / len(trainSet[i])
            # 這一行的tf除以該行文件中的詞總數(實際上就是row長度)以消除長短句的影響
            for singleword in set(doc):
                idf[0, self.vocabulary.index(singleword)] += 1  # 統計每個文檔里的詞在所有文檔里出現的次數
            idf = np.log(len(trainSet) / (idf + 1))   # +1是為了防止0除
        return np.multiply(tf, idf)
    
    def _bulid_tdm(self, trainSet, classVec):
        """計算每個類別下每個詞出現的概率"""
        tf_labels = np.c_[self.tf, labels]  # 在權重矩陣後面增加一列labels
        for label in self.Pcates.keys():
            label_tf_group = tf_labels[tf_labels[:, -1] == label][:, :-1]  # 獲取label類對應的tf子矩陣
            label_tf = np.sum(label_tf_group, axis=0)/np.sum(label_tf_group)  # 行累加除以總值
            self.Pcates[label]["tdm"] = label_tf  # p("具有某特征"|"屬於某類")
    
    def predict(self, test_wordList):
        """測試分類數據"""
        # 首先根據word_list生成詞向量
        test_wordArray = np.zeros([1, len(self.vocabulary)])
        for word in test_wordList:
            test_wordArray[0, self.vocabulary.index(word)] += 1
        # 其次計算p("具有某特征"|"屬於某類") * p("屬於某類")
        # 不計算p("具有某特征")是因為假定對於每個測試的樣本，它們具有的特征是完全隨機的，都是一樣的概率。
        pred_prob = 0
        pred_label = None
        for label, val in self.Pcates.items():
            test_prob = np.sum(test_wordArray * val["tdm"] * val["prob"])
            if test_prob > pred_prob:
                pred_prob = test_prob
                pred_label = label
        return {"predict_probability": round(pred_prob,4), "predict_label": pred_label}

　　來一段測試代碼：

load = LoadDataSet()
trainSet, labels = load.get_dataSet()
bayes = NavieBayes()
bayes.train(trainSet, labels)
bayes.predict(trainSet[0])

　　2、sikit-learn實現朴素貝葉斯

 　　這裡要用到sklearn.feature_extraction.text中的TfidfTransformer和CountVectorizer。

from sklearn import naive_bayes
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer

trainSet, labels = LoadDataSet().get_dataSet()
trainSet = [" ".join(row) for row in trainSet]

vectorizer = CountVectorizer()     # 用拼接的句子輸入，它要生成svm，不接受長短不一的列表
transformer = TfidfTransformer()   # tf-idf權重矩陣

vsm = vectorizer.fit_transform(trainSet)  # 訓練vsm模型
# print(vsm.toarray())  
# 更多方法請參閱 http://scikit-learn.org/stable/modules/feature_extraction.html#common-vectorizer-usage
tfidf = transformer.fit_transform(svm)    # 轉換成tf-idf模型

# 生成測試用的數據
test = vectorizer.transform([trainSet[0]])
test = transformer.transform(test)

# 這裡用混合貝葉斯模型；有興趣的可以看伯努利模型、高斯模型
bys = naive_bayes.MultinomialNB()
bys.fit(tfidf, labels)

testData = trainSet[0]
bys.predict(test)