1. 前言
《朴素貝葉斯算法（Naive Bayes）》，介紹了朴素貝葉斯原理。本文介紹的是朴素貝葉斯的基礎實現，用來垃圾郵件分類。
2. 朴素貝葉斯基礎實現
朴素貝葉斯 (naive Bayes) 法是基於貝葉斯定理與特征條件獨立假設的分類的方法。對於給定的訓練數據集，首先基於特征條件獨立假設學習輸入/輸出的聯合概率分布；然后基於此模型，對於給定的輸入\(x\)，利用貝葉斯定理求出后驗概率最大的輸出\(y\)，完整代碼GitHub。
輸入：
#垃圾郵件的內容
posting_list = [
['my', 'dog', 'has', 'flea', 'problem', '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', 'ny', 'steak', 'how', 'to', 'stop', 'him'],
['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']
]
#是否是垃圾郵件的標簽
labels = [0, 1, 0, 1, 0, 1]
首先得根據上述文本建立一個詞匯表，即把重復的詞匯剔除。代碼如下：
def createVocabList(dataSet):
'''
創建所有文檔中出現的不重復詞匯列表
Args:
dataSet: 所有文檔
Return:
包含所有文檔的不重復詞列表，即詞匯表
'''
vocabSet = set([])
# 創建兩個集合的並集
for document in dataSet:
vocabSet = vocabSet | set(document)
return list(vocabSet)
然后需要把每句話轉化為詞袋模型(bag-of-words model)：
# 詞袋模型(bag-of-words model):詞在文檔中出現的次數
def bagOfWords2Vec(vocabList, inputSet):
'''
依據詞匯表，將輸入文本轉化成詞袋模型詞向量
Args:
vocabList: 詞匯表
inputSet: 當前輸入文檔
Return:
returnVec: 轉換成詞向量的文檔
例子：
vocabList = ['I', 'love', 'python', 'and', 'machine', 'learning']
inputset = ['python', 'machine', 'learning', 'python', 'machine']
returnVec = [0, 0, 2, 0, 2, 1]
長度與詞匯表一樣長，出現了的位置為1，未出現為0，如果詞匯表中無該單詞則print
'''
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
目前為止，我們把每份郵件轉化成了一系列的向量形式，向量的長度是詞表里面的詞的個數，是稀疏矩陣。
接下去就是朴素貝葉斯的步驟了，也就是訓練的過程：
def fit(self, trainMatrix, trainCategory):
'''
朴素貝葉斯分類器訓練函數，求：p(Ci),基於詞匯表的p(w|Ci)
Args:
trainMatrix : 訓練矩陣，即向量化表示后的文檔（詞條集合）
trainCategory : 文檔中每個詞條的列表標注
Return:
p0Vect : 屬於0類別的概率向量(p(w1|C0),p(w2|C0),...,p(wn|C0))
p1Vect : 屬於1類別的概率向量(p(w1|C1),p(w2|C1),...,p(wn|C1))
pAbusive : 屬於1類別文檔的概率
'''
numTrainDocs = len(trainMatrix)
# 長度為詞匯表長度
numWords = len(trainMatrix[0])
# p(ci)
self.pAbusive = sum(trainCategory) / float(numTrainDocs)
# 由於后期要計算p(w|Ci)=p(w1|Ci)*p(w2|Ci)*...*p(wn|Ci)，若wj未出現，則p(wj|Ci)=0,因此p(w|Ci)=0，這樣顯然是不對的
# 故在初始化時，將所有詞的出現數初始化為1，分母即出現詞條總數初始化為2
p0Num = np.ones(numWords)
p1Num = np.ones(numWords)
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])
# p(wi | c1)
# 為了避免下溢出（當所有的p都很小時，再相乘會得到0.0，使用log則會避免得到0.0）
self.p1Vect = np.log(p1Num / p1Denom)
# p(wi | c2)
self.p0Vect = np.log(p0Num / p0Denom)
return self
訓練完了，剩下的是對新數據的預測過程：
def predict(self, testX):
'''
朴素貝葉斯分類器
Args:
testX : 待分類的文檔向量（已轉換成array）
p0Vect : p(w|C0)
p1Vect : p(w|C1)
pAbusive : p(C1)
Return:
1 : 為侮辱性文檔 (基於當前文檔的p(w|C1)*p(C1)=log(基於當前文檔的p(w|C1))+log(p(C1)))
0 : 非侮辱性文檔 (基於當前文檔的p(w|C0)*p(C0)=log(基於當前文檔的p(w|C0))+log(p(C0)))
'''
p1 = np.sum(testX * self.p1Vect) + np.log(self.pAbusive)
p0 = np.sum(testX * self.p0Vect) + np.log(1 - self.pAbusive)
if p1 > p0:
return 1
else:
return 0
3. 總結
- 朴素貝葉斯模型發源於古典數學理論，有穩定的分類效率。
- 對小規模的數據表現很好，能個處理多分類任務，適合增量式訓練，尤其是數據量超出內存時，我們可以一批批的去增量訓練。
- 對缺失數據不太敏感，算法也比較簡單，常用於文本分類。