机器学习之朴素贝叶斯学习笔记

朴素贝叶斯

一、概述

朴素贝叶斯算法是有监督的学习算法，解决的是分类问题，如客户是否流失、是否值得投资、信用等级评定等多分类问题。该算法的优点在于简单易懂、学习效率高、在某些领域的分类问题中能够与决策树、神经网络相媲美。但由于该算法以自变量之间的独立（条件特征独立）性和连续变量的正态性假设为前提，就会导致算法精度在某种程度上受影响。

二、朴素贝叶斯理论

朴素贝叶斯是贝叶斯决策理论的一部分，所以在学习朴素贝叶斯之前有必要快速了解一下贝叶斯决策理论。

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

也就是说，我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。已经了解了贝叶斯决策理论的核心思想，那么接下来，就是学习如何计算p1和p2概率。

2、条件概率

条件概率(Conditional probability)，就是指在事件B发生的情况下，事件A发生的概率，用$P(A|B)$来表示。

$$C=A\cap B$$
根据文氏图，可以很清楚地看到在事件$B$发生的情况下,事件$A$发生的概率就是$P(A\cap B)$除以$P(B)$。
$$P(A|B)=\frac{P(A\cap B)}{P(B)}$$

为什么是这计算条件概率呢？

一般说到条件概率这一概念的时候，事件A和事件B都是同一实验下的不同的结果集合，事件A和事件B一般是有交集的，若没有交集（互斥），则条件概率为0。

由图再来理解一下这个问题：“B已经发生的条件下，A发生的概率”，这句话中，“B已经发生”就相当于已经把样本的可选范围限制在了圆圈B中，其实就等价于这句话：“在圆圈B中，A发生的概率”，显然$P(A|B)$就等于AB交集中样本的数目/B的样本数目。
$$P(A|B)=\frac{AB交集中样本的数目}{B的样本数目}$$

为什么这里用的是样本的数目相除，而上面的公式却是用的概率相除，原因很简单，用样本数目相除时，把分子分母同除以总样本数，这就变成了概率相除。

因此，设A,B是两个事件，且$P(B)>0$,则在事件$B$发生的条件下，事件A发生的条件概率（conditional probability)为：
$$P(A|B)=\frac{P(A\cap B)}{P(B)}$$

同理可得，
$$P(A|B)=\frac{P(B\cap A)}{P(A)}$$
变换可得，
$$P(A\cap B)=P(A|B)P(B)$$
同理亦可得，
$$P(A\cap B)=P(B|A)P(A)$$
所以，
$$P(A|B)P(B)=P(B|A)P(A)$$
即
$$P(A|B)=\frac{P(B|A)P(A)}{P(B)}$$
这就是条件概率的计算公式。

3、全概率公式

除了条件概率以外，在计算p1和p2的时候，还要用到全概率公式，因此，这里继续推导全概率公式。

假定样本空间S，是两个事件A与A’的和。
上图中，红色部分是事件A，绿色部分是事件A’，它们共同构成了样本空间S。

在这种情况下，事件B可以划分成两个部分。

即
$$P(B)=P(A\cap B)+P(A^{\prime }\cap B)$$
在上面的推导当中，我们已知
$$P(A\cap B)=P(B|A)P(A)$$
所以，
$$P(B)=P(B|A)P(A)+P(B|A^{\prime })P(A^{\prime })$$
这就是全概率公式。它的含义是，如果A和A'构成样本空间的一个划分，那么事件B的概率，就等于A和A'的概率分别乘以B对这两个事件的条件概率之和。

将这个公式代入上面的的条件概率公式，就得到了条件概率的另一种写法：
$$P(A|B)=\frac{P(B|A)P(A)}{P(B|A)P(A)+P(B|A^{\prime })P(A^{\prime })}$$

4、贝叶斯推断

