當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

机器学习实战（四）——基于概率论的分类方法：朴素贝叶斯

發布時間：2023/12/15 编程问答 20 豆豆

生活随笔收集整理的這篇文章主要介紹了机器学习实战（四）——基于概率论的分类方法：朴素贝叶斯小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

- 樸素貝葉斯法
  - 4.1 基于貝葉斯決策理論的分類方法
    - 4.1.1 貝葉斯決策理論
    - 4.1.2 條件概率
    - 4.1.3 全概率公式
    - 4.1.4 貝葉斯推斷
    - 4.1.5 樸素貝葉斯
  - 4.2 使用樸素貝葉斯進行文檔分類
  - 4.3 總結
  - 4.4 樸素貝葉斯改進——拉普拉斯平滑
  - 4.5 樸素貝葉斯——過濾垃圾郵件
    - 4.5.1 收集數據
    - 4.5.2 準備數據
  - 4.6 樸素貝葉斯——新浪新聞分類（sklearn）
    - 4.6.1 中文語句切分
    - 4.6.2 文本特征選擇
  - 4.7 使用sklearn構建樸素貝葉斯分類器
  - 4.7 總結

樸素貝葉斯法

樸素貝葉斯(naive Bayes)算法是基于貝葉斯定理與特征條件獨立假設的分類方法，對于給定的訓練數據集，首先基于特征條件獨立假設學習輸入/輸出的聯合概率分布，然后基于此模型，對給定的輸入x，利用貝葉斯定理求出后驗概率最大的輸出y，樸素貝葉斯法實現簡單，學習與預測的效率都很高，是一種常見的方法。

樸素貝葉斯(naive Bayes)算法是有監督的學習算法，解決的是分類問題，如客戶是否流失、是否值得投資、信用等級評定等多分類問題。該算法的優點在于簡單易懂、學習效率高、在某些領域的分類問題中能夠與決策樹、神經網絡相媲美。但由于該算法以自變量之間的獨立（條件特征獨立）性和連續變量的正態性假設為前提，就會導致算法精度在某種程度上受影響。

4.1 基于貝葉斯決策理論的分類方法

優點：在數據較少的情況下仍然有效，可以處理多類別問題
缺點：對于輸入數據的準備方式較為敏感
適用數據類型：標稱型數據

4.1.1 貝葉斯決策理論

樸素貝葉斯是貝葉斯決策理論的一部分，所以首先了解一下貝葉斯理論。

假設現在我們有一個數據集，它由兩類數據組成，數據分布如下圖所示：

我們現在用p1(x,y)表示數據點(x,y)屬于類別1(圖中紅色圓點表示的類別)的概率，用p2(x,y)表示數據點(x,y)屬于類別2(圖中藍色三角形表示的類別)的概率，那么對于一個新數據點(x,y)，可以用下面的規則來判斷它的類別：

如果p1(x,y) > p2(x,y)，那么類別為1
如果p1(x,y) < p2(x,y)，那么類別為2

也就是說，我們會選擇高概率對應的類別。這就是貝葉斯決策理論的核心思想，即選擇具有最高概率的決策。

適用決策樹不會非常成功，和簡單的概率計算相比，KNN計算量太大，因此對于上述問題，最佳選擇是概率比較方法。

已經了解了貝葉斯決策理論的核心思想，那么接下來，就是學習如何計算p1和p2概率。

4.1.2 條件概率

在學習計算p1和p2概率之前，我們需要了解什么是條件概率(Condittional probability)，就是指在事件B發生的情況下，事件A發生的概率，用P(A|B)?來表示。

P(A|B)=P(A?B)P(B)??P(A|B)=P(A?B)P(B)
故：

P(A?B)=P(A|B)P(B)?P(A?B)=P(A|B)P(B)
同理：

P(A?B)=P(B|A)P(A)?P(A?B)=P(B|A)P(A)
所以：

P(A|B)P(B)=P(B|A)P(A)?P(A|B)P(B)=P(B|A)P(A)
即：

P(A|B)=P(B|A)P(A)P(B)??P(A|B)=P(B|A)P(A)P(B)
上式即為條件概率的計算公式

4.1.3 全概率公式

除了條件概率以外，在計算p1和p2的時候，還要用到全概率公式，因此，這里繼續推導全概率公式。

P(B)=P(B?A)+P(B?A?′?)?P(B)=P(B?A)+P(B?A′)
已知：

P(B?A)=+P(B|A)P(A)?P(B?A)=+P(B|A)P(A)
故全概率公式為：

P(B)=P(B|A)P(A)+P(B|A?′?)P(A?′?)?P(B)=P(B|A)P(A)+P(B|A′)P(A′)

其含義為：如果A?和 $A'$ 構成一個樣本空間的一個劃分，那么事件B?的概率就等于 $A$ 和A?′??的概率分別乘以B?對這兩個事件的條件概率之和。

于是條件概率就有了另一種寫法：
$P (A | B) = P ( B | A ) P ( A ) P ( B | A ) P ( A ) + P ( B | A ' ) P ( A ' )$

4.1.4 貝葉斯推斷

對條件概率進行變形，可以得到如下形式：

P(A|B)=P(A)P(B|A)P(B)??

我們把P(A)稱為”先驗概率”（Prior probability），即在B事件發生之前，我們對A事件概率的一個判斷。

P(A|B)稱為”后驗概率”（Posterior probability），即在B事件發生之后，我們對A事件概率的重新評估。

P(B|A)/P(B)稱為”可能性函數”（Likelyhood），這是一個調整因子，使得預估概率更接近真實概率。

所以，條件概率可以理解成下面的式子：

后驗概率=先驗概率?調整因子?

這就是貝葉斯推斷的含義：我們先預估一個”先驗概率”，然后加入實驗結果，看這個實驗到底是增強還是削弱了”先驗概率”，由此得到更接近事實的”后驗概率”。

在這里，如果”可能性函數”P(B|A)/P(B)>1，意味著”先驗概率”被增強，事件A的發生的可能性變大；如果”可能性函數”=1，意味著B事件無助于判斷事件A的可能性；如果”可能性函數”<1，意味著”先驗概率”被削弱，事件A的可能性變小。

4.1.5 樸素貝葉斯

“樸素”的解釋：假設各個特征之間相互獨立（在貝葉斯分類器上做了簡化）
樸素貝葉斯的基礎假設：

①每個特征相互獨立；
②每個特征的權重（或重要性）都相等，即對結果的影響程度都相同。

樸素貝葉斯具體實現步驟：

舉例說明：

某個醫院早上來了六個門診的病人，他們的情況如下表所示：

癥狀職業疾病

打噴嚏	護士	感冒
打噴嚏	農夫	過敏
頭痛	建筑工人	腦震蕩
頭痛	建筑工人	感冒
打噴嚏	教師	感冒
頭痛	教師	腦震蕩

