機器學習實戰之樸素貝葉斯--python/scikit-learn實現

理論基礎知識

貝葉斯與大多數機器學習算法不同，如：決策樹，邏輯迴歸，支持向量機等都是判別方法，也就是直接學習出特徵輸出Y和特徵X之間的關係，通過一個決策函數Y=f(X)或者條件分佈P(Y|X)。今天的主角貝葉斯是生成方法，找出特徵輸出Y和特徵X的聯合分佈P(X,Y),然後用P(Y|X)=P(X,Y)/P(X)得出。

基本思想

樸素貝葉斯假設：自變量特徵之間條件獨立

貝葉斯學派的思想可以概括爲 先驗概率+數據=後驗概率（言外之意：我們在實際問題中想要得到的後驗概率，可以通過先驗概率和數據一起綜合得到）

條件獨立:如果X,Y互相獨立，則有

條件概率：

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

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

最後得到貝葉斯公式：

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

貝葉斯模型

現在我們來看一下怎麼操作。假設我有m個樣本數據：

$\left(x_{1}^{(1)}, x_{2}^{(1)}, \ldots x_{n}^{(1)}, y_{1}\right),\left(x_{1}^{(2)}, x_{2}^{(2)}, \ldots x_{n}^{(2)}, y_{2}\right), \ldots\left(x_{1}^{(m)}, x_{2}^{(m)}, \ldots x_{n}^{(m)}, y_{n}\right)$

每一個樣本特徵X有n個體徵，標籤Y有K個類別，定義爲爲：

從已有的樣本，我們很容易得到先驗概率分佈 (k=1,,,,K)

再來看條件概率分佈：

$P\left(X=x | Y=C_{k}\right)=P\left(X_{1}=x_{1}, X_{2}=x_{2}, \ldots X_{n}=x_{n} | Y=C_{k}\right)$

然後我們就可以用貝葉斯公式得到X,Y的聯合分佈P(X,Y)了，聯合分佈P(X,Y)定義爲：

$P\left(X, Y=C_{k}\right)=P\left(Y=C_{k}\right) P\left(X=x | Y=C_{k}\right)=P\left(Y=C_{k}\right) P\left(X_{1}=x_{1}, X_{2}=x_{2}, \ldots X_{n}=x_{n} | Y=C_{k}\right)$

從上面可以看出我們的很容易得到，統計一下各類被佔的比例（頻數）就能求得。

但是 $P\left(X_{1}=x_{1}, X_{2}=x_{2}, \ldots X_{n}=x_{n} | Y=C_{k}\right)$ 很難求出，因爲這是一個很複雜的有n個維度的條件分佈，因此樸素貝葉斯在這裏做了一個大膽的假設：X的n個維度之間相互獨立（也就是，特徵之間條件獨立），這樣就可以得到：

$P\left(X_{1}=x_{1}, X_{2}=x_{2}, \ldots X_{n}=x_{n} | Y=C_{k}\right)=P\left(X_{1}=x_{1} | Y=C_{k}\right) P\left(X_{2}=x_{2} | Y=C_{k}\right) \ldots P\left(X_{n}=x_{n} | Y=C_{k}\right)$

這大大的簡化了n維條件概率分佈的難度，雖然很粗暴，但是很給力。

手動計算實例一：

實戰項目--屏蔽社區留言板的侮辱性言論

Python版本

def loadDataSet():
    """
    創建數據集
    :return: 單詞列表postingList, 所屬類別classVec
    """
    postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'], #[0,0,1,1,1......]
                   ['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']]
    classVec = [0, 1, 0, 1, 0, 1]  # 1 is abusive, 0 not
    return postingList, classVec


def createVocabList(dataSet):
    """
    獲取所有單詞的集合
    :param dataSet: 數據集
    :return: 所有單詞的集合(即不含重複元素的單詞列表)
    """
    vocabSet = set([])  # create empty set
    for document in dataSet:
        # 操作符 | 用於求兩個集合的並集
        vocabSet = vocabSet | set(document)  # union of the two sets
    return list(vocabSet)


def setOfWords2Vec(vocabList, inputSet):
    """
    遍歷查看該單詞是否出現，出現該單詞則將該單詞置1
    :param vocabList: 所有單詞集合列表
    :param inputSet: 輸入數據集
    :return: 匹配列表[0,1,0,1...]，其中 1與0 表示詞彙表中的單詞是否出現在輸入的數據集中
    """
    # 創建一個和詞彙表等長的向量，並將其元素都設置爲0
    returnVec = [0] * len(vocabList)# [0,0......]
    # 遍歷文檔中的所有單詞，如果出現了詞彙表中的單詞，則將輸出的文檔向量中的對應值設爲1
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
        else:
            print "the word: %s is not in my Vocabulary!" % word
    return returnVec