对条件概率公式进行变形，可以得到如下形式：
$$P(A|B)=\frac{P(A\cap B)}{P(B)}=P(A)\frac{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的可能性变小。

为了加深对贝叶斯推断的理解，我们举一个例子。

问题1：

两个一模一样的碗，一号碗有30颗水果糖和10颗巧克力糖，二号碗有水果糖和巧克力糖各20颗。现在随机选择一个碗，从中摸出一颗糖，发现是水果糖。请问这颗水果糖来自一号碗的概率有多大？

求解：

假设，H1表示一号碗，H2表示二号碗。由于这两个碗是一样的，所以P(H1)=P(H2)，也就是说，在取出水果糖之前，这两个碗被选中的概率相同。因此，P(H1)=0.5，我们把这个概率就叫做"先验概率"，即没有做实验之前，来自一号碗的概率是0.5。

再假设，E表示水果糖，所以问题就变成了在已知E的情况下，来自一号碗的概率有多大，即求P(H1|E)。我们把这个概率叫做"后验概率"，即在E事件发生之后，对P(H1)的修正。

根据条件概率公式，得到
$$P(H1|E)=P(H1)\frac{P(E|H1)}{P(E)}$$
已知，P(H1)=0.5，P(E|H1)为一号碗中取出水果糖的概率，等于30÷(30+10)=0.75，那么求出P(E)就可以得到答案。根据全概率公式，
$$\begin{gathered} P(E)=P(E|H1)P(H1)+P(E|H2)P(H2) \\ =0.75\times 0.5+0.5\times 0.5=0.625 \end{gathered}$$
将数字代入原方程，得到
$$P(H1|E)=0.5\times \frac{0.75}{0.625}=0.6$$
这表明，来自一号碗的概率是0.6。也就是说，取出水果糖之后，H1事件的可能性得到了增强。

问题2：

两个一模一样的碗，一号碗有30颗水果糖和10颗巧克力糖，二号碗有水果糖和巧克力糖各20颗。现在随机选择一个碗，从中摸出一颗糖，发现是水果糖。请问这颗水果糖最有可能来自哪号碗？

求解：

假设，H1表示一号碗，H2表示二号碗,E表示水果糖。求解该问题，我们需要知道水果糖来自一号碗和二号碗的概率，即P(H1|E)和P(H2|E)。

根据条件概率公式，得到
$$P(H1|E)=P(H1)\frac{P(E|H1)}{P(E)}$$
$$P(H2|E)=P(H2)\frac{P(E|H2)}{P(E)}$$

根据上面公式，我们再思考一个问题，在使用该算法的时候，只需要知道所属类别，即来自一号碗还是二号碗，我们有必要计算P(E)这个全概率吗？

由于，P(H1)=P(H2)=0.5 ,而且P(H1|E)和P(H2|E)的分母都是相同的，既然如此，那我们只需要比较分子即可，即比较P(E|H1)P(H1)和P(E|H2)P(H2)的大小，那么我们就可以知道水果糖是来自一号碗还是二号碗，所以为了减少计算量，全概率公式在实际编程中可以不使用。

5、朴素贝叶斯推断

理解了贝叶斯推断，那么让我们继续看看朴素贝叶斯。贝叶斯和朴素贝叶斯的概念是不同的，区别就在于“朴素”二字，朴素贝叶斯对条件个概率分布做了条件独立性的假设。 比如下面的公式，假设有n个特征：
$$P(a|X)=P(a)\frac{P(X|a)}{P(X)}$$
其中，
$$X=x_1,x_2,...,x_n$$
由于X是独立分布的，所以
$$P(X)=P(x_1)+P(x_2)+...+P(x_n)=1$$
故，
$$P(a|X)=P(a)P(X|a)$$

由于每个特征都是独立的，我们可以进一步拆分公式 ：
$$\begin{gathered} P(a|X)=P(a)P(x_1,x_2,...,x_n|a) \\ =P(a)(P(x_1|a)\ast P(x_2|a)\ast ...\ast P(x_n|a)) \end{gathered}$$
这样我们就可以进行计算了。如果有些迷糊，让我们从一个例子开始讲起，你会看到贝叶斯分类器很好懂，一点都不难。

举例
某个医院早上来了六个门诊的病人，他们的情况如下表所示：

症状	职业	疾病
打喷嚏	护士	感冒
打喷嚏	农夫	过敏
头痛	建筑工人	脑震荡
头痛	建筑工人	感冒
打喷嚏	教师	感冒
头痛	教师	脑震荡

现在又来了第七个病人，是一个打喷嚏的建筑工人。请问他患上感冒的概率有多大？

根据贝叶斯定理：
$$P(A|B)=\frac{P(A)P(B|A)}{P(B)}$$
可得：
$$P(感冒|打喷嚏\times 建筑工人)=\frac{P(感冒)P(打喷嚏\times 建筑工人|感冒)}{P(打喷嚏\times 建筑工人)}$$

根据朴素贝叶斯条件独立性的假设可知，"打喷嚏"和"建筑工人"这两个特征是独立的，因此，上面的等式就变成了

$$P(感冒|打喷嚏\times 建筑工人)=\frac{P(感冒)\times P(打喷嚏|感冒)\times P(建筑工人|感冒)}{P(打喷嚏)\times P(建筑工人)}$$

这里可以计算,
$$P(感冒)=\frac{3}{6}=0.5$$

$$P(打喷嚏|感冒)=\frac{2}{3}=0.66$$

$$P(建筑工人|感冒)=\frac{1}{3}=0.33$$

$$P(建筑工人)=\frac{2}{6}=0.33$$

$$P(打喷嚏)=\frac{3}{6}=0.5$$

$$P(感冒|打喷嚏\times 建筑工人)=\frac{0.5\times 0.66\times 0.33}{0.5\times 0.33}$$
因此，这个打喷嚏的建筑工人，有66%的概率是得了感冒。同理，可以计算这个病人患上过敏或脑震荡的概率。比较这几个概率，就可以知道他最可能得什么病。

这就是贝叶斯分类器的基本方法：在统计资料的基础上，依据某些特征，计算各个类别的概率，从而实现分类。

同样，在编程的时候，如果不需要求出所属类别的具体概率，P(打喷嚏) = 0.5和P(建筑工人) = 0.33的概率是可以不用求的。

三、朴素贝叶斯 项目案例

项目案例1: 屏蔽社区留言板的侮辱性言论

朴素贝叶斯 开发流程

收集数据: 可以使用任何方法。
准备数据: 需要数值型或者布尔型数据。
分析数据: 有大量特征时，绘制特征作用不大，此时使用直方图效果更好。
训练算法: 计算不同的独立特征的条件概率。
测试算法: 计算错误率。
使用算法: 一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。

以在线社区留言为例。为了不影响社区的发展，我们要屏蔽侮辱性的言论，所以要构建一个快速过滤器，如果某条留言使用了负面或者侮辱性的语言，那么就将该留言标志为内容不当。过滤这类内容是一个很常见的需求。对此问题建立两个类型：侮辱类和非侮辱类，使用1和0分别表示。

把文本看成单词向量或者词条向量，也就是说将句子转换为向量。

1、构建数据集

"""
函数说明:创建实验样本
 
Parameters:
    无
Returns:
    postingList - 实验样本切分的词条
    classVec - 类别标签向量

"""
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']]
    classVec = [0,1,0,1,0,1]                                                                   #类别标签向量，1代表侮辱性词汇，0代表不是
    return postingList,classVec
 
if __name__ == '__main__':
    postingLIst, classVec = loadDataSet()
    for each in postingLIst:
        print(each)
    print(classVec)

从运行结果可以看出，我们已经将postingList是存放词条列表中，classVec是存放每个词条的所属类别，1代表侮辱类 ，0代表非侮辱类。

2、创建一个词汇表。

"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表
 
Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
"""
def createVocabList(dataSet):
    vocabSet = set([])                      #创建一个空的不重复列表
    for document in dataSet:               
        vocabSet = vocabSet | set(document) #取并集
    return list(vocabSet)
 

3、将切分好的词条转换为词条向量。

"""
函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
 
Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词集模型
"""
def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)  #创建一个其中所含元素都为0的向量
    for word in inputSet:  #遍历每个词条
        if word in vocabList:  #如果词条存在于词汇表中，则置1
            returnVec[vocabList.index(word)] = 1
        else: 
        	print("the word: %s is not in my Vocabulary!" % word)
    return returnVec  #返回文档向量

4、测试

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:
[[‘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’]]

myVocabList:
[‘cute’, ‘steak’, ‘flea’, ‘park’, ‘stop’, ‘please’, ‘to’, ‘dalmation’, ‘him’, ‘garbage’, ‘my’, ‘help’, ‘take’, ‘so’, ‘is’, ‘worthless’, ‘licks’, ‘love’, ‘stupid’, ‘posting’, ‘ate’, ‘how’, ‘dog’, ‘I’, ‘quit’, ‘food’, ‘has’, ‘maybe’, ‘mr’, ‘buying’, ‘problems’, ‘not’]
trainMat:
[[0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0]]

从运行结果可以看出，postingList是原始的词条列表，myVocabList是词汇表。myVocabList是所有单词出现的集合，没有重复的元素。

词汇表是用来干什么的？

没错，它是用来将词条向量化的，一个单词在词汇表中出现过一次，那么就在相应位置记作1，如果没有出现就在相应位置记作0。trainMat是所有的词条向量组成的列表。它里面存放的是根据myVocabList向量化的词条向量。

6、通过词条向量训练朴素贝叶斯分类器。

import numpy as np
"""
函数说明:朴素贝叶斯分类器训练函数
 
Parameters:
    trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵
    trainCategory - 训练类别标签向量，即loadDataSet返回的classVec
Returns:
    p0Vect - 非侮辱类的条件概率数组
    p1Vect - 侮辱类的条件概率数组
    pAbusive - 文档属于侮辱类的概率
"""
def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix) #计算训练的文档数目
    numWords = len(trainMatrix[0]) #计算每篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs) #文档属于侮辱类的概率
    p0Num = np.zeros(numWords); p1Num = np.zeros(numWords)#创建numpy.zeros数组,词条出现数初始化为0
    p0Denom = 0.0; p1Denom = 0.0   #分母初始化为0
    for i in range(numTrainDocs):
        if trainCategory[i] == 1: #统计属于侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)···
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        else:  #统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = p1Num/p1Denom                                      
    p0Vect = p0Num/p0Denom         
    return p0Vect,p1Vect,pAbusive   #返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率

7、代码分析：

1、从数据表中取一条文档，即

postingList[0] = [‘my’, ‘dog’, ‘has’, ‘flea’, ‘problems’, ‘help’, ‘please’]

文档中的‘my’, ‘dog’, ‘has’, ‘flea’, ‘problems’, ‘help’, ‘please’，为特征。

2、通过词汇表转为词向量

词汇表为，myVocabList:
['cute', 'steak', 'flea', 'park', 'stop', 'please', 'to', 'dalmation', 'him', 'garbage', 'my', 'help', 'take', 'so', 'is', 'worthless', 'licks', 'love', 'stupid', 'posting', 'ate', 'how', 'dog', 'I', 'quit', 'food', 'has', 'maybe', 'mr', 'buying', 'problems', 'not']

词汇表表中的元素可看作为特征，假定为 $w_1,w_2,...,w_n$,其中n为词典的长度。

通过setOfWords2Vec(myVocabList, postingList[0])转为词向量，即

[0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0]

根据上面的数据集，求属于侮辱类的概率有多大？

根据贝叶斯定理：
$$P(A|B)=\frac{P(A)P(B|A)}{P(B)}$$
可得，
$$P(侮辱|w_1,w_2,...,w_n)=\frac{P(侮辱)P(w_1,w_2,...,w_n|侮辱)}{P(w_1,w_2,...,w_n)}$$

因为，$w_1,w_2,...,w_n$是相互独立的特征，故
$$P(侮辱|w_1,w_2,...,w_n)=\frac{P(侮辱)P(w_1|侮辱)\ast P(w_2|侮辱)\ast ...\ast P(w_n|侮辱)}{P(w_1)\ast P(w_2)\ast ...\ast P(w_n)}$$

3、代码分析

trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵。
trainCategory - 训练类别标签向量，即loadDataSet返回的classVec。

文档属于侮辱类的概率

pAbusive = sum(trainCategory)/float(numTrainDocs) 

求的 $P(侮辱)$,也就是先验概率

for i in range(numTrainDocs):
#统计属于侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)···
    if trainCategory[i] == 1: #
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
    else:  #统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])

其中， p1Num += trainMatrix[i]是为了统计属于侮辱类的文档中的每个词条（也就是特征，$w_1,w_2,...,w_n$）的出现的次数。

而 p1Denom += sum(trainMatrix[i])是为了统计属于侮辱类的文档中的总的词数目，即所有词条出现的次数的总和，然后利用它求得每个词条（特征，$w_1,w_2,...,w_n$）出现的概率 P(w1),P(w2), P(w3)…

从上面第二小节，条件概率的为什么是这计算条件概率呢？

可知A在B下的条件概率，用的是样本的数目相除，而我们一般使用的概率相除,

$$P(A|B)=\frac{AB交集中样本的数目}{B的样本数目}$$
$$P(A|B)=\frac{\frac{AB交集中样本的数目}{总样本数}}{\frac{B的样本数目}{总样本数}}=\frac{P(A\cap B)}{P(B)}=\frac{P(A)P(B|A)}{P(B)}$$

原因很简单，用样本数目相除时，把分子分母同除以总样本数，这就变成了概率相除。

同样的道理，在代码中计算，侮辱类的文档中的每个词条的出现的次数/侮辱类的文档中的总的词数目

$$P(w_1,w_2,...,w_n|侮辱)=\frac{w_1,w_2,...,w_n}{总的词数目}$$

在侮辱类的条件下，统计词条属于侮辱类的条件概率，即P(w0|1),P(w1|1),P(w2|1)···

p1Vect = p1Num/p1Denom		#相除        

求得 ，$P(w_1|侮辱)\ast P(w_2|侮辱)\ast ...\ast P(w_n|侮辱)$，也就是调整因子的分子 。

非侮辱类与上面同样的道理。

测试

if __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，也就是非侮辱类词汇的概率。比如p0V的倒数第14个概率，就是stupid这个单词属于非侮辱类的概率为0。同理，p1V的倒数第14个概率，就是stupid这个单词属于侮辱类的概率为0.15789474，也就是约等于15.79%的概率。我们知道stupid的中文意思是蠢货，难听点的叫法就是傻逼。显而易见，这个单词属于侮辱类。

pAb是所有侮辱类的样本占所有样本的概率，从classVec中可以看出，一共有3个侮辱类，3个非侮辱类。所以侮辱类的概率是0.5。因此p0V存放的就是P(cute | 非侮辱类) = 0.0417，P(steak | 非侮辱类) = 0.0417，一直到P(not | 非侮辱类) = 0，这些单词的条件概率。同理，p1V存放的就是各个单词属于侮辱类的条件概率。pAb就是先验概率。

8、已经训练好分类器，接下来，使用分类器进行分类。

在 4、贝叶斯推断 中，我们提到，如果只需要知道所属类别 ，即来自一号碗还是二号碗，因为分母相同，那我们只需要比较分子即可，即比较P(E|H1)P(H1)和P(E|H2)P(H2) 的大小，我们就可以知道水果糖是来自一号碗还是二号碗，所以为了减少计算量，全概率公式在实际编程中可以不使用 。

同样的道理，在这里我们只计算
$$P(侮辱)P(w_1|侮辱)\ast P(w_2|侮辱)\ast ...\ast P(w_n|侮辱)$$

"""
函数说明:朴素贝叶斯分类器分类函数
 
Parameters:
    vec2Classify - 待分类的词条数组
    p0Vec - 侮辱类的条件概率数组
    p1Vec -非侮辱类的条件概率数组
    pClass1 - 文档属于侮辱类的概率
Returns:
    0 - 属于非侮辱类
    1 - 属于侮辱类
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = reduce(lambda x,y:x*y, vec2Classify * p1Vec) * pClass1                #对应元素相乘
    p0 = reduce(lambda x,y:x*y, vec2Classify * p0Vec) * (1.0 - pClass1)
    print('p0:',p0)
    print('p1:',p1)
    if p1 > p0:
        return 1
    else: 
        return 0

上面的代码中，
先计算， vec2Classify * p1Vec，得到测试数据的侮辱类的条件概率数组

然后计算，$$P(w_1|侮辱)\ast P(w_2|侮辱)\ast ...\ast P(w_n|侮辱)$$

最后计算，$$P(侮辱)P(w_1|侮辱)\ast P(w_2|侮辱)\ast ...\ast P(w_n|侮辱)$$

最后比较， p1 > p0，那个最大这个测试文档就属于那个类别。

"""
函数说明:测试朴素贝叶斯分类器
 
Parameters:
    无
Returns:
    无
"""
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)) #训练朴素贝叶斯分类器
    testEntry = ['love', 'my', 'dalmation']     #测试样本1
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))  #测试样本向量化
    if classifyNB(thisDoc,p0V,p1V,pAb):
        print(testEntry,'属于侮辱类')       #执行分类并打印分类结果
    else:
        print(testEntry,'属于非侮辱类')    #执行分类并打印分类结果
    testEntry = ['stupid', 'garbage']     #测试样本2
 
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry)) #测试样本向量化
    if classifyNB(thisDoc,p0V,p1V,pAb):
        print(testEntry,'属于侮辱类')      #执行分类并打印分类结果
    else:
        print(testEntry,'属于非侮辱类')  #执行分类并打印分类结果
 