現在又來了第七個病人，是一個打噴嚏的建筑工人。請問他患上感冒的概率有多大？

根據貝葉斯定理：

P(A|B)=P(B|A)P(A)P(B)??

可得：

P(感冒|打噴嚏&建筑工人)=P(打噴嚏&建筑工人|感冒)P(感冒) / P(打噴嚏&建筑工人)

根據樸素貝葉斯條件獨立假設可知，打噴嚏和建筑工人兩個特征是獨立的，所以：

P(感冒|打噴嚏&建筑工人)=P(打噴嚏|感冒)*P(建筑工人|感冒*P(感冒) / P(打噴嚏&建筑工人)

P(感冒|打噴嚏&建筑工人)=0.66*0.33*0.5/(0.5*0.33)=0.66

因此，這個打噴嚏的建筑工人，有66%的概率是得了感冒。同理，可以計算這個病人患上過敏或腦震蕩的概率。比較這幾個概率，就可以知道他最可能得什么病。

這就是貝葉斯分類器的基本方法：在統計資料的基礎上，依據某些特征，計算各個類別的概率，從而實現分類。

同樣，在編程的時候，如果不需要求出所屬類別的具體概率，P(打噴嚏) = 0.5和P(建筑工人) = 0.33的概率是可以不用求的。

4.2 使用樸素貝葉斯進行文檔分類

樸素貝葉斯是上節介紹的貝葉斯分類器的一個擴展，是用于文檔分類的常用算法。

以在線社區留言為例。為了不影響社區的發展，我們要屏蔽侮辱性的言論，所以要構建一個快速過濾器，如果某條留言使用了負面或者侮辱性的語言，那么就將該留言標志為內容不當。過濾這類內容是一個很常見的需求。對此問題建立兩個類型：侮辱類和非侮辱類，使用1和0分別表示。

我們把文本看成單詞向量或者詞條向量，也就是說將句子轉換為向量。考慮出現所有文檔中的單詞，再決定將哪些單詞納入詞匯表或者說所要的詞匯集合，然后必須要將每一篇文檔轉換為詞匯表上的向量。簡單起見，我們先假設已經將本文切分完畢，存放到列表中，并對詞匯向量進行分類標注。編寫代碼如下：

結果：

創建一個詞匯表，并將切好的詞條轉化為詞條向量

""" 函數說明：創建實驗樣本Parameters：無 Returns：postingList：實驗樣本切分的詞條classVec：類別標簽向量 Modify：2018-03-14""" def loadDataSet():# 切分的詞條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']]# 類別標簽向量，1代表侮辱性詞匯，0代表不是classVec = [0, 1, 0, 1, 0, 1]return postingList, classVec""" 函數說明：更加vocabList詞匯表，將inputSet向量化，向量的每個元素為1或0Parameters：vocabList：createVocabList返回的列表inputSet：切分的詞條列表 Returns：returnVec：文檔向量，詞集模型 Modify：2018-03-14""" def setOfWords2Vec(vocabList,inputSet):#創建一個其中所含元素都為0的向量returnVec=[0]*len(vocabList)#遍歷每個詞條for word in inputSet:#如果詞條存在于詞匯表中，則置1if word in vocabList:returnVec[vocabList.index(word)]=1else:print("the word: %s is not in my Vocabulary!" % word)#返回向量文檔return returnVec"""" 函數說明：將切分的實驗樣本詞條整理成不重復的詞條列表，也就是詞匯表Parameters：dataSet：整理的樣本數據集 Returns：vocabSet：返回不重復的詞條列表，也就是詞匯表 Modify：2018-03-14""" def createVocabList(dataSet):#創建一個空的不重復列表vocabSet=set([])for document in dataSet:#取并集vocabSet=vocabSet|set(document)return list(vocabSet)if __name__=='__main__':postingList,classVec=loadDataSet()print('postingList:\n',postingList)myVocabList=createVocabList(postingList)print('myVocabList:\n',myVocabList)trainMat=[]for postinDoc in postingList:trainMat.append(setOfWords2Vec(myVocabList,postinDoc))print('trainMat:\n',trainMat)

結果：

從運行結果可以看出，postingList是原始的詞條列表，myVocabList是詞匯表。myVocabList是所有單詞出現的集合，沒有重復的元素。詞匯表是用來干什么的？沒錯，它是用來將詞條向量化的，一個單詞在詞匯表中出現過一次，那么就在相應位置記作1，如果沒有出現就在相應位置記作0。trainMat是所有的詞條向量組成的列表。它里面存放的是根據myVocabList向量化的詞條向量。

我們已經得到了詞條向量。接下來，我們就可以通過詞條向量訓練樸素貝葉斯分類器。

import numpy as np""" 函數說明：創建實驗樣本Parameters：無 Returns：postingList：實驗樣本切分的詞條classVec：類別標簽向量 Modify：2018-03-14""" def loadDataSet():# 切分的詞條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']]# 類別標簽向量，1代表侮辱性詞匯，0代表不是classVec = [0, 1, 0, 1, 0, 1]return postingList, classVec""" 函數說明：更加vocabList詞匯表，將inputSet向量化，向量的每個元素為1或0Parameters：vocabList：createVocabList返回的列表inputSet：切分的詞條列表 Returns：returnVec：文檔向量，詞集模型 Modify：2018-03-14""" def setOfWords2Vec(vocabList,inputSet):#創建一個其中所含元素都為0的向量returnVec=[0]*len(vocabList)#遍歷每個詞條for word in inputSet:#如果詞條存在于詞匯表中，則置1if word in vocabList:returnVec[vocabList.index(word)]=1else:print("the word: %s is not in my Vocabulary!" % word)#返回向量文檔return returnVec"""" 函數說明：將切分的實驗樣本詞條整理成不重復的詞條列表，也就是詞匯表Parameters：dataSet：整理的樣本數據集 Returns：vocabSet：返回不重復的詞條列表，也就是詞匯表 Modify：2018-03-14""" def createVocabList(dataSet):#創建一個空的不重復列表vocabSet=set([])for document in dataSet:#取并集vocabSet=vocabSet|set(document)return list(vocabSet)""" 函數說明：樸素貝葉斯分類器訓練函數Parameters：trainMatrix：訓練文檔矩陣，即setOfWords2Vec返回的returnVec構成的矩陣trainCategory：訓練類別標簽向量，即loadDataSet返回的classVec Returns： p0Vect：侮辱類的條件概率數組p1Vect：非侮辱類的條件概率數組pAbusive：文檔屬于侮辱類的概率 Modify：2018-03-14""" def trainNB0(trainMtrix,trainCategory):#計算訓練的文檔數目numTrainDocs=len(trainMtrix)#計算每篇文章的詞條數numWords=len(trainMtrix[0])#文檔屬于侮辱類的概率pAbusive=sum(trainCategory)/float(numTrainDocs)#創建numpy.zeros數組p0Num=np.zeros(numWords);p1Num=np.zeros(numWords)#分母初始化為0.0p0Denom=0.0;p1Denom=0.0for i in range(numTrainDocs):#統計屬于侮辱類的條件概率if trainCategory[i]==1:p1Num+=trainMtrix[i]p1Denom+=sum(trainMtrix[i])#統計屬于非侮辱類的條件概率else:p0Num+=trainMtrix[i]p0Denom+=sum(trainMtrix[i])#相除p1Vect=p1Num/p1Denomp0Vect=p0Num/p1Denom#返回屬于侮辱類的條件概率return p0Vect,p1Vect,pAbusiveif __name__=='__main__':postingList,classVec=loadDataSet()myVocabList=createVocabList(postingList)print('myVocabList:\n',myVocabList)trainMat=[]for postinDoc in postingList:trainMat.append(setOfWords2Vec(myVocabList,postinDoc))p0V,p1V,pAb=trainNB0(trainMat,classVec)print('p0V:\n',p0V)print('p1V:\n', p1V)print('classVec:\n', classVec)print('pAb:\n', pAb)

p0V存放的是每個單詞屬于類別0，也就是非侮辱類詞匯的概率
p1V存放的就是各個單詞屬于侮辱類的條件概率。pAb就是先驗概率。

已經訓練好分類器，接著用分類器進行分類

import numpy as np from functools import reduce """ 函數說明：創建實驗樣本Parameters：無 Returns：postingList：實驗樣本切分的詞條classVec：類別標簽向量 Modify：2018-03-14"""def loadDataSet():# 切分的詞條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']]# 類別標簽向量，1代表侮辱性詞匯，0代表不是classVec = [0, 1, 0, 1, 0, 1]return postingList, classVec""" 函數說明：更加vocabList詞匯表，將inputSet向量化，向量的每個元素為1或0Parameters：vocabList：createVocabList返回的列表inputSet：切分的詞條列表 Returns：returnVec：文檔向量，詞集模型 Modify：2018-03-14"""def setOfWords2Vec(vocabList, inputSet):# 創建一個其中所含元素都為0的向量returnVec = [0] * len(vocabList)# 遍歷每個詞條for word in inputSet:# 如果詞條存在于詞匯表中，則置1if word in vocabList:returnVec[vocabList.index(word)] = 1else:print("the word: %s is not in my Vocabulary!" % word)# 返回向量文檔return returnVec"""" 函數說明：將切分的實驗樣本詞條整理成不重復的詞條列表，也就是詞匯表Parameters：dataSet：整理的樣本數據集 Returns：vocabSet：返回不重復的詞條列表，也就是詞匯表 Modify：2018-03-14"""def createVocabList(dataSet):# 創建一個空的不重復列表vocabSet = set([])for document in dataSet:# 取并集vocabSet = vocabSet | set(document)return list(vocabSet)""" 函數說明：樸素貝葉斯分類器訓練函數Parameters：trainMatrix：訓練文檔矩陣，即setOfWords2Vec返回的returnVec構成的矩陣trainCategory：訓練類別標簽向量，即loadDataSet返回的classVec Returns： p0Vect：侮辱類的條件概率數組p1Vect：非侮辱類的條件概率數組pAbusive：文檔屬于侮辱類的概率 Modify：2018-03-14"""def trainNB0(trainMtrix, trainCategory):# 計算訓練的文檔數目numTrainDocs = len(trainMtrix)# 計算每篇文章的詞條數numWords = len(trainMtrix[0])# 文檔屬于侮辱類的概率pAbusive = sum(trainCategory) / float(numTrainDocs)# 創建numpy.zeros數組p0Num = np.zeros(numWords);p1Num = np.zeros(numWords)# 分母初始化為0.0p0Denom = 0.0;p1Denom = 0.0for i in range(numTrainDocs):# 統計屬于侮辱類的條件概率if trainCategory[i] == 1:p1Num += trainMtrix[i]p1Denom += sum(trainMtrix[i])# 統計屬于非侮辱類的條件概率else:p0Num += trainMtrix[i]p0Denom += sum(trainMtrix[i])# 相除p1Vect = p1Num / p1Denomp0Vect = p0Num / p1Denom# 返回屬于侮辱類的條件概率return p0Vect, p1Vect, pAbusive""" 函數說明:樸素貝葉斯分類器分類函數Parameters:vec2Classifyaaa：待分類的詞條數組p0Vec：侮辱類的條件概率數組p1Vec：非侮辱類的條件概率數組pClass1：文檔屬于侮辱類的概率 Returns:0 ：屬于非侮辱類1 ：屬于侮辱類 Modify:2018-03-14 """ def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):#對應元素相乘p1=reduce(lambda x,y:x*y,vec2Classify*p1Vec)*pClass1p0=reduce(lambda x,y:x*y,vec2Classify*p0Vec)*(1.0-pClass1)print('p0:',p0)print('p1:',p1)if p1>p0:return 1else:return 0""" 函數說明:測試樸素貝葉斯分類器Parameters:無 Returns:無 Modify:2018-03-14 """ def testingNB():#創建實驗樣本listOPosts,listClasses=loadDataSet()#創建詞匯表myVocabList=createVocabList((listOPosts))trainMat=[]for postinDoc in listOPosts:#將實驗樣本向量化trainMat.append(setOfWords2Vec(myVocabList,postinDoc))#訓練樸素貝葉斯分類器p0V,p1V,pAb=trainNB0(np.array(trainMat),np.array(listClasses))#測試樣本1testEntry=['love','my','dalmation']#測試樣本向量化thisDoc=np.array(setOfWords2Vec(myVocabList,testEntry))#執行分類并打印分類結果if classifyNB(thisDoc,p0V,p1V,pAb):print(testEntry,'屬于侮辱類')# 執行分類并打印分類結果else:print(testEntry,'屬于非侮辱類')#測試樣本2testEntry=['stupid','garbage']#測試樣本向量化thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))# 執行分類并打印分類結果if classifyNB(thisDoc, p0V, p1V, pAb):print(testEntry, '屬于侮辱類')# 執行分類并打印分類結果else:print(testEntry, '屬于非侮辱類') if __name__ == '__main__':testingNB()

我們發現，p0和p1的計算結果都是0，下面來探討產生該結果的問題。

4.3 總結

樸素貝葉斯推斷的一些優點：

生成式模型，通過計算概率來進行分類，可以用來處理多分類問題。
對小規模的數據表現很好，適合多分類任務，適合增量式訓練，算法也比較簡單。

樸素貝葉斯推斷的一些缺點：

對輸入數據的表達形式很敏感。
由于樸素貝葉斯的“樸素”特點，所以會帶來一些準確率上的損失。
需要計算先驗概率，分類決策存在錯誤率。

4.4 樸素貝葉斯改進——拉普拉斯平滑

1）零概率問題

造成原因：

利用貝葉斯分類器對文檔進行分類時，要計算多個概率的乘積以獲得文檔屬于某個類別的概率，即計算p(w0|A)p(w1|A)p(w2|A)?，如果其中有一個為0，則最后的結果也為0。

解決方法：

為了降低這種影響，可以將所有詞的出現次數初始化為1，并將分母初始化為2，這種做法稱為“拉普拉斯平滑”，也稱“加1平滑”，是比較常用的平滑方法，為了解決0概率問題。

2）下溢出

造成的原因：

是太多很小的數相乘，越乘越小，就造成了下溢出的問題。在相應小數位置進行四舍五入，計算結果可能就變成0了。

解決方法：

對乘積結果取自然對數，通過求對數可以避免下溢出或者浮點數舍入導致的錯誤，同時，采用自然對數進行處理不會有任何損失。

上圖顯示了f(x)?和lnf(x)?的曲線，可以看出上面兩條曲線同增同減，且最大值處相同，取值雖然不同，但是不影響最終結果。

因此，可以對trainNB0函數進行修改：

import numpy as np""" 函數說明：創建實驗樣本Parameters：無 Returns：postingList：實驗樣本切分的詞條classVec：類別標簽向量 Modify：2018-03-14""" def loadDataSet():# 切分的詞條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']]# 類別標簽向量，1代表侮辱性詞匯，0代表不是classVec = [0, 1, 0, 1, 0, 1]return postingList, classVec""" 函數說明：更加vocabList詞匯表，將inputSet向量化，向量的每個元素為1或0Parameters：vocabList：createVocabList返回的列表inputSet：切分的詞條列表 Returns：returnVec：文檔向量，詞集模型 Modify：2018-03-14""" def setOfWords2Vec(vocabList,inputSet):#創建一個其中所含元素都為0的向量returnVec=[0]*len(vocabList)#遍歷每個詞條for word in inputSet:#如果詞條存在于詞匯表中，則置1if word in vocabList:returnVec[vocabList.index(word)]=1else:print("the word: %s is not in my Vocabulary!" % word)#返回向量文檔return returnVec"""" 函數說明：將切分的實驗樣本詞條整理成不重復的詞條列表，也就是詞匯表Parameters：dataSet：整理的樣本數據集 Returns：vocabSet：返回不重復的詞條列表，也就是詞匯表 Modify：2018-03-14""" def createVocabList(dataSet):#創建一個空的不重復列表vocabSet=set([])for document in dataSet:#取并集vocabSet=vocabSet|set(document)return list(vocabSet)""" 函數說明：樸素貝葉斯分類器訓練函數Parameters：trainMatrix：訓練文檔矩陣，即setOfWords2Vec返回的returnVec構成的矩陣trainCategory：訓練類別標簽向量，即loadDataSet返回的classVec Returns： p0Vect：侮辱類的條件概率數組p1Vect：非侮辱類的條件概率數組pAbusive：文檔屬于侮辱類的概率 Modify：2018-03-14""" def trainNB0(trainMtrix, trainCategory):# 計算訓練的文檔數目numTrainDocs = len(trainMtrix)# 計算每篇文章的詞條數numWords = len(trainMtrix[0])# 文檔屬于侮辱類的概率pAbusive = sum(trainCategory) / float(numTrainDocs)# 創建numpy.ones數組，詞條初始化為1，拉普拉斯平滑p0Num = np.ones(numWords);p1Num = np.ones(numWords)# 分母初始化為2.0，拉普拉斯平滑p0Denom = 2.0p1Denom = 2.0for i in range(numTrainDocs):# 統計屬于侮辱類的條件概率所需的數據，即P(w0|1),P(w1|1),P(w2|1)···if trainCategory[i] == 1:p1Num += trainMtrix[i]p1Denom += sum(trainMtrix[i])# 統計屬于非侮辱類的條件概率所需的數據，即P(w0|0),P(w1|0),P(w2|0)···else:p0Num += trainMtrix[i]p0Denom += sum(trainMtrix[i])# 相除p1Vect = np.log(p1Num / p1Denom)p0Vect = np.log(p0Num / p1Denom)# 返回屬于侮辱類的條件概率return p0Vect, p1Vect, pAbusiveif __name__=='__main__':postingList,classVec=loadDataSet()myVocabList=createVocabList(postingList)print('myVocabList:\n',myVocabList)trainMat=[]for postinDoc in postingList:trainMat.append(setOfWords2Vec(myVocabList,postinDoc))p0V,p1V,pAb=trainNB0(trainMat,classVec)print('p0V:\n',p0V)print('p1V:\n', p1V)print('classVec:\n', classVec)print('pAb:\n', pAb)

結果：

此時已經不存在零概率了。

對classifyNB進行修改：

import numpy as np from functools import reduce """ 函數說明：創建實驗樣本Parameters：無 Returns：postingList：實驗樣本切分的詞條classVec：類別標簽向量 Modify：2018-03-14"""def loadDataSet():# 切分的詞條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']]# 類別標簽向量，1代表侮辱性詞匯，0代表不是classVec = [0, 1, 0, 1, 0, 1]return postingList, classVec""" 函數說明：更加vocabList詞匯表，將inputSet向量化，向量的每個元素為1或0Parameters：vocabList：createVocabList返回的列表inputSet：切分的詞條列表 Returns：returnVec：文檔向量，詞集模型 Modify：2018-03-14"""def setOfWords2Vec(vocabList, inputSet):# 創建一個其中所含元素都為0的向量returnVec = [0] * len(vocabList)# 遍歷每個詞條for word in inputSet:# 如果詞條存在于詞匯表中，則置1if word in vocabList:returnVec[vocabList.index(word)] = 1else:print("the word: %s is not in my Vocabulary!" % word)# 返回向量文檔return returnVec"""" 函數說明：將切分的實驗樣本詞條整理成不重復的詞條列表，也就是詞匯表Parameters：dataSet：整理的樣本數據集 Returns：vocabSet：返回不重復的詞條列表，也就是詞匯表 Modify：2018-03-14"""def createVocabList(dataSet):# 創建一個空的不重復列表vocabSet = set([])for document in dataSet:# 取并集vocabSet = vocabSet | set(document)return list(vocabSet)""" 函數說明：樸素貝葉斯分類器訓練函數Parameters：trainMatrix：訓練文檔矩陣，即setOfWords2Vec返回的returnVec構成的矩陣trainCategory：訓練類別標簽向量，即loadDataSet返回的classVec Returns：p0Vect：侮辱類的條件概率數組p1Vect：非侮辱類的條件概率數組pAbusive：文檔屬于侮辱類的概率 Modify：2018-03-14"""def trainNB0(trainMtrix, trainCategory):# 計算訓練的文檔數目numTrainDocs = len(trainMtrix)# 計算每篇文章的詞條數numWords = len(trainMtrix[0])# 文檔屬于侮辱類的概率pAbusive = sum(trainCategory) / float(numTrainDocs)# 創建numpy.ones數組，詞條初始化為1，拉普拉斯平滑p0Num = np.ones(numWords);p1Num = np.ones(numWords)# 分母初始化為2.0，拉普拉斯平滑p0Denom = 2.0p1Denom = 2.0for i in range(numTrainDocs):# 統計屬于侮辱類的條件概率所需的數據，即P(w0|1),P(w1|1),P(w2|1)···if trainCategory[i] == 1:p1Num += trainMtrix[i]p1Denom += sum(trainMtrix[i])# 統計屬于非侮辱類的條件概率所需的數據，即P(w0|0),P(w1|0),P(w2|0)···else:p0Num += trainMtrix[i]p0Denom += sum(trainMtrix[i])# 相除p1Vect = np.log(p1Num / p1Denom)p0Vect = np.log(p0Num / p1Denom)# 返回屬于侮辱類的條件概率return p0Vect, p1Vect, pAbusive""" 函數說明:樸素貝葉斯分類器分類函數Parameters:vec2Classifyaaa：待分類的詞條數組p0Vec：侮辱類的條件概率數組p1Vec：非侮辱類的條件概率數組pClass1：文檔屬于侮辱類的概率 Returns:0 ：屬于非侮辱類1 ：屬于侮辱類 Modify:2018-03-14 """ def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):#對應元素相乘,logA*B=logA+logB，所以要加上np.log(pClass1)p1=sum(vec2Classify*p1Vec)+np.log(pClass1)p0 = sum(vec2Classify * p0Vec) + np.log(1.0-pClass1)if p1>p0:return 1else:return 0""" 函數說明:測試樸素貝葉斯分類器Parameters:無 Returns:無 Modify:2018-03-14 """ def testingNB():#創建實驗樣本listOPosts,listClasses=loadDataSet()#創建詞匯表myVocabList=createVocabList((listOPosts))trainMat=[]for postinDoc in listOPosts:#將實驗樣本向量化trainMat.append(setOfWords2Vec(myVocabList,postinDoc))#訓練樸素貝葉斯分類器p0V,p1V,pAb=trainNB0(np.array(trainMat),np.array(listClasses))#測試樣本1testEntry=['love','my','dalmation']#測試樣本向量化thisDoc=np.array(setOfWords2Vec(myVocabList,testEntry))#執行分類并打印分類結果if classifyNB(thisDoc,p0V,p1V,pAb):print(testEntry,'屬于侮辱類')# 執行分類并打印分類結果else:print(testEntry,'屬于非侮辱類')#測試樣本2testEntry=['stupid','garbage']#測試樣本向量化thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))# 執行分類并打印分類結果if classifyNB(thisDoc, p0V, p1V, pAb):print(testEntry, '屬于侮辱類')# 執行分類并打印分類結果else:print(testEntry, '屬于非侮辱類')if __name__ == '__main__':testingNB()

結果：

4.5 樸素貝葉斯——過濾垃圾郵件

樸素貝葉斯的最著名的應用——電子郵件垃圾過濾

步驟：

收集數據：提供文本文件。
準備數據：將文本文件解析成詞條向量。
分析數據：檢查詞條確保解析的正確性。
訓練算法：使用我們之前建立的trainNB0()函數。
測試算法：使用classifyNB()，并構建一個新的測試函數來計算文檔集的錯誤率。
使用算法：構建一個完整的程序對一組文檔進行分類，將錯分的文檔輸出到屏幕上。

4.5.1 收集數據

有兩個文件夾，ham和spam，spam文件下的txt文件為垃圾郵件。

4.5.2 準備數據

對于英文文本，我們可以以非字母、非數字作為符號進行切分，使用split函數即可。編寫代碼如下：

import re""" 函數說明:接收一個大字符串并將其解析為字符串列表Parameters:無 Returns:無 Modify:2018-03-14 """ def textParse(bigString):# 將特殊符號作為切分標志進行字符串切分，即非字母、非數字listOfTokens = re.split(r'\W*', bigString)# 除了單個字母，例如大寫的I，其它單詞變成小寫return [tok.lower() for tok in listOfTokens if len(tok) > 2]""" 函數說明:將切分的實驗樣本詞條整理成不重復的詞條列表，也就是詞匯表Parameters:dataSet - 整理的樣本數據集 Returns:vocabSet - 返回不重復的詞條列表，也就是詞匯表 Modify:2018-03-14 """ def createVocabList(dataSet):# 創建一個空的不重復列表vocabSet = set([])for document in dataSet:# 取并集vocabSet = vocabSet | set(document)return list(vocabSet)if __name__ == '__main__':docList = []; classList = []# 遍歷25個txt文件for i in range(1, 26):# 讀取每個垃圾郵件，并字符串轉換成字符串列表wordList = textParse(open('spam/%d.txt' % i, 'r').read())docList.append(wordList)# 標記垃圾郵件，1表示垃圾文件classList.append(1)# 讀取每個非垃圾郵件，并字符串轉換成字符串列表wordList = textParse(open('ham/%d.txt' % i, 'r').read())docList.append(wordList)# 標記非垃圾郵件，1表示垃圾文件classList.append(0)# 創建詞匯表，不重復vocabList = createVocabList(docList)print(vocabList)

詞匯表結果：

根據詞匯表，可以將每個文本向量化，此處將數據集分為訓練集和測試集，使用交叉驗證的方式測試樸素貝葉斯分類器的準確性，代碼如下：

import numpy as np import re import random""" 函數說明：創建實驗樣本Parameters：無 Returns：postingList：實驗樣本切分的詞條classVec：類別標簽向量 Modify：2018-03-14"""def loadDataSet():# 切分的詞條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']]# 類別標簽向量，1代表侮辱性詞匯，0代表不是classVec = [0, 1, 0, 1, 0, 1]return postingList, classVec""" 函數說明：更加vocabList詞匯表，將inputSet向量化，向量的每個元素為1或0Parameters：vocabList：createVocabList返回的列表inputSet：切分的詞條列表 Returns：returnVec：文檔向量，詞集模型 Modify：2018-03-14"""def setOfWords2Vec(vocabList, inputSet):# 創建一個其中所含元素都為0的向量returnVec = [0] * len(vocabList)# 遍歷每個詞條for word in inputSet:# 如果詞條存在于詞匯表中，則置1if word in vocabList:returnVec[vocabList.index(word)] = 1else:print("the word: %s is not in my Vocabulary!" % word)# 返回向量文檔return returnVec"""" 函數說明：將切分的實驗樣本詞條整理成不重復的詞條列表，也就是詞匯表Parameters：dataSet：整理的樣本數據集 Returns：vocabSet：返回不重復的詞條列表，也就是詞匯表 Modify：2018-03-14"""def createVocabList(dataSet):# 創建一個空的不重復列表vocabSet = set([])for document in dataSet:# 取并集vocabSet = vocabSet | set(document)return list(vocabSet)""" 函數說明：根據vocabList詞匯表，構建詞袋模型Parameters:vocabList - createVocabList返回的列表inputSet - 切分的詞條列表 Returns:returnVec - 文檔向量,詞袋模型Modify:2018-03-14"""def bagOfWords2VecMN(vocabList, inputSet):# 創建一個其中所含元素都為0的向量returnVec = [0] * len(vocabList)# 遍歷每個詞條for word in inputSet:# 如果詞條存在于詞匯表中，則計數加一if word in vocabList:returnVec[vocabList.index(word)] += 1# 返回詞袋模型return returnVec""" 函數說明：樸素貝葉斯分類器訓練函數Parameters：trainMatrix：訓練文檔矩陣，即setOfWords2Vec返回的returnVec構成的矩陣trainCategory：訓練類別標簽向量，即loadDataSet返回的classVec Returns：p0Vect：侮辱類的條件概率數組p1Vect：非侮辱類的條件概率數組pAbusive：文檔屬于侮辱類的概率 Modify：2018-03-14"""def trainNB0(trainMtrix, trainCategory):# 計算訓練的文檔數目numTrainDocs = len(trainMtrix)# 計算每篇文章的詞條數numWords = len(trainMtrix[0])# 文檔屬于侮辱類的概率pAbusive = sum(trainCategory) / float(numTrainDocs)# 創建numpy.ones數組，詞條初始化為1，拉普拉斯平滑p0Num = np.ones(numWords);p1Num = np.ones(numWords)# 分母初始化為2.0，拉普拉斯平滑p0Denom = 2.0p1Denom = 2.0for i in range(numTrainDocs):# 統計屬于侮辱類的條件概率所需的數據，即P(w0|1),P(w1|1),P(w2|1)···if trainCategory[i] == 1:p1Num += trainMtrix[i]p1Denom += sum(trainMtrix[i])# 統計屬于非侮辱類的條件概率所需的數據，即P(w0|0),P(w1|0),P(w2|0)···else:p0Num += trainMtrix[i]p0Denom += sum(trainMtrix[i])# 相除p1Vect = np.log(p1Num / p1Denom)p0Vect = np.log(p0Num / p1Denom)# 返回屬于侮辱類的條件概率return p0Vect, p1Vect, pAbusive""" 函數說明:樸素貝葉斯分類器分類函數Parameters:vec2Classifyaaa：待分類的詞條數組p0Vec：侮辱類的條件概率數組p1Vec：非侮辱類的條件概率數組pClass1：文檔屬于侮辱類的概率 Returns:0 ：屬于非侮辱類1 ：屬于侮辱類 Modify:2018-03-14 """def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):# 對應元素相乘,logA*B=logA+logB，所以要加上np.log(pClass1)p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)if p1 > p0:return 1else:return 0""" 函數說明:接收一個大字符串并將其解析為字符串列表Parameters:無 Returns:無 Modify:2018-03-14 """def textParse(bigString):# 將特殊符號作為切分標志進行字符串切分，即非字母、非數字listOfTokens = re.split(r'\W*', bigString)# 除了單個字母，例如大寫的I，其它單詞變成小寫return [tok.lower() for tok in listOfTokens if len(tok) > 2]""" 函數說明：測試樸素貝葉斯分類器Parameters:無 Returns:無 Modify:2018-03-14"""def spamTest():docList = []classList = []fullText = []# 遍歷25個txt文件for i in range(1, 26):# 讀取每個垃圾郵件，并字符串轉換成字符串列表wordList = textParse(open('spam/%d.txt' % i, 'r').read())docList.append(wordList)fullText.append(wordList)# 標記非垃圾郵件，1表示垃圾郵件classList.append(1)# 讀取每個非垃圾郵件，并字符串轉換為字符串列表wordList = textParse(open('spam/%d.txt' % i, 'r').read())docList.append(wordList)fullText.append(wordList)# 標記非垃圾郵件，1表示垃圾郵件classList.append(0)# 創建詞匯表，不重復vocabList = createVocabList(docList)# 創建存儲訓練集的索引值的列表和測試集的索引值的列表trainingSet = list(range(50));testSet = []# 從50個郵件中，隨機挑選出40個作為訓練集,10個做測試集for i in range(10):# 隨機選取索索引值randIndex = int(random.uniform(0, len(trainingSet)))# 添加測試集的索引值testSet.append(trainingSet[randIndex])# 在訓練集列表中刪除添加到測試集的索引值del (trainingSet[randIndex])# 創建訓練集矩陣和訓練集類別標簽系向量trainMat = []trainClasses = []# 遍歷訓練集for docIndex in trainingSet:# 將生成的詞集模型添加到訓練矩陣中trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))# 將類別添加到訓練集類別標簽系向量中trainClasses.append(classList[docIndex])# 訓練樸素貝葉斯模型p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClasses))# 錯誤分類計數errorCount = 0# 遍歷測試集for docIndex in testSet:# 測試集的詞集模型wordVector = setOfWords2Vec(vocabList, docList[docIndex])# 如果分類錯誤，錯誤計數加1if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:errorCount += 1print("分類錯誤的測試集：", docList[docIndex])print('錯誤率：%.2f%%' % (float(errorCount) / len(testSet) * 100))if __name__ == '__main__':spamTest()

函數spamTest()會輸出在10封隨機選擇的電子郵件上的分類錯誤概率。既然這些電子郵件是隨機選擇的，所以每次的輸出結果可能有些差別。如果發現錯誤的話，函數會輸出錯誤的文檔的此表，這樣就可以了解到底是哪篇文檔發生了錯誤。如果想要更好地估計錯誤率，那么就應該將上述過程重復多次，比如說10次，然后求平均值。相比之下，將垃圾郵件誤判為正常郵件要比將正常郵件歸為垃圾郵件好。

4.6 樸素貝葉斯——新浪新聞分類（sklearn）

4.6.1 中文語句切分

可以直接使用第三方分詞組件，即jieba，也就是”結巴”。

在anaconda prompt中輸入：

pip install jieba

即可直接安裝。

官方教程：https://github.com/fxsjy/jieba

中文教程：https://www.oschina.net/p/jieba

數據集的分類結果如下：

切分中文語句代碼：

""" 函數說明：切分中文語句""" import os import jiebadef TextProcessing(folder_path):#查看folder_path下的文件folder_list=os.listdir(folder_path)#訓練集data_list=[]class_list=[]#遍歷每個子文件夾for folder in folder_list:#根據子文件夾，生成新的路徑new_folder_path=os.path.join(folder_path,folder)#存放子文件夾下的txt文件的列表files=os.listdir(new_folder_path)j=1#遍歷每個txt文件for file in files:#每類txt樣本數最多100個if j>100:break#打開txt文件with open(os.path.join(new_folder_path,file),'r',encoding='utf-8') as f:raw=f.read()#精簡模式，返回一個可迭代的generatorword_cut=jieba.cut(raw,cut_all=False)#generator轉換為listword_list=list(word_cut)data_list.append(word_list)class_list.append(folder)j+=1print(data_list)print(class_list)if __name__=='__main__':#文本預處理#訓練集存放地址folder_path='E:\python\machine learning in action\My Code\chap 04\SogouC\Sample'TextProcessing((folder_path))

結果：

4.6.2 文本特征選擇

我們將所有文本分成訓練集和測試集，并對訓練集中的所有單詞進行詞頻統計，并按降序排序。也就是將出現次數多的詞語在前，出現次數少的詞語在后進行排序。編寫代碼如下：

結果：

輸出的all_word_list就是將所有訓練集的切分結果按照詞頻降序排列構成的單詞集合，前面包含了很多標點符號，和“是”、“的”、“在”等詞語，及數字。所以要將這些去掉。

去掉的規則：去掉高頻詞，至于去掉多少，則根據高頻詞個數和最終檢測率的關系來確定。

如何去掉：可以使用已經整理好的stopwords_cn.txt文本：

可以根據這個文檔來去掉高頻詞，不作為分類的特征，首先去除100個，代碼如下：

""" 函數說明：切分中文語句""" import os import jieba import randomdef TextProcessing(folder_path,test_size = 0.2):#查看folder_path下的文件folder_list=os.listdir(folder_path)#訓練集data_list=[]class_list=[]#遍歷每個子文件夾for folder in folder_list:#根據子文件夾，生成新的路徑new_folder_path=os.path.join(folder_path,folder)#存放子文件夾下的txt文件的列表files=os.listdir(new_folder_path)j=1#遍歷每個txt文件for file in files:#每類txt樣本數最多100個if j>100:break#打開txt文件with open(os.path.join(new_folder_path,file),'r',encoding='utf-8') as f:raw=f.read()#精簡模式，返回一個可迭代的generatorword_cut=jieba.cut(raw,cut_all=False)#generator轉換為listword_list=list(word_cut)data_list.append(word_list)class_list.append(folder)j+=1#zip壓縮合并，將數據與標簽對應壓縮data_class_list=list(zip(data_list,class_list))#將data_class_list亂序random.shuffle(data_class_list)#訓練集與測試集切分的索引值index=int(len(data_class_list)*test_size)+1#訓練集train_list=data_class_list[index:]#測試集test_list=data_class_list[:index]#訓練集解壓縮train_data_list,train_class_list=zip(*train_list)#測試集解壓縮test_data_list,test_class_list=zip(*test_list)#統計訓練集詞頻all_words_dict={}for word_list in train_data_list:for word in word_list:if word in all_words_dict.keys():all_words_dict[word]+=1else:all_words_dict[word]=1#根據鍵值倒序排列all_words_tuple_list=sorted(all_words_dict.items(),key=lambdaf:f[1],reverse=True)#解壓縮all_words_list,all_words_nums=zip(*all_words_tuple_list)#轉換成列表all_words_list=list(all_words_list)return all_words_list,train_data_list,test_data_list,train_class_list,\test_class_list""" 函數說明：讀取文件中的內容并去重Parameters：words_file：文件路徑 Returns：word_set：讀取內容的set集合 Modify：2018-03-15""" def MakeWordSet(words_file):#創建set集合words_set=set()#打開文件with open(words_file,'r',encoding='utf-8') as f:#一行一行讀取for line in f.readlines():#去回車word=line.strip()#有文本，則添加到word_set中if len(word)>0:words_set.add(word)#返回處理結果return words_set""" 函數說明：文本特征提取 Parameters:all_words_list - 訓練集所有文本列表deleteN - 刪除詞頻最高的deleteN個詞stopwords_set - 指定的結束語 Returns:feature_words - 特征集 Modify:2018-03-15 """ def words_dict(all_words_list,deleteN,stopWords_set=set()):#特征列表feature_words=[]n=1for t in range(deleteN,len(all_words_list),1):#feature_words額維度為1000if n>1000:break#如果這個詞不是數字，且不是指定的結束語，并且單詞長度大于1小于5，那么這個詞就可以作為特征詞if not all_words_list[t].isdigit() and all_words_list[t] not in stopWords_set \and 1<len(all_words_list[t])<5:feature_words.append(all_words_list[t])n+=1return feature_wordsif __name__=='__main__':#文本預處理，訓練集存放的地址folder_path='E:\python\machine learning in action\My Code\chap 04\SogouC\Sample'all_words_list, train_data_list, test_data_list, train_class_list, \test_class_list=TextProcessing(folder_path,test_size=0.2)#生成stopwords_setstopwords_file='stopwords_cn.txt'stopwords_set=MakeWordSet(stopwords_file)feature_words=words_dict(all_words_list,100,stopwords_set)print(feature_words)

結果：

從結果可以看出，我們已經濾除了那些沒有用的詞組，這些feature_words就是我們最終選出用于新聞分類的特征，隨后就可以根據特征詞將文本向量化，然后用于訓練樸素貝葉斯分類器。

4.7 使用sklearn構建樸素貝葉斯分類器

官方文檔

在scikit-learn中，一共有3個樸素貝葉斯的分類算法類。分別是GaussianNB，MultinomialNB和BernoulliNB。

GaussianNB就是先驗為高斯分布的樸素貝葉斯；
MultinomialNB就是先驗為多項式分布的樸素貝葉斯；
BernoulliNB就是先驗為伯努利分布的樸素貝葉斯。

前面所講的的先驗概率模型就是先驗概率為多項式分布的樸素貝葉斯。

對于新聞的分類，屬于多分類問題，可以使用MultinomialNB來完成，假設特征的先驗概率為多項式分布：

class sklearn.naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)

