机器学习之朴素贝叶斯（Naive bayes）学习笔记-Datawhale Task02

Author	Bryce230
e-mail	2540892461@qq.com
Software	win10，Pycharm2019.3.3，Python3.7.7

1 基本概念

朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。 我们称之为“朴素”，是因为整个形式化过程只做最原始、最简单的假设。朴素贝叶斯是贝叶斯决策理论的一部分，贝叶斯决策理论的核心思想是“高概率思想”：

优点	缺点
1）朴素贝叶斯模型有稳定的分类效率；2）对小规模的数据表现很好，能处理多分类任务，适合增量式训练，尤其是数据量超出内存时，可以一批批的去增量训练；3）对缺失数据不太敏感，算法也比较简单，常用于文本分类。	1）理论上，朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此，这是因为实际中属性之间相互独立往往不成立；2） 需要知道先验概率，且先验概率很多时候取决于假设，假设的模型可以有很多种，因此在某些时候会由于假设的先验模型的原因导致预测效果不佳；3）由于我们是通过先验和数据来决定后验的概率从而决定分类，所以分类决策存在一定的错误率；4）对输入数据的表达形式很敏感。

2 使用条件概率来分类

因此，我们需要求解的是类似于这样的等式：

可以将其看为：

这里就需要用到基本概念里提到的朴素贝叶斯假设：特征是相互独立的。在类别为y时，我们有：

由以上两式，我们可以得到：

因为分母P(X)是定值，所以在比较大小时，只要比较分子就可以了，这个在后面的程序里会体现。 进一步写为：

3 使用朴素贝叶斯进行文本分类

朴素贝叶斯是用于文档分类的常用算法，现在我们就基于Python用朴素贝叶斯算法来对文本进行分类。

3.1 从文本中构建词向量

首先我们需要把文本看成单词向量或者词条向量，也就是说将句子转换为向量。（该程序基于在线社区的斑点犬爱好者留言板，来自《机器学习实战》一书）
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

2）创建一个包含在所有文档中出现的不重复词的列表，所以需要用到set数据类型。操作符“|”表示并集（也是位或or操作符）。

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

3）该函数是为了检验每个输入的单词是否存在于词汇表中，存在取“1”，不存在取“0”，也即初始化一个全0的向量。

'''
Parameters:
    vocabList - createVocabList返回的列表
    inputSet - 切分的词条列表
Returns:
    returnVec - 文档向量,词集模型
'''
# 函数说明:根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
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

3.2 从词向量计算概率

这里我们需要明确两个问题：

3.2.1解决零概率问题

只需在初始化的时候，将分子初始化改为1，分母初始化为2。

3.2.2 解决下溢问题

数值下溢问题： 是指计算机浮点数计算的结果小于可以表示的最小数，因为计算机的能力有限，当数值小于一定数时，其无法精确保存，会造成数值的精度丢失，由上述公式可以看到，求概率时多个概率值相乘，得到的结果往往非常小。
其中比较常用的解决办法是取自然对数，将连乘转换为连加。

3.2.3 朴素贝叶斯分类器

实现上述条件概率的伪代码如下：

基于伪代码，我们可以写出具体的代码。

'''
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

此处用到了Numpy库函数，所以在程序开始处添加

import numpy as np

3.3 测试使用算法

我们上面说过，比较大小只要比较分子大小即可，因为分母一样。另外这里两个概率之间是加，因为已经取了对数。

#函数说明：朴素贝叶斯分类函数
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)  #只是分子部分
    p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
    if p1 > p0:
        return 1   #谁概率大取谁
    else:
        return 0

以上利用朴素贝叶斯来判断类型的各个函数已经完成，现只需要调用这些函数即可。

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)

    testEntry = ['stupid', 'my', 'garbage']
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))

我们在此测验的是“愚蠢，我的，垃圾”词汇，我们可以直接判断出其属于侮辱性词组，因此结果应该为1。最后输出结果为1，与我们预料的一致。

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

3.4 文档词袋模型

我们可以发现，上述算法，我们只是统计了词汇是否出现在词汇表中，而并没有统计出现的次数。前者我们称为词集模型，后者称为词袋模型。而改为词袋模型时，只要更改函数setOfWords2Vec()即可，更改后的如下：

def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0] * len(vocabList)                       #创建一个其中所含元素都为0的向量
    for word in inputSet:                                  #遍历每个词条
        if word in vocabList:                              #如果词条存在于词汇表中，则加1
            returnVec[vocabList.index(word)] += 1
    return returnVec 

4 参考文献

[1]《机器学习实战》[美] Peter
[2] Datawhale: Task2 bayes_plus.ipynb
[3] 朴素贝叶斯分类:原理
[4] 朴素贝叶斯-百度百科