if __name__ == '__main__':
    testingNB()

我们测试了两个词条，在使用分类器前，也需要对词条向量化，然后使用classifyNB()函数，用朴素贝叶斯公式，计算词条向量属于侮辱类和非侮辱类的概率。运行结果如下：

你会发现，这样写的算法无法进行分类，p0和p1的计算结果都是0，显然结果错误。这是为什么呢？

8、朴素贝叶斯改进之拉普拉斯平滑

利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算p(w0|1)p(w1|1)p(w2|1)。如果其中有一个概率值为0，那么最后的成绩也为0。如图所示，

从上图可以看出，在计算的时候已经出现了概率为0的情况。如果新实例文本，包含这种概率为0的分词，那么最终的文本属于某个类别的概率也就是0了。显然，这样是不合理的，为了降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。这种做法就叫做拉普拉斯平滑(Laplace Smoothing)又被称为加1平滑，是比较常用的平滑方法，它就是为了解决0概率问题。

除此之外，另外一个遇到的问题就是下溢出，这是由于太多很小的数相乘造成的。学过数学的人都知道，两个小数相乘，越乘越小，这样就造成了下溢出。在程序中，在相应小数位置进行四舍五入，计算结果可能就变成0了。一种解决办法是对乘积取自然对数。在代数中有 ln(a * b) = ln(a) + ln(b), 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。

下图给出了函数 f(x) 与 ln(f(x)) 的曲线。可以看出，它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。

因此我们可以对面的trainNB0(trainMatrix, trainCategory)函数进行更改，修改如下：