alpha：浮點型可選參數，默認為1.0，其實就是添加拉普拉斯平滑，即為上述公式中的λ ，如果這個參數設置為0，就是不添加平滑；
fit_prior：布爾型可選參數，默認為True。布爾參數fit_prior表示是否要考慮先驗概率，如果是false,則所有的樣本類別輸出都有相同的類別先驗概率。否則可以自己用第三個參數class_prior輸入先驗概率，或者不輸入第三個參數class_prior讓MultinomialNB自己從訓練集樣本來計算先驗概率，此時的先驗概率為P(Y=Ck)=mk/m。其中m為訓練集樣本總數量，mk為輸出為第k類別的訓練集樣本數。
class_prior：可選參數，默認為None。

fit_priorclass_prior最終先驗概率

False	無意義	P(Y=C?k?)=1/k?
True	不填	P(Y=C?k?)=mk/m?
True	填	P(Y=C?k?)=class_prior?

提供的方法：

擬合：

fit：一般的擬合

partial_fit：一般用在訓練集數據量非常大，一次不能全部載入內存的時候，這個時候可以把訓練集分成若干等分，重復調用該方法來一步步學習訓練集。

預測：

predict：常用的預測方法，直接給出測試集的預測類別輸出

predict_log_proba：預測出的各個類別對數概率里的最大值對應的類別，也就是predict方法得到類別