def _trainNB0(trainMatrix, trainCategory):
    """
    訓練數據原版
    :param trainMatrix: 文件單詞矩陣 [[1,0,1,1,1....],[],[]...]
    :param trainCategory: 文件對應的類別[0,1,1,0....]，列表長度等於單詞矩陣數，其中的1代表對應的文件是侮辱性文件，0代表不是侮辱性矩陣
    :return:
    """
    # 文件數
    numTrainDocs = len(trainMatrix)
    # 單詞數
    numWords = len(trainMatrix[0])
    # 侮辱性文件的出現概率，即trainCategory中所有的1的個數，
    # 代表的就是多少個侮辱性文件，與文件的總數相除就得到了侮辱性文件的出現概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 構造單詞出現次數列表
    p0Num = zeros(numWords) # [0,0,0,.....]
    p1Num = zeros(numWords) # [0,0,0,.....]

    # 整個數據集單詞出現總數
    p0Denom = 0.0
    p1Denom = 0.0
    for i in range(numTrainDocs):
        # 是否是侮辱性文件
        if trainCategory[i] == 1:
            # 如果是侮辱性文件，對侮辱性文件的向量進行加和
            p1Num += trainMatrix[i] #[0,1,1,....] + [0,1,1,....]->[0,2,2,...]
            # 對向量中的所有元素進行求和，也就是計算所有侮辱性文件中出現的單詞總數
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # 類別1，即侮辱性文檔的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表
    # 即 在1類別下，每個單詞出現的概率
    p1Vect = p1Num / p1Denom# [1,2,3,5]/90->[1/90,...]
    # 類別0，即正常文檔的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表
    # 即 在0類別下，每個單詞出現的概率
    p0Vect = p0Num / p0Denom
    return p0Vect, p1Vect, pAbusive

def trainNB0(trainMatrix, trainCategory):
    """
    訓練數據優化版本
    :param trainMatrix: 文件單詞矩陣
    :param trainCategory: 文件對應的類別
    :return:
    """
    # 總文件數
    numTrainDocs = len(trainMatrix)
    # 總單詞數
    numWords = len(trainMatrix[0])
    # 侮辱性文件的出現概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 構造單詞出現次數列表
    # p0Num 正常的統計
    # p1Num 侮辱的統計
    p0Num = ones(numWords)#[0,0......]->[1,1,1,1,1.....]
    p1Num = ones(numWords)

    # 整個數據集單詞出現總數，2.0根據樣本/實際調查結果調整分母的值（2主要是避免分母爲0，當然值可以調整）
    # p0Denom 正常的統計
    # p1Denom 侮辱的統計
    p0Denom = 2.0
    p1Denom = 2.0
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            # 累加辱罵詞的頻次
            p1Num += trainMatrix[i]
            # 對每篇文章的辱罵的頻次 進行統計彙總
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # 類別1，即侮辱性文檔的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
    p1Vect = log(p1Num / p1Denom)
    # 類別0，即正常文檔的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
    p0Vect = log(p0Num / p0Denom)
    return p0Vect, p1Vect, pAbusive

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    """
    使用算法：
        # 將乘法轉換爲加法
        乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
        加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
    :param vec2Classify: 待測數據[0,1,1,1,1...]，即要分類的向量
    :param p0Vec: 類別0，即正常文檔的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
    :param p1Vec: 類別1，即侮辱性文檔的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
    :param pClass1: 類別1，侮辱性文件的出現概率
    :return: 類別1 or 0
    """
    # 計算公式  log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
    # 大家可能會發現，上面的計算公式，沒有除以貝葉斯準則的公式的分母，也就是 P(w) （P(w) 指的是此文檔在所有的文檔中出現的概率）就進行概率大小的比較了，
    # 因爲 P(w) 針對的是包含侮辱和非侮辱的全部文檔，所以 P(w) 是相同的。
    # 使用 NumPy 數組來計算兩個向量相乘的結果，這裏的相乘是指對應元素相乘，即先將兩個向量中的第一個元素相乘，然後將第2個元素相乘，以此類推。
    # 我的理解是：這裏的 vec2Classify * p1Vec 的意思就是將每個詞與其對應的概率相關聯起來
    p1 = sum(vec2Classify * p1Vec) + log(pClass1) # P(w|c1) * P(c1) ，即貝葉斯準則的分子
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1) # P(w|c0) * P(c0) ，即貝葉斯準則的分子·
    if p1 > p0:
        return 1
    else:
        return 0