"""
函数说明:朴素贝叶斯分类器训练函数
 
Parameters:
    trainMatrix - 训练文档矩阵，即setOfWords2Vec返回的returnVec构成的矩阵
    trainCategory - 训练类别标签向量，即loadDataSet返回的classVec
Returns:
    p0Vect - 非侮辱类的条件概率数组
    p1Vect - 侮辱类的条件概率数组
    pAbusive - 文档属于侮辱类的概率
"""
def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)  #计算训练的文档数目
    numWords = len(trainMatrix[0])  #计算每篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs) #文档属于侮辱类的概率
    p0Num = np.ones(numWords); p1Num = np.ones(numWords) #创建numpy.ones数组,词条出现数初始化为1，拉普拉斯平滑
    p0Denom = 2.0; p1Denom = 2.0   #分母初始化为2,拉普拉斯平滑
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:  #统计属于侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)···
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        else:  #统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = np.log(p1Num/p1Denom)  #取对数，防止下溢出         
    p0Vect = np.log(p0Num/p0Denom)         
    return p0Vect,p1Vect,pAbusive  #返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率
    
if __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)

运行代码，就可以得到如下结果：

myVocabList:
 ['dog', 'steak', 'buying', 'park', 'quit', 'how', 'garbage', 'help', 'stop', 'mr', 'stupid', 'take', 'is', 'cute', 'food', 'him', 'dalmation', 'my', 'to', 'love', 'so', 'licks', 'ate', 'maybe', 'problems', 'worthless', 'posting', 'not', 'flea', 'has', 'please', 'I']
p0V:
 [-2.56494936 -2.56494936 -3.25809654 -3.25809654 -3.25809654 -2.56494936
 -3.25809654 -2.56494936 -2.56494936 -2.56494936 -3.25809654 -3.25809654
 -2.56494936 -2.56494936 -3.25809654 -2.15948425 -2.56494936 -1.87180218
 -2.56494936 -2.56494936 -2.56494936 -2.56494936 -2.56494936 -3.25809654
 -2.56494936 -3.25809654 -3.25809654 -3.25809654 -2.56494936 -2.56494936
 -2.56494936 -2.56494936]
p1V:
 [-1.94591015 -3.04452244 -2.35137526 -2.35137526 -2.35137526 -3.04452244
 -2.35137526 -3.04452244 -2.35137526 -3.04452244 -1.65822808 -2.35137526
 -3.04452244 -3.04452244 -2.35137526 -2.35137526 -3.04452244 -3.04452244
 -2.35137526 -3.04452244 -3.04452244 -3.04452244 -3.04452244 -2.35137526
 -3.04452244 -1.94591015 -2.35137526 -2.35137526 -3.04452244 -3.04452244
 -3.04452244 -3.04452244]
classVec:
 [0, 1, 0, 1, 0, 1]
pAb:
 0.5

这样我们得到的结果就没有问题了，不存在0概率。当然除此之外，我们还需要对代码进行修改classifyNB(vec2Classify, p0Vec, p1Vec, pClass1)函数，修改如下：

"""
函数说明:朴素贝叶斯分类器分类函数
 
Parameters:
    vec2Classify - 待分类的词条数组
    p0Vec - 非侮辱类的条件概率数组
    p1Vec -侮辱类的条件概率数组
    pClass1 - 文档属于侮辱类的概率
Returns:
    0 - 属于非侮辱类
    1 - 属于侮辱类
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)        #对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
    p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
    print('p0:',p0)
    print('p1:',p1)
    if p1 > p0:
        return 1
    else:
        return 0

为啥这么改？

因为取自然对数了。logab = loga + logb。

测试

if __name__ == '__main__':
    testingNB()

运行结果如下：

这样，我们的朴素贝叶斯分类器就改进完毕了。

项目案例2: 使用朴素贝叶斯过滤垃圾邮件

概述

在上面的简单例子中，我们引入了字符串列表。使用朴素贝叶斯解决一些现实生活中的问题时，需要先从文本内容得到字符串列表，然后生成词向量。下面这个例子中，我们将了解朴素贝叶斯的一个最著名的应用：电子邮件垃圾过滤。

首先看一下使用朴素贝叶斯对电子邮件进行分类的步骤：

收集数据：提供文本文件。
准备数据：将文本文件解析成词条向量。
分析数据：检查词条确保解析的正确性。
训练算法：使用我们之前建立的trainNB0()函数。
测试算法：使用classifyNB()，并构建一个新的测试函数来计算文档集的错误率。
使用算法：构建一个完整的程序对一组文档进行分类，将错分的文档输出到屏幕上。

1、收集数据

数据可以在Github上下载： 数据集下载

有两个文件夹ham和spam，spam文件下的txt文件为垃圾邮件。

2、准备数据

对于英文文本，我们可以以非字母、非数字作为符号进行切分，使用split函数即可。编写代码如下：

import re
 
"""
函数说明:接收一个大字符串并将其解析为字符串列表
 
Parameters:
    无
Returns:
    无
"""
def textParse(bigString):   #将字符串转换为字符列表
    listOfTokens = re.split(r'\W+', bigString)  #将特殊符号作为切分标志进行字符串切分，即非字母、非数字
    return [tok.lower() for tok in listOfTokens if len(tok) > 2] #除了单个字母，例如大写的I，其它单词变成小写

这里使用\W 或者\W+ 都可以将字符数字串分割开，产生的空字符将会在后面的列表推导式中过滤掉

**测试**
```python
if __name__ == '__main__':
    # spamTest()
    listOfTokens = re.split(r'\W+', open('email/ham/1.txt', 'r').read())
    print(listOfTokens)    
    wordList=textParse(open('email/ham/1.txt', 'r').read())
    print()

listOfTokens：    
['Hi', 'Peter', 'With', 'Jose', 'out', 'of', 'town', 'do', 'you', 'want', 'to', 'meet', 'once', 'in', 'a', 'while', 'to', 'keep', 'things', 'going', 'and', 'do', 'some', 'interesting', 'stuff', 'Let', 'me', 'know', 'Eugene']

 wordList：
['peter', 'with', 'jose', 'out', 'town', 'you', 'want', 'meet', 'once', 'while', 'keep', 'things', 'going', 'and', 'some', 'interesting', 'stuff', 'let', 'know', 'eugene']    

构建词汇表

"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表
 
Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
"""
def createVocabList(dataSet):
    vocabSet = set([])   #创建一个空的不重复列表
    for document in dataSet:               
        vocabSet = vocabSet | set(document) #取并集
    return list(vocabSet)
 
if __name__ == '__main__':
    docList = []; classList = []
    for i in range(1, 26):    #遍历25个txt文件
        wordList = textParse(open('email/spam/%d.txt' % i, 'r').read()) #读取每个垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        classList.append(1)   #标记垃圾邮件，1表示垃圾文件
        wordList = textParse(open('email/ham/%d.txt' % i, 'r').read())  #读取每个非垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        classList.append(0)  #标记非垃圾邮件，1表示垃圾文件   
    vocabList = createVocabList(docList)  #创建词汇表，不重复
    print(vocabList)

这样我们就得到了词汇表，结果如下所示：