predict_proba：它會給出測試集樣本在各個類別上預測的概率，預測出的各個類別概率里的最大值對應的類別，也就是predict方法得到類別。

確定要去掉的前deleteN個高頻詞的個數與最終檢測準確率的關系，確定deleteN的取值：

""" 函數說明：切分中文語句""" import os import jieba import random from sklearn.naive_bayes import MultinomialNB import matplotlib.pyplot as pltdef TextProcessing(folder_path,test_size = 0.2):#查看folder_path下的文件folder_list=os.listdir(folder_path)#訓練集data_list=[]class_list=[]#遍歷每個子文件夾for folder in folder_list:#根據子文件夾，生成新的路徑new_folder_path=os.path.join(folder_path,folder)#存放子文件夾下的txt文件的列表files=os.listdir(new_folder_path)j=1#遍歷每個txt文件for file in files:#每類txt樣本數最多100個if j>100:break#打開txt文件with open(os.path.join(new_folder_path,file),'r',encoding='utf-8') as f:raw=f.read()#精簡模式，返回一個可迭代的generatorword_cut=jieba.cut(raw,cut_all=False)#generator轉換為listword_list=list(word_cut)data_list.append(word_list)class_list.append(folder)j+=1#zip壓縮合并，將數據與標簽對應壓縮data_class_list=list(zip(data_list,class_list))#將data_class_list亂序random.shuffle(data_class_list)#訓練集與測試集切分的索引值index=int(len(data_class_list)*test_size)+1#訓練集train_list=data_class_list[index:]#測試集test_list=data_class_list[:index]#訓練集解壓縮train_data_list,train_class_list=zip(*train_list)#測試集解壓縮test_data_list,test_class_list=zip(*test_list)#統計訓練集詞頻all_words_dict={}for word_list in train_data_list:for word in word_list:if word in all_words_dict.keys():all_words_dict[word]+=1else:all_words_dict[word]=1#根據鍵值倒序排列all_words_tuple_list=sorted(all_words_dict.items(),key=lambdaf:f[1],reverse=True)#解壓縮all_words_list,all_words_nums=zip(*all_words_tuple_list)#轉換成列表all_words_list=list(all_words_list)return all_words_list,train_data_list,test_data_list,train_class_list,\test_class_list""" 函數說明：讀取文件中的內容并去重Parameters：words_file：文件路徑 Returns：word_set：讀取內容的set集合 Modify：2018-03-15""" def MakeWordSet(words_file):#創建set集合words_set=set()#打開文件with open(words_file,'r',encoding='utf-8') as f:#一行一行讀取for line in f.readlines():#去回車word=line.strip()#有文本，則添加到word_set中if len(word)>0:words_set.add(word)#返回處理結果return words_setdef TextFeatures(train_data_list, test_data_list, feature_words):# 出現在特征集中，則置1def text_features(text, feature_words):text_words = set(text)features = [1 if word in text_words else 0 for word in feature_words]return featurestrain_feature_list = [text_features(text, feature_words) for text in train_data_list]test_feature_list = [text_features(text, feature_words) for text in test_data_list]# 返回結果return train_feature_list, test_feature_list""" 函數說明：文本特征提取 Parameters:all_words_list - 訓練集所有文本列表deleteN - 刪除詞頻最高的deleteN個詞stopwords_set - 指定的結束語 Returns:feature_words - 特征集 Modify:2018-03-15 """ def words_dict(all_words_list,deleteN,stopWords_set=set()):#特征列表feature_words=[]n=1for t in range(deleteN,len(all_words_list),1):#feature_words額維度為1000if n>1000:break#如果這個詞不是數字，且不是指定的結束語，并且單詞長度大于1小于5，那么這個詞就可以作為特征詞if not all_words_list[t].isdigit() and all_words_list[t] not in stopWords_set \and 1<len(all_words_list[t])<5:feature_words.append(all_words_list[t])n+=1return feature_words""" 函數說明：新聞分類器parameters：train_feature_list - 訓練集向量化的特征文本test_feature_list - 測試集向量化的特征文本train_class_list - 訓練集分類標簽test_class_list - 測試集分類標簽 Returns:test_accuracy - 分類器精度 Modify:2018-03-15 """ def TextClassifier(train_feature_list,test_feature_list,train_class_list,test_class_list):classifier=MultinomialNB().fit(train_feature_list,train_class_list)test_accuracy=classifier.score(test_feature_list,test_class_list)return test_accuracyif __name__=='__main__':#文本預處理，訓練集存放的地址folder_path='E:\python\machine learning in action\My Code\chap 04\SogouC\Sample'all_words_list, train_data_list, test_data_list, train_class_list, \test_class_list=TextProcessing(folder_path,test_size=0.2)#生成stopwords_setstopwords_file='stopwords_cn.txt'stopwords_set=MakeWordSet(stopwords_file)test_accuracy_list=[]deleteNs=range(0,1000,20)for deleteN in deleteNs:feature_words=words_dict(all_words_list,deleteN,stopwords_set)train_feature_list,test_feature_list=TextFeatures(train_data_list,test_data_list,feature_words)test_accuracy=TextClassifier(train_feature_list,test_feature_list,train_class_list,test_class_list)test_accuracy_list.append(test_accuracy)plt.figure()plt.plot(deleteNs,test_accuracy_list)plt.title('Relationship of deleteNs and test_accuracy')plt.xlabel('deleteNs')plt.ylabel('test_accuracy')plt.show()

