機器學習—朴素貝葉斯及其優化

機器學習—朴素貝葉斯

本文代碼均來自《機器學習實戰》

朴素貝葉斯的兩個基本假設：

1. 獨立：一個特征出現的可能性和與它和其他特征相鄰沒有關系
2. 每個特征同等重要

這段代碼是以文本分類為例介紹朴素貝葉斯算法的

要從文本中獲取特征，需要先拆分文本。這里的特征是來自文本的詞條（token），一個詞條是字符的任意組合。可以把詞條想象為單詞，也可以使用非單詞詞條，如URL、IP地址或者任意其他字符串。然后將一個文本片段表示為一個詞向量，其中值為1表示詞條出現，0表示詞條未出現。

以在線社區的留言板為例，為了不影響社區的發展，我們要屏蔽侮辱性的言論，所以要構建一個快速過濾器，如果某條留言使用了負面或者侮辱性的言語，那么就將該留言表示為內容不當。過濾這類內容是一個很常見的需求。對此問題建立兩個類別：侮辱類和非侮辱類，使用1和0分別表示。
————————————————
版權聲明：本文為CSDN博主「WordZzzz」的原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/u011475210/article/details/77922565

'''
Created on Oct 19, 2010

@author: Peter
'''
#和其他復雜模型不一樣，朴素貝葉斯的思想和操作比較簡單，它一般是內嵌在處理具體問題的函數中的，而不像神經網絡模型或者決策樹等等有自己獨立的方法
from numpy import *
#訓練集
def loadDataSet():
    #features
    postingList=[['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']]
    #labels
    classVec = [0,1,0,1,0,1]    #1 is abusive（虐待）, 0 not
    return postingList,classVec
                 
def createVocabList(dataSet):
    #將data中出現的所有詞放在一個列表中
    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):
    #返回訓練集中的哪些詞在這個樣本中出現了
    #vocabList是詞庫，inputSet是輸入的該條樣本
    returnVec = [0]*len(vocabList)#創建一個所含元素都為0的向量
    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):#朴素貝葉斯分類器訓練函數
    #trainMatrix是訓練集data，trainCategory是訓練集樣本的labels
    numTrainDocs = len(trainMatrix)#訓練集樣本個數
    numWords = len(trainMatrix[0])#訓練集中單詞一共有多少個
    pAbusive = sum(trainCategory)/float(numTrainDocs)#返回的結果是“訓練集中樣本有多少百分比是侮辱性文檔”,即P(c)
    #初始化概率的分子變量
    p0Num = ones(numWords)
    p1Num = ones(numWords)      
    #初始化概率的分母變量
    p0Denom = 2.0; p1Denom = 2.0 
    """
    為什么這里初始化的時候是2.0而不是0呢？因為我們在這里用到了拉普拉斯平滑這一改進技術
    由於P(C|w)=P(w|c)*P(c)/P(w)，這里的P(w|c)是通過p0Vect和p1Vect得到的，但是會發生這樣一種情況：
    就是在原本的訓練集中，某個詞沒有出現過label為ci的某個類，但是在實際上的文本中卻出現了，但是如果我們用上面的式子計算的話，得到概率卻是0（因為P（w|c)是0），
    但其實它出現的概率可能不是0，而只是比較小而已；或者更嚴重的，我們的樣本數量和典型性受限，不能代表總體特征。
    這種情況下，就需要我們使用拉普拉斯平滑這一技術，這是經常使用了朴素貝葉斯方法上的技術：
    具體操作上就是：將所有詞的出現數初始化為1，並將分母初始化為2
    更詳細的內容可以見下面的分析
    """    
    #遍歷所有data                   
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]#p1Num統計總體中的哪些詞出現在了被標記為侮辱性的文檔中，它不是一個數，而是一個向量，是侮辱性文檔中字符出現的疊加
            #例如[0,1,2,0],0表示這個詞從來沒有在侮辱性文檔中出現過，而1,2,3分別表示他們出現了1次、2、3次
            p1Denom += sum(trainMatrix[i])#侮辱性文檔的總詞數
        else:
            p0Num += trainMatrix[i]#同上，只不過這次操作的是非侮辱性的那些
            p0Denom += sum(trainMatrix[i])
    #對每個元素做除法求概率
    p1Vect = log(p1Num/p1Denom)          #change to log()，原本的朴素貝葉斯模型中這里應該是不帶log的，它表示的是P(w|ci),這里是改進后的模型
    #注意，p1Vect是一個數組，每個元素表示已知是侮辱性文檔的前提下這個詞出現的概率，就是P(wj|ci)
    p0Vect = log(p0Num/p0Denom)          #change to log()
    return p0Vect,p1Vect,pAbusive#返回P(w|c)和P(c)
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #p1是判斷為侮辱性文檔的概率，即P(C|w)=P(w|c)*P(c)/P(w),由於分母都是一樣的P(w),所以這里只計算分子
    #按元素相乘再相加，為什么是加上log(pClass1),不應該是P(w|c)*P(c)嗎，因為這里我們改進了，都把他們做了log變換，所以原來的乘法自然也變成加法了
    """
    1. 為什么要改進成log:
    小數連乘會造成所得值幾乎等於 0 的結果，從而無法比較大小。鑒於此，往往在實際運算中，會借助 log 函數
    因為概率處於[0,1]區間，由log的函數圖像可知，這樣改造之后不會改變增減性，但是會起到特征放大的作用
    2.為什么沒計算P（w):
    貝葉斯式子的那個分母在比較的時候根本不需要，就不算了
    """
    """
    *(星號)運算的作用
    對數組執行對應位置相乘
    對矩陣執行矩陣乘法運算
    """
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else: 
        return 0