['told', 'mail', '750', 'jewerly', 'automatically', 'ultimate', 'series', 'couple', 'either', 'yeah', '570', 'them', 'assigning', 'knocking', 'concise', 'creative', 'credit', 'don抰', 'moderate', 'days', 'can', 'trusted', 'vivek', 'changing', 'hold', 'doctor', 'hommies', 'window', '5mg', 'blue', 'hamm', '119', 'keep', 'view', '15mg', 'had', 'plus', '0nline', 'opportunity', 'level', 'where', '292', 'mandatory', 'mathematician', 'includes', 'jquery', 'of_penisen1argement', 'have', 'bike', 'call', 'cards', 'copy', 'see', 'ambiem', 'fedex', 'recieve', 'behind', 'cost', 'tabs', 'dhl', 'share', 'eugene', 'supplement', 'http', 'any', 'not', '625', 'year', 'might', 'peter', 'will', 'but', 'improving', 'you抮e', 'starting', 'today', 'sky', 'been', 'what', 'thousand', 'watchesstore', 'featured', 'vicodin', 'cartier', 'ems', 'doing', 'length', 'think', 'the', 'buy', 'than', 'then', 'approach', 'saw', 'while', 'moderately', 'town', 'things', 'interesting', 'python', 'thanks', '156', '588', '225', 'linkedin', 'others', 'below', 'strategy', 'right', 'pro', 'required', 'being', 'support', '100m', 'based', 'add', 'discussions', 'storedetailview_98', '325', 'certified', 'issues', 'price', 'effective', 'designed', 'jpgs', 'two', 'close', '200', '66343', 'nvidia', '50mg', 'plugin', 'thailand', 'ideas', 'let', 'done', 'like', '138', 'haloney', 'rude', 'freeviagra', 'reputable', 'suggest', 'dusty', 'low', 'network', '2011', 'lists', 'and', 'china', 'answer', 'thread', 'often', 'example', 'over', 'thirumalai', 'class', 'code', 'discount', 'source', 'riding', 'brand', 'drunk', 'pricing', 'about', 'using', 'said', 'off', 'inform', 'status', 'must', 'working', 'harderecetions', 'articles', 'perhaps', 'leaves', 'gucci', 'number', 'some', 'model', 'john', 'more', 'focus', 'pain', 'fine', 'pretty', 'too', '291', 'generation', 'program', 'museum', 'easily', 'save', 'jqplot', 'strategic', 'individual', 'incoming', 'cold', '129', 'narcotic', 'germany', 'party', 'mailing', 'province', '300x', 'monte', 'opioid', 'good', '100mg', 'come', 'hermes', 'bad', '180', 'via', 'from', 'hello', 'watson', 'permanantly', 'october', '195', 'financial', 'that', 'sophisticated', 'quality', 'all', 'enabled', 'accept', 'arvind', 'earn', 'fundamental', 'mandelbrot', 'analgesic', 'www', 'latest', 'know', 'mandarin', 'brands', 'com', 'holiday', '30mg', 'giants', 'went', 'percocet', 'guaranteeed', 'day', 'how', 'chinese', 'want', 'roofer', 'tiffany', 'ryan', 'computing', 'use', 'edit', 'amazing', 'chance', 'courier', 'automatic', 'well', 'another', 'school', 'much', 'pictures', 'hours', 'requested', 'don', 'delivery', 'experience', '14th', 'would', 'who', 'dior', 'team', 'yay', 'transformed', 'has', 'update', 'dozen', 'wholesale', 'now', 'item', 'survive', 'prepared', 'faster', 'canadian', 'sent', 'past', 'adobe', 'owner', 'food', 'experts', 'bargains', 'fermi', 'retirement', 'cuda', 'lunch', 'ferguson', 'invitation', 'inches', 'notification', '492', 'moneyback', 'magazine', 'oem', 'increase', 'buyviagra', 'endorsed', 'cheers', 'stuff', 'success', 'questions', 'bags', 'game', 'per', 'worldwide', 'most', 'wilmott', 'forward', 'your', 'supporting', 'foaming', 'cs5', 'regards', 'products', 'members', 'wasn', 'longer', 'discreet', 'top', 'shipment', 'book', 'tool', 'scenic', '203', 'reply', 'warranty', 'least', 'core', 'home', 'should', 'jose', 'color', 'used', '219', '50092', 'cannot', 'genuine', 'died', 'site', 'release', 'find', 'you', 'gpu', 'louis', 'because', 'once', 'knew', '100', 'full', 'methylmorphine', 'file', 'explosive', 'care', 'glimpse', 'just', 'link', 'competitive', '120', 'style', 'significantly', 'sorry', 'sounds', 'time', 'made', 'herbal', '1924', 'looking', '2007', 'creation', 'zolpidem', 'may', '25mg', 'need', 'bathroom', 'are', 'computer', 'viagranoprescription', 'welcome', 'guy', 'noprescription', 'jay', 'those', 'thickness', 'reliever', 'writing', 'hope', 'work', 'since', 'great', 'pick', 'name', 'spaying', 'cca', 'softwares', 'horn', 'tour', 'millions', 'customized', 'back', 'vuitton', 'naturalpenisenhancement', 'only', 'functionalities', 'contact', 'superb', 'assistance', 'expertise', 'specifications', 'prices', '90563', 'changes', 'received', 'possible', 'carlo', 'inside', 'ofejacu1ate', 'get', 'page', 'insights', 'coast', 'message', 'chapter', 'biggerpenis', 'pills', 'try', 'inconvenience', 'shipping', 'each', 'parallel', 'got', 'items', 'control', 'kerry', 'gains', 'store', 'extended', 'quantitative', 'brandviagra', 'held', 'station', 'learn', 'download', 'job', 'inspired', 'tokyo', 'works', 'betterejacu1ation', 'prototype', 'thing', 'natural', 'february', 'night', 'away', 'serial', 'location', 'business', 'enjoy', 'lined', 'was', 'heard', 'development', 'net', 'speedpost', 'high', 'take', 'also', 'rain', 'hotel', 'create', 'note', 'tickets', 'rock', 'pharmacy', 'these', 'ordercializviagra', 'mathematics', 'fans', 'major', 'far', 'please', 'website', 'winter', 'amex', 'connection', 'pavilion', 'office', 'jocelyn', 'plane', '2010', '10mg', 'came', 'girl', 'capabilities', 'new', 'gain', 'treat', 'uses', 'phone', 'advocate', 'safest', 'watches', '130', 'safe', 'listed', 'microsoft', 'information', 'grow', 'cats', '385', 'address', 'upload', 'father', 'encourage', 'exhibit', 'definitely', '86152', 'does', 'finder', 'york', 'car', 'there', 'wilson', '322', 'finance', 'thought', 'severepain', 'turd', 'proven', 'specifically', 'drugs', 'fda', 'google', 'email', 'photoshop', 'free', 'one', 'needed', 'nature', 'volume', 'mom', 'acrobat', 'professional', 'arolexbvlgari', '430', 'generates', 'announcement', 'hangzhou', 'meet', 'running', 'selected', 'incredib1e', 'cat', 'phentermin', 'grounds', 'methods', 'benoit', 'door', 'ma1eenhancement', 'ones', 'private', 'fast', 'stepp', 'help', 'files', 'windows', 'commented', 'shape', 'approved', 'mba', 'ready', 'julius', 'wednesday', '174623', 'wallets', 'instead', 'comment', 'check', 'with', 'express', 'sites', 'tent', 'here', 'ups', 'place', 'expo', 'sliding', 'web', 'programming', 'money', '396', 'focusing', 'located', '199', 'management', 'modelling', 'intenseorgasns', 'bin', 'trip', 'group', 'everything', 'order', 'through', 'yourpenis', 'rent', 'tesla', 'hotels', 'pls', '513', 'fbi', 'femaleviagra', 'art', 'wrote', 'whybrew', 'could', 'butt', 'jar', 'borders', 'design', 'way', 'doggy', 'famous', 'yesterday', 'out', 'decision', 'runs', 'visa', 'income', 'codeine', 'same', 'talked', 'oris', 'they', 'differ', 'sure', '366', 'zach', 'scifinance', 'attaching', 'placed', 'troy', 'follow', 'this', 'important', 'such', 'enough', 'both', 'huge', 'service', 'pages', 'online', 'brained', 'withoutprescription', 'signed', 'hydrocodone', 'when', 'thank', 'bettererections', 'gas', 'pill', 'access', 'features', 'launch', 'forum', 'doors', 'storage', '562', 'life', 'aged', 'going', 'derivatives', 'train', 'cheap', 'groups', 'his', 'logged', 'accepted', 'having', 'titles', 'risk', 'favorite', 'fractal', 'reservation', 'docs', 'for']