結果：

將代碼修改如下：

if __name__ == '__main__':#文本預處理folder_path = './SogouC/Sample' #訓練集存放地址all_words_list, train_data_list, test_data_list, train_class_list, test_class_list = TextProcessing(folder_path, test_size=0.2)# 生成stopwords_setstopwords_file = './stopwords_cn.txt'stopwords_set = MakeWordsSet(stopwords_file)test_accuracy_list = []feature_words = words_dict(all_words_list, 450, stopwords_set)train_feature_list, test_feature_list = TextFeatures(train_data_list, test_data_list, feature_words)test_accuracy = TextClassifier(train_feature_list, test_feature_list, train_class_list, test_class_list)test_accuracy_list.append(test_accuracy)ave = lambda c: sum(c) / len(c)

4.7 總結

在訓練樸素貝葉斯分類器之前，要處理好訓練集，文本的清洗還是有很多需要學習的東西。
根據提取的分類特征將文本向量化，然后訓練樸素貝葉斯分類器。
去高頻詞匯數量的不同，對結果也是有影響的的。
拉普拉斯平滑對于改善樸素貝葉斯分類器的分類效果有著積極的作用。

總結

以上是生活随笔為你收集整理的机器学习实战（四）——基于概率论的分类方法：朴素贝叶斯的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： csdn-markdown 编辑器
下一篇： Bootstrap框架