def testingNB():
    #一個測試用的例子，也是告訴我們這些函數的正確用法
    listOPosts,listClasses = loadDataSet()#加載data和labels
    myVocabList = createVocabList(listOPosts)
    trainMat=[]#初始化訓練數據列表
    for postinDoc in listOPosts:
        #將輸入的樣本的數據進行處理和轉換，從原來的字符數組變成一個表示"訓練集中的哪些詞在該樣本中出現過"的數組
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V,p1V,pAb = trainNB0(array(trainMat),array(listClasses))
    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))
    testingNB()
詞集模型與詞袋模型
上面的代碼有一個地方其實和我們的預想是有些不太一樣的，就是它在統計總體中的哪些詞出現在了樣本中的時候只統計了0（沒出現）和1（出現過），而不考慮出現的次數，這種模型被稱為“詞集模型”。相應的，統計出現次數的模型被稱為詞袋模型，這兩種不好說哪種更好，但是他們之間的轉換也是很容易的，對於上面的代碼，我們只需要修改一個函數就好了：

詞集模型的代碼：

def setOfWords2Vec(vocabList, inputSet):
    #返回訓練集中的哪些詞在這個樣本中出現了
    #vocabList是詞庫，inputSet是輸入的該條樣本
    returnVec = [0]*len(vocabList)#創建一個所含元素都為0的向量
    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 bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    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

詞集模型與詞袋模型

上面的代碼有一個地方其實和我們的預想是有些不太一樣的，就是它在統計總體中的哪些詞出現在了樣本中的時候只統計了0（沒出現）和1（出現過），而不考慮出現的次數，這種模型被稱為“詞集模型”。相應的，統計出現次數的模型被稱為詞袋模型，這兩種不好說哪種更好，但是他們之間的轉換也是很容易的，對於上面的代碼，我們只需要修改一個函數就好了：

詞集模型的代碼：

def setOfWords2Vec(vocabList, inputSet):
    #返回訓練集中的哪些詞在這個樣本中出現了
    #vocabList是詞庫，inputSet是輸入的該條樣本
    returnVec = [0]*len(vocabList)#創建一個所含元素都為0的向量
    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 bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    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

對朴素貝葉斯方法的優化

其實上文中，我們已經進行並說明了一項優化了，就是將原有的概率變為對數，由於對數化了之后在[0.1]上值的變化更大了，這樣就消除了概率計算下溢的風險。log和原曲線增減性相同，且在同樣的位置取到極值點，所以這樣的替換是可行的。

下面我們說明另一項優化：拉普拉斯平滑，這部分來源於博客https://cuijiahua.com/blog/2017/11/ml_5_bayes_2.html。

在計算的時候已經出現了概率為0的情況。如果新實例文本，包含這種概率為0的分詞，那么最終的文本屬於某個類別的概率也就是0了。顯然，這樣是不合理的，為了降低這種影響，可以將所有詞的出現數初始化為1，並將分母初始化為2。這種做法就叫做拉普拉斯平滑(Laplace Smoothing)又被稱為加1平滑，是比較常用的平滑方法，它就是為了解決0概率問題。

能體現這一優化的代碼是：

p0Num = ones(numWords)
    p1Num = ones(numWords)      
    #初始化概率的分母變量
    p0Denom = 2.0; p1Denom = 2.0 

為什么這里初始化的時候是2.0而不是0呢？因為我們在這里用到了拉普拉斯平滑這一改進技術。由於P(C|w)=P(w|c)*P(c)/P(w)，這里的P(w|c)是通過p0Vect和p1Vect得到的，但是會發生這樣一種情況：就是在原本的訓練集中，某個詞沒有出現過label為ci的某個類，但是在實際上的文本中卻出現了，但是如果我們用上面的式子計算的話，得到概率卻是0（因為P（w|c)是0），但其實它出現的概率可能不是0，而只是比較小而已；或者更嚴重的，我們的樣本數量和典型性受限，不能代表總體特征。

這種情況下，就需要我們使用拉普拉斯平滑這一技術，這是經常使用在朴素貝葉斯方法上的技術：

​ 具體操作上就是：將所有詞的出現數初始化為1，並將分母初始化為2。當然，不是只有這一種寫法的，具體來說應該是：

這里的K表示種類的個數，λ可以任取。由於我們是二分類所以K=2，這里我們取λ等於1，就是上面說的了，當然取其他的數字也可以。

這個式子的正確性是顯而易見的，把所有情況的式子加起來還是1就能說明依然能正確表示概率。

這樣做，就能保證對於每一種情況，都有了一個基礎的概率。