4、训练和测试算法

根据词汇表，我们就可以将每个文本向量化。我们将数据集分为训练集和测试集，并随机选择10个测试样本测试朴素贝叶斯分类器的准确性。编写代码如下：

import numpy as np
import random
import re

"""
函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
 
Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词集模型
"""
def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)  #创建一个其中所含元素都为0的向量
    for word in inputSet:    #遍历每个词条
        if word in vocabList:  #如果词条存在于词汇表中，则置1
            returnVec[vocabList.index(word)] = 1
        else: print("the word: %s is not in my Vocabulary!" % word)
    return returnVec    #返回文档向量

"""
函数说明:根据vocabList词汇表，构建词袋模型
 
Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词袋模型
"""
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)    #创建一个其中所含元素都为0的向量
    for word in inputSet:    #遍历每个词条
        if word in vocabList:  #如果词条存在于词汇表中，则计数加一
            returnVec[vocabList.index(word)] += 1
    return returnVec   #返回词袋模型 

测试朴素贝叶斯分类器

"""
函数说明:测试朴素贝叶斯分类器
 
Parameters:
    无
Returns:
    无
"""
def spamTest():
    docList = []; classList = []; fullText = []
    for i in range(1, 26):    #遍历25个txt文件,
        wordList = textParse(open('email/spam/%d.txt' % i, 'r').read())  #读取每个垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(1)   #标记垃圾邮件，1表示垃圾文件
        wordList = textParse(open('email/ham/%d.txt' % i, 'r').read())   #读取每个非垃圾邮件，并字符串转换成字符串列表
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(0)    #标记非垃圾邮件，1表示垃圾文件   
    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]) #测试集的词集模型
        if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]: #如果分类错误
            errorCount += 1   #错误计数加1
            print("分类错误的测试集：",docList[docIndex])
    print('错误率：%.2f%%' % (float(errorCount) / len(testSet) * 100))
 
 
if __name__ == '__main__':
    spamTest()

执行结果为：

函数spamTest()会输出在10封随机选择的电子邮件上的分类错误概率。既然这些电子邮件是随机选择的，所以每次的输出结果可能有些差别。如果发现错误的话，函数会输出错误的文档的此表，这样就可以了解到底是哪篇文档发生了错误。如果想要更好地估计错误率，那么就应该将上述过程重复多次，比如说10次，然后求平均值。相比之下，将垃圾邮件误判为正常邮件要比将正常邮件归为垃圾邮件好。为了避免错误，有多种方式可以用来修正分类器。

相关代码获取：代码获取

项目案例3: 朴素贝叶斯之新浪新闻分类(Sklearn)

1、中文语句切分

考虑一个问题，英文的语句可以通过非字母和非数字进行切分，但是汉语句子呢？就比如我打的这一堆字，该如何进行切分呢？我们自己写个规则？

幸运地是，这部分的工作不需要我们自己做了，可以直接使用第三方分词组件，即jieba，没错就是"结巴"。

jieba已经兼容Python2和Python3，使用如下指令直接安装即可：

pip3 install jieba

Python中文分词组件使用简单：

民间教程：https://www.oschina.net/p/jieba
官方教程：https://github.com/fxsjy/jieba

新闻分类数据集我也已经准备好，可以到我的Github进行下载：数据集下载

数据集已经做好分类，分文件夹保存，分类结果如下：

C000008	财经
C000010	IT
C000013	健康
C000014	体育
C000016	旅游
C000020	教育
C000022	招聘
C000023	文化
C000024	军事

数据集已经准备好，接下来，让我们直接进入正题。切分中文语句，编写如下代码：

# -*- coding: UTF-8 -*-
import os
import jieba
 
def TextProcessing(folder_path):
    folder_list = os.listdir(folder_path) #查看folder_path下的文件
    data_list = []   #训练集
    class_list = []  #遍历每个子文件夹
    for folder in folder_list:
        new_folder_path = os.path.join(folder_path, folder) #根据子文件夹，生成新的路径
        files = os.listdir(new_folder_path) #存放子文件夹下的txt文件的列表 
        j = 1
        #遍历每个txt文件
        for file in files:
            if j > 100:  #每类txt样本数最多100个
                break
            #打开txt文件
            with open(os.path.join(new_folder_path, file), 'r', encoding = 'utf-8') as f: 
                raw = f.read() 
            #精简模式，返回一个可迭代的generator
            word_cut = jieba.cut(raw, cut_all = False)            
            word_list = list(word_cut)  #generator转换为list
 
            data_list.append(word_list)
            class_list.append(folder,len(folder))
            j += 1
    print(data_list)
    print(class_list)
if __name__ == '__main__':
    #文本预处理
    folder_path = './SogouC/Sample' #训练集存放地址
    TextProcessing(folder_path)

执行结果为：

2、文本特征选择

将所有文本分成训练集和测试集，并对训练集中的所有单词进行词频统计，并按降序排序。也就是将出现次数多的词语放在前，出现次数少的词语在后进行排序。编写代码如下：

import os
import random
import jieba
 
"""
函数说明:中文文本处理
 
Parameters:
    folder_path - 文本存放的路径
    test_size - 测试集占比，默认占所有数据集的百分之20
Returns:
    all_words_list - 按词频降序排序的训练集列表
    train_data_list - 训练集列表
    test_data_list - 测试集列表
    train_class_list - 训练集标签列表
    test_class_list - 测试集标签列表
"""
def TextProcessing(folder_path, test_size = 0.2):
    folder_list = os.listdir(folder_path)  #查看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:
            if j > 100: #每类txt样本数最多100个                                        
                break
            #打开txt文件
            with open(os.path.join(new_folder_path, file), 'r', encoding = 'utf-8') as f:   
                raw = f.read()
            #精简模式，返回一个可迭代的generator#精简模式，返回一个可迭代的generator
            word_cut = jieba.cut(raw, cut_all = False)            
            word_list = list(word_cut) #generator转换为list
 
            data_list.append(word_list) #添加数据集数据
            class_list.append(folder) #添加数据集类别
            j += 1
 
    data_class_list = list(zip(data_list, class_list)) #zip压缩合并，将数据与标签对应压缩
    random.shuffle(data_class_list) #将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] += 1
            else:
                all_words_dict[word] = 1 
    #根据键的值倒序排序
    all_words_tuple_list = sorted(all_words_dict.items(), key = lambda f: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
 
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)
    print(all_words_list)

all_words_list就是将所有训练集的切分结果通过词频降序排列构成的单词合集。观察一下打印结果，不难发现，这里包含了很多标点符号，很显然，这些标点符号是不能作为新闻分类的特征的。

为了降低这些高频的符号对分类结果的影响，我们应该怎么做呢？

抛弃他们！ 除了这些，还有"在"，"了"这样对新闻分类无关痛痒的词。并且还有一些数字，数字显然也不能作为分类新闻的特征。所以要消除它们对分类结果的影响，我们可以定制一个规则。

一个简单的规则可以这样制定：首先去掉高频词，至于去掉多少个高频词，我们可以通过观察去掉高频词个数和最终检测准确率的关系来确定。除此之外，去除数字，不把数字作为分类特征。同时，去除一些特定的词语，比如："的"，"一"，"在"，"不"，“当然”,"怎么"这类的对新闻分类无影响的介词、代词、连词。