def testingNB():
    """
    測試樸素貝葉斯算法
    """
    # 1. 加載數據集
    listOPosts, listClasses = loadDataSet()
    # 2. 創建單詞集合
    myVocabList = createVocabList(listOPosts)
    # 3. 計算單詞是否出現並創建數據矩陣
    trainMat = []
    for postinDoc in listOPosts:
        # 返回m*len(myVocabList)的矩陣， 記錄的都是0，1信息
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    # 4. 訓練數據
    p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
    # 5. 測試數據
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)

Scikit-learn版本

import numpy as np


#獲取之前的數據loadDataSet()、createVocabList()、setOfWords2Vec() 都是上面的
listOPosts, listClasses = loadDataSet()
#詞彙表
myVocabList = createVocabList(listOPosts)
#特徵
trainMat = []
for postinDoc in listOPosts:
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))


X = np.asarray(trainMat)
Y = listClasses

from sklearn.naive_bayes import GaussianNB  #導入模型
clf = GaussianNB() #實例化

clf.fit(X, Y) #擬合

print(clf.predict(X[0])) #預測

在scikit-learn中，一共有3個樸素貝葉斯的分類算法類。分別是GaussianNB，MultinomialNB和BernoulliNB。其中GaussianNB就是先驗爲高斯分佈的樸素貝葉斯，MultinomialNB就是先驗爲多項式分佈的樸素貝葉斯，而BernoulliNB就是先驗爲伯努利分佈的樸素貝葉斯。這三個類適用的分類場景各不相同，一般來說，如果樣本特徵的分佈大部分是連續值，使用GaussianNB會比較好。如果如果樣本特徵的分大部分是多元離散值，使用MultinomialNB比較合適。而如果樣本特徵是二元離散值或者很稀疏的多元離散值，應該使用BernoulliNB

One more thing

1.連續特徵的處理方式

1.可以使用離散化技術處理，如分箱

2.假設連續特徵符合高斯分佈：

$\hat{P}\left(X_{j} | C=c_{i}\right)=\frac{1}{\sqrt{2 \pi} \sigma_{j i}} \exp \left(-\frac{\left(X_{j}-\mu_{j i}\right)^{2}}{2 \sigma_{j i}^{2}}\right)$

$\mu_{ji}$ 類別Ci對應的連續特徵Xj 的平均值； $\delta _{ji}$ 是對應的標準差。

舉個例子：

2.零概率問題--拉普拉斯平滑

零概率問題，就是在計算實例的概率時，如果某個量x，在觀察樣本庫（訓練集）中沒有出現過，會導致整個實例的概率結果是0

以文本分類爲例：在文本分類的問題中，當一個詞語沒有在訓練樣本中出現，該詞語調概率爲0，使用連乘計算文本出現概率時也爲0。這是不合理的，不能因爲一個事件沒有觀察到就武斷的認爲該事件的概率是0。

計算舉例：

在文本分類中，有3個類，C1、C2、C3，在指定的訓練樣本中（共1000個文檔），某個詞語K1，在各個類中觀測計數分別爲0，990，10，K1的概率爲0，0.99，0.01。對這三個量使用拉普拉斯平滑的計算方法如下：
1/1003 = 0.001，991/1003=0.988，11/1003=0.011

總結一句話：分子加1，分母加K（K等於類別數）

參考資料

https://shunliz.gitbooks.io/machine-learning/content/ml/bayes/scikit-simple-bayes.html

https://github.com/apachecn/AiLearning/blob/master/docs/ml/4.%E6%9C%B4%E7%B4%A0%E8%B4%9D%E5%8F%B6%E6%96%AF.md

scikit-learn文檔：https://scikit-learn.org/stable/modules/naive_bayes.html#naive-bayes

<Getting Started with Machine Learning>--Jim Liang

機器學習實戰之樸素貝葉斯--python/scikit-learn實現

理論基礎知識

基本思想

貝葉斯模型

手動計算實例一：

實戰項目--屏蔽社區留言板的侮辱性言論

Python版本

Scikit-learn版本

One more thing

1.連續特徵的處理方式

2.零概率問題--拉普拉斯平滑

深度之眼【Pytorch】--張量基本操作拼接、堆疊、索引、squeeze()

深度之眼【Pytorch】--學習率調整策略

【精簡推導】線性迴歸、嶺迴歸、Lasso迴歸（最小二乘法）

機器學習實戰之樸素貝葉斯--python/scikit-learn實現

機器學習實戰之K近鄰（KNN）-python/sklearn實現

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結