怎么去除这些词呢？

可以使用已经整理好的stopwords_cn.txt文本。下载地址：点我下载

这个文件是这个样子的：

我们可以根据这个文档，将这些单词去除，不作为分类的特征。我们先去除前100个高频词汇，然后编写代码如下：

读取文件里的内容，并去重

"""
函数说明:读取文件里的内容，并去重
 
Parameters:
    words_file - 文件路径
Returns:
    words_set - 读取的内容的set集合
"""
def MakeWordsSet(words_file):
    words_set = set()   #创建set集合
    with open(words_file, 'r', encoding = 'utf-8') as f:  #打开文件
        for line in f.readlines():   #一行一行读取
            word = line.strip()    #去回车
            if len(word) > 0:   #有文本，则添加到words_set中
                words_set.add(word)                               
    return words_set      #返回处理结果

文本特征选取

"""
函数说明:文本特征选取
 
Parameters:
    all_words_list - 训练集所有文本列表
    deleteN - 删除词频最高的deleteN个词
    stopwords_set - 指定的结束语
Returns:
    feature_words - 特征集
"""
def words_dict(all_words_list, deleteN, stopwords_set = set()):
    feature_words = []    #特征列表
    n = 1
    for t in range(deleteN, len(all_words_list), 1):
        if n > 1000:     #feature_words的维度为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 += 1   
    return feature_words

测试

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_set
    stopwords_file = './stopwords_cn.txt'
    stopwords_set = MakeWordsSet(stopwords_file)
 
    feature_words = words_dict(all_words_list, 100, stopwords_set)
    print(feature_words)

执行结果为

['成为', '支付', '目前', '仿制', '学校', '企业', '发展', '问题', '选择', '远程', '主要', '品牌', '工作', '通过', '建设', '射程', '银行', '可能', '完全', '分析', '复习', '学习', '上海', '部署', '亿美元', '开始', '很多', '词汇', '比赛', '专业', '文章', '能力', '电话', '辅导班', '考试', '基础', '使用', '填报', '五一', '达到', '部队', '比较', '部分', '技术', '管理', '表现', '服务', '产品', '重要', '情况', '表示', '拥有', '阵地', '一定', '相对', '提高', '训练', '记者', '用户', '现在', '相关', '军事', '几乎', '资料', '科学', '需要', '来源', '英语', '阅读', '要求', '历史', '坦克', '一家', '期间', '这是', '写作', '了解', '影响', '考研', '网络', '提供', '东莞', '实验室', '专家', '老师', '彻底', '准备', '必须', '黄金周', '公里', '大批', '不用', '压制', '今年', '人数', '计划', '增长', '系统', '装备', '我国', '专利', '时候', '员工', '应该', '方面', '显示', '国家', '距离', '岛屿', '数字', '游戏', '手机', '印度', '阿里', '耿大勇', '设计', '告诉', '一直', 'MBA', '建议', '日本', '协议', '不同', '沿海', '力气', '摧毁', '经济', '指挥', '全国', '知道', '最后', '参加', '最大', '挑衅', '角度', '数独', '接待', '平台', '一批', '新型', '全军', '两个', '台湾', '一次', '不能', '机会', '希望', '非常', '方式', '全球', '自寻死路', '世界领先', '型号', '开战', '金贵', '置于', '海量', '之内', '费多', '廉价', '国内', '万人次', '纳斯', '战场', '收入', '发展观', '医院', '第一', '目标', '活动', '这家', '沈阳市', '进入', '地方', '排名', '文化', '广东', '重点', '教育', '药厂', '获得', '消费者', '作用', '正在', '东引岛', '武器', '军队', '香港', '去年', '网上', '信息化', '推出', '我军', '录取', '预期', '止痛药', '知名', '喜欢', '不会', '语法', '得到', '备考', '全面', '句子', '此前', '世界', '介绍', '决定', '完成', '这种', '利用', '数学', '出现', '事情', '包括', '大学生', '复试', '理由', '未来', '电脑', '销售', 'VS', '治疗', '顾客', '分期付款', '发现', '是否', '成功', '结果', '项目', '分钟', '原因', '实现', '数据', '交易', '越来越', '左右', '火力', '设立', '基本', '院校', '组织', '演练', '医疗', '孩子', '本场', '药物', '镇痛药', '有限公司', '努力', '每个', '领导', '一年', '中心', '知识', '掌握', '小时', '信息', '之后', '一下', '吸引', '整个', '超过', '埃及', '面对', '詹姆斯', '帮助', '内容', '认证', '上市', '学员', '患者', '利苑', '考虑', '根本', '客户', '实施', '简历', '这一', '注意', '大学', '特别', '坚持', '发布', '著名', '更加', '经验', '最近', '各型', '不断', '生活', '景点', '景区', '对手', '回家', '人才', '蓝军', '上午', '消息', '指出', '领域', '连续', '免息', '感觉', '不少', '职业', '业务', '一起', '理解', '大量', '其实', '休闲', '发生', '三个', '媒体', '参与', '增加', '一样', '公布', '补充', '今天', '之间', '能够', '创造', '开通', '消费', '标志', '赔偿', '之前', '伯德', '研究', '分公司', '面试', '过年', '关国光', '明显', '制药', '疼痛', '最佳', '振保', '一位', '这次', '起来', '晋升', '社会', '支持', '容易', '资源', '环境', '同事', '真正', '翻译', '每天', '找到', '关键', '当时', '元老', '昨天', '之一', '代表', '第一次', '产生', '电视', '意味着', '关系', '价值', '购买', '攻击', '下载', '条件', '欧洲', '女士', '本报', '电子', '口技', '结束', '发出', '单位', '总部', '网站', '战斗', '标题', '功能', '官兵', '教材', '本科', '密码', '批次', '酒家', '主动', '先后', '投入', '稳定', '提升', '变得', '安排', '规则', '采取', '方法', '过程', '加强', '很大', '效果', '不要', '集团', '亿元', '每股', '价格', '首次', '协会', '举行', '建立', '有效', '数量', '胜利', '一场', '泰国', '十分', '预计', '广播', '合作', '展示', '骗局', '很快', '力量', '同学', '关键字', '美国在线', '东部', '内容摘要', '工程', '联想', '优秀', '邮票', '第三方', '方向', '市民', 'gt', '补报', '听课', '机构', '提出', '一页', '过去', '第二', '三分', '经理', '有点', '失去', '取得', '只能', '综合', '练习', '平时', '核心', '突破', '范文', '考场', '韩国', '东南亚', '围棋', '广告', '刚刚', '带来', '进一步', '透露', '报道', '大师', '迅速', '图库', '负责', '巨大', '几年', '万人', '开展', '米勒', '罚球', '预测', '不再', '跨国公司', '提醒', '培训', '广州', '搜索', '保障', '红军', '培养', '医药', '海上', '埃弗顿', '办法', '口语', '牙膏', '场位', '本书', '商业银行', '传统', '网上支付', '吸烟', '戒烟', '国防', '战争', '初盘', '销售额', '收益', '可选报', '阿片类', '敏华', '南京', '至少', '真实', '变成', '竞争', '空间', '留下', '往往', '下来', '商机', '积极', '熟悉', '增强', '安妮', '呼叫', '改革', '经常', '汪力', '行动', '运用', '集中', '阶段', '考前', '精读', '水平', '必要', '成绩', '题目', '参看', '发挥', '日电', '出境', '签订', '变化', '人士', '具有', '沈阳', '即将', '时代', '经典', '挑战', '战略', '两年', '近年来', '短程', '战术导弹', '点穴', '旅游者', '月份', '年前', '一半', '人口', '负责人', '报告', '共同', '女兵', '打击', '工具', '招聘', '半导体', '上网', '装甲团', '机票', '应用', '压力', '高清晰', '调查', '展开', '听力', '降价', '多年', '增幅', '动力', '安全性', '模拟', '连队', '辅导', '兵器', '家教', '学生', '泰华', '红玫瑰', '白玫瑰', '新加坡', '一天', '现实', '回到', '重新', '诊断', '结合', '业绩', '意见', '实力', '轻松', '避免', '分为', '考题', '记忆', '单词', '查询', '最好', '为主', '一般', '比例', '汉语', '结构', '技巧', '做到', '固定', '尤其', '仍然', '保证', '思路', '继续', '公民', '双方', '主席', '陈祖德', '关注', '更是', '依然', '用于', '程度', '工资', '公斤', '军方', '正式', '基地', '评估', '年代', '属于', '采用', '垃圾', '出版', '困难', '专门', '几天', '来到', '经营', '商店', '举办', '进攻', '显然', '满足', '制定', '晚上', '鼓励', '命令', 'www', '兄弟', 'of', '英文', '故障', '下降', '诺基亚', '需求', '费用', '华纳', 'BBC', '免费', '安契塔', '商业', '贯彻', '账户', '生产', '相互', '利润', '因素', '国际', '相当', '独立', '觉得', '标准', '有望', '主队', '原则', '心理', 'com', '干部', '季泽', '制剂', '家长', '调剂', '二外', '招生', '生物', '市营率', '非甾体', '参考书', '大多数', '股骨头', '雅思', '出品', '导演', '指导', '语言', '形象', '一番', '好好', '看看', '离开', '上司', '印象', '第三', '表明', '总监', '愿意', '有所']

可以看到，我们已经滤除了那些没有用的词组，这个feature_words就是我们最终选出的用于新闻分类的特征。随后，我们就可以根据feature_words，将文本向量化，然后用于训练朴素贝叶斯分类器。这个向量化的思想和上面的思想一致，因此不再累述。

代码如下：

"""
函数说明:根据feature_words将文本向量化
 
Parameters:
    train_data_list - 训练集
    test_data_list - 测试集
    feature_words - 特征集
Returns:
    train_feature_list - 训练集向量化列表
    test_feature_list - 测试集向量化列表

"""
def TextFeatures(train_data_list, test_data_list, feature_words):
    def text_features(text, feature_words): #出现在特征集中，则置1                                               
        text_words = set(text)
        features = [1 if word in text_words else 0 for word in feature_words]
        return features
    train_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   #返回结果

3、使用Sklearn构建朴素贝叶斯分类器

数据已经处理好了，接下来就可以使用sklearn构建朴素贝叶斯分类器了。

官方英文文档地址：文档地址
朴素贝叶斯是一类比较简单的算法，scikit-learn中朴素贝叶斯类库的使用也比较简单。相对于决策树，KNN之类的算法，朴素贝叶斯需要关注的参数是比较少的，这样也比较容易掌握。

在scikit-learn中，一共有3个朴素贝叶斯的分类算法类。分别是GaussianNB，MultinomialNB和BernoulliNB。其中GaussianNB就是先验为高斯分布的朴素贝叶斯，MultinomialNB就是先验为多项式分布的朴素贝叶斯，而BernoulliNB就是先验为伯努利分布的朴素贝叶斯。上面讲解的先验概率模型就是先验概率为多项式分布的朴素贝叶斯。

对于新闻分类，属于多分类问题。我们可以使用MultinamialNB()完成我们的新闻分类问题。MultinomialNB假设特征的先验概率为多项式分布，即如下式：
$$P(X_j=x_{jl}|Y=C_k)=\frac{X_{jl}+\lambda }{m_k+n\lambda }$$

其中，$P(X_j=x_{jl}|Y=C_k)$是第$k$个类别的第j维特征的第$l$个取值条件概率。$m_k$是训练集中输出为第k类的样本个数。λ为一个大于0的常数，常常取值为1，即拉普拉斯平滑，也可以取其他值。

接下来，我们看下MultinamialNB这个函数，只有3个参数：

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。

除此之外，MultinamialNB也有一些方法供我们使用：

MultinomialNB一个重要的功能是有partial_fit方法，这个方法一般用在训练集数据量非常大，一次不能全部载入内存的时候。这时我们可以把训练集分成若干等分，重复调用partial_fit来一步步的学习训练集，非常方便。GaussianNB和BernoulliNB也有类似的功能。

在使用MultinomialNB的fit方法或者partial_fit方法拟合数据后，我们可以进行预测。

此时预测有三种方法，包括predict，predict_log_proba和predict_proba。predict方法就是我们最常用的预测方法，直接给出测试集的预测类别输出。predict_proba则不同，它会给出测试集样本在各个类别上预测的概率。predict_proba预测出的各个类别概率里的最大值对应的类别，也就是predict方法得到的类别。
predict_log_proba和predict_proba类似，它会给出测试集样本在各个类别上预测的概率的一个对数转化。转化后predict_log_proba预测出的各个类别对数概率里的最大值对应的类别，也就是predict方法得到类别。

了解了这些，我们就可以编写代码，通过观察取不同的去掉前deleteN个高频词的个数与最终检测准确率的关系，确定deleteN的取值：

from sklearn.naive_bayes import MultinomialNB
import matplotlib.pyplot as plt
import os
import random
import jieba

 
"""
函数说明:新闻分类器
 
Parameters:
    train_feature_list - 训练集向量化的特征文本
    test_feature_list - 测试集向量化的特征文本
    train_class_list - 训练集分类标签
    test_class_list - 测试集分类标签
"""
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_accuracy

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_set
    stopwords_file = './stopwords_cn.txt'
    stopwords_set = MakeWordsSet(stopwords_file)
 
 
    test_accuracy_list = []
    deleteNs = range(0, 1000, 20)  #0 20 40 60 ... 980
    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()

执行结果如下，

我们绘制出了deleteNs和test_accuracy的关系，这样我们就可以大致确定去掉前多少的高频词汇了。每次运行程序，绘制的图形可能不尽相同，我们可以通过多次测试，来决定这个deleteN的取值，然后确定这个参数，这样就可以顺利构建出用于新闻分类的朴素贝叶斯分类器了。我测试感觉400还不错，最差的分类准确率也可以达到百分之50以上。将if __name__ == '__main__'下的代码修改如下：

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_set
    stopwords_file = './stopwords_cn.txt'
    stopwords_set = MakeWordsSet(stopwords_file)
 
    test_accuracy_list = []
    feature_words = words_dict(all_words_list, 400, 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)
 
    print(ave(test_accuracy_list))

运行结果：

四、总结

朴素贝叶斯推断的一些优点：

生成式模型，通过计算概率来进行分类，可以用来处理多分类问题。
对小规模的数据表现很好，适合多分类任务，适合增量式训练，算法也比较简单。

朴素贝叶斯推断的一些缺点：

对输入数据的表达形式很敏感。
由于朴素贝叶斯的“朴素”特点，所以会带来一些准确率上的损失。
需要计算先验概率，分类决策存在错误率。

注意：

在训练朴素贝叶斯分类器之前，要处理好训练集，文本的清洗还是有很多需要学习的东西。
根据提取的分类特征将文本向量化，然后训练朴素贝叶斯分类器。
去高频词汇数量的不同，对结果也是有影响的的。
拉普拉斯平滑对于改善朴素贝叶斯分类器的分类效果有着积极的作用。

参考文章：

• 机器学习实战教程（四）：朴素贝叶斯基础篇之言论过滤器 | Jack Cui
• ApacheCN 第4章 基于概率论的分类方法: 朴素贝叶斯
• 《机器学习实战》

本文出现的所有代码，来自github参考代码。