大暑这天开通了博客

bayes_word

实验介绍

1.实验内容

本实验介绍朴素贝叶斯算法原理，并通过一个小例子演示如何使用该算法。

2.实验目标

通过本实验掌握朴素贝叶斯算法原理，了解朴素贝叶斯算法如何应用。

3. 实验知识点

朴素贝叶斯算法

4. 实验环境

python 3.6.5

5.预备知识

概率论与数理统计
Linux命令基本操作
Python编程基础

实验-言论过滤器

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

词条切分和词性标注

我们把文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现所有文档中的单词，再决定将哪些单词纳入词汇表或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。简单起见，我们先假设已经将本文切分完毕，存放到列表中，并对词汇向量进行分类标注。编写代码如下：

# -*- coding: UTF-8 -*-
"""
函数说明:创建实验样本
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)

['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']
[0, 1, 0, 1, 0, 1]

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

生成词条向量

继续编写代码，前面我们已经说过我们要先创建一个词汇表，并将切分好的词条转换为词条向量。

# -*- coding: UTF-8 -*-
"""
函数说明:根据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 #返回文档向量
"""
函数说明:将切分的实验样本词条整理成不重复的词条列表，也就是词汇表

Parameters:
    dataSet - 整理的样本数据集
Returns:
    vocabSet - 返回不重复的词条列表，也就是词汇表
"""
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:
 [['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:
 ['worthless', 'flea', 'maybe', 'mr', 'take', 'is', 'steak', 'my', 'has', 'quit', 'please', 'licks', 'buying', 'so', 'I', 'love', 'park', 'dog', 'ate', 'how', 'cute', 'to', 'food', 'dalmation', 'stop', 'help', 'stupid', 'not', 'him', 'problems', 'posting', 'garbage']
trainMat:
 [[0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0]]

从运行结果可以看出，postingList是原始的词条列表，myVocabList是词汇表。myVocabList是所有单词出现的集合，没有重复的元素。词汇表是用来干什么的？没错，它是用来将词条向量化的，一个单词在词汇表中出现过一次，那么就在相应位置记作1，如果没有出现就在相应位置记作0。trainMat是所有的词条向量组成的列表。它里面存放的是根据myVocabList向量化的词条向量。

【练习】训练朴素贝叶斯分类器

我们已经得到了词条向量。接下来，我们就可以通过词条向量训练朴素贝叶斯分类器。

import numpy as np

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

def setOfWords2Vec(vocabList, inputSet):
    """
    根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
    :param vocabList:
    :param inputSet:
    :return:
    """
    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


def createVocabList(dataSet):
    vocabSet = set([])
    for document in dataSet:
        vocabSet = vocabSet | set(document)
    return list(vocabSet)

def trainNB0(trainMaxtrix, trainCategory):
    """
    朴素贝叶斯训练函数
    :param trainMaxtrix: 训练文档矩阵
    :param trainCategory: 训练类别标签向量
    :return:
    """
    numTrainDocs = len(trainMaxtrix)   #计算训练文档的数目
    numWords = len(trainMaxtrix[0])    #计算每一篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    p0Num = np.zeros(numWords)   #分子
    p1Num = np.zeros(numWords)  #分子
    p0Denom = 0.0   #分母
    p1Denom = 0.0
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:   #统计属于侮辱类的条件概率所需的数据
            p1Num += trainMaxtrix[i]
            p1Denom += sum(trainMaxtrix[i])
        else:  #统计属于非侮辱类条件概率所需的数据
            p0Num += trainMaxtrix[i]
            p0Denom += sum(trainMaxtrix[i])
    p1Vect = p1Num/p1Denom
    p0Vec = p0Num/p0Denom
    return p0Vec,p1Vect, pAbusive  #返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率



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))
    p0V, p1V, pAb = trainNB0(trainMat, classVec)
    print('p0V:\n', p0V)
    print('p1V:\n', p1V)
    print('classVec:\n', classVec)
    print('pAb:\n', pAb)

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:
 ['has', 'mr', 'so', 'not', 'dalmation', 'problems', 'steak', 'licks', 'I', 'help', 'take', 'my', 'dog', 'flea', 'love', 'posting', 'cute', 'food', 'him', 'garbage', 'buying', 'is', 'please', 'stop', 'how', 'ate', 'maybe', 'park', 'worthless', 'to', 'stupid', 'quit']
p0V:
 [0.04166667 0.04166667 0.04166667 0.         0.04166667 0.04166667
 0.04166667 0.04166667 0.04166667 0.04166667 0.         0.125
 0.04166667 0.04166667 0.04166667 0.         0.04166667 0.
 0.08333333 0.         0.         0.04166667 0.04166667 0.04166667
 0.04166667 0.04166667 0.         0.         0.         0.04166667
 0.         0.        ]
p1V:
 [0.         0.         0.         0.05263158 0.         0.
 0.         0.         0.         0.         0.05263158 0.
 0.10526316 0.         0.         0.05263158 0.         0.05263158
 0.05263158 0.05263158 0.05263158 0.         0.         0.05263158
 0.         0.         0.05263158 0.05263158 0.10526316 0.05263158
 0.15789474 0.05263158]
classVec:
 [0, 1, 0, 1, 0, 1]
pAb:
 0.5

运行结果如上所示，p0V存放的是每个单词属于类别0，也就是非侮辱类词汇的概率。比如p0V的倒数第2个概率，就是stupid这个单词属于非侮辱类的概率为0。同理，p1V的倒数第2个概率，就是stupid这个单词属于侮辱类的概率为0.15789474，也就是约等于15.79%的概率。我们知道stupid的中文意思是蠢货，显而易见，这个单词属于侮辱类。pAb是所有侮辱类的样本占所有样本的概率，从classVec中可以看出，一用有3个侮辱类，3个非侮辱类。所以侮辱类的概率是0.5。因此p0V存放的就是P(him|非侮辱类) = 0.0833、P(is|非侮辱类) = 0.0417，一直到P(dog|非侮辱类) = 0.0417，这些单词的条件概率。同理，p1V存放的就是各个单词属于侮辱类的条件概率。pAb就是先验概率。

使用分类器进行分类

上个步骤已经训练好分类器，接下来，使用分类器进行分类。

"""
函数说明:朴素贝叶斯分类器分类函数

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

"""
函数说明:测试朴素贝叶斯分类器

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()

p0: 0.0
p1: 0.0
['love', 'my', 'dalmation'] 属于非侮辱类
p0: 0.0
p1: 0.0
['stupid', 'garbage'] 属于非侮辱类

我们测试了两个词条，在使用分类器前，也需要对词条向量化，然后使用classifyNB()函数，用朴素贝叶斯公式，计算词条向量属于侮辱类和非侮辱类的概率。你会发现，这样写的算法无法进行分类，p0和p1的计算结果都是0，这里显然存在问题。这是为什么呢？下个实验步骤我们继续解决这个问题。

算法改进

利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算p(w0|1)p(w1|1)p(w2|1)。如果其中有一个概率值为0，那么最后的成绩也为0。我们拿出上一个步骤中的截图。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FJkS0ysk-1672218805756)(27_bayes_word.png)]
从上图可以看出，在计算的时候已经出现了概率为0的情况。如果新实例文本，包含这种概率为0的分词，那么最终的文本属于某个类别的概率也就是0了。显然，这样是不合理的，为了降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。这种做法就叫做拉普拉斯平滑(Laplace Smoothing)又被称为加1平滑，是比较常用的平滑方法，它就是为了解决0概率问题。
除此之外，另外一个遇到的问题就是下溢出，这是由于太多很小的数相乘造成的。我们知道，两个小数相乘，越乘越小，这样就造成了下溢出。在程序中，在相应小数位置进行四舍五入，计算结果可能就变成0了。为了解决这个问题，对乘积结果取自然对数。通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。下图给出函数f(x)和ln(f(x))的曲线。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-72YjXAgl-1672218805757)(28_bayes_word.jpg)]
检查这两条曲线，就会发现它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。因此我们可以对trainNB0(trainMatrix, trainCategory)函数进行更改，修改如下：

import numpy as np
from functools import reduce

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

def setOfWords2Vec(vocabList, inputSet):
    """
    根据vocabList词汇表，将inputSet向量化，向量的每个元素为1或0
    :param vocabList:
    :param inputSet:
    :return:
    """
    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


def createVocabList(dataSet):
    vocabSet = set([])
    for document in dataSet:
        vocabSet = vocabSet | set(document)
    return list(vocabSet)

def trainNB0(trainMaxtrix, trainCategory):
    """
    朴素贝叶斯训练函数
    :param trainMaxtrix: 训练文档矩阵
    :param trainCategory: 训练类别标签向量
    :return:
    """
    numTrainDocs = len(trainMaxtrix)   #计算训练文档的数目
    numWords = len(trainMaxtrix[0])    #计算每一篇文档的词条数
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    p0Num = np.zeros(numWords)   #分子
    p1Num = np.zeros(numWords)  #分子
    p0Denom = 0.0   #分母
    p1Denom = 0.0
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:   #统计属于侮辱类的条件概率所需的数据
            p1Num += trainMaxtrix[i]
            p1Denom += sum(trainMaxtrix[i])
        else:  #统计属于非侮辱类条件概率所需的数据
            p0Num += trainMaxtrix[i]
            p0Denom += sum(trainMaxtrix[i])
    p1Vect = p1Num/p1Denom
    p0Vec = p0Num/p0Denom
    return p0Vec,p1Vect, pAbusive  #返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    """
    分类器函数
    :param vec2Classify:待分类的词条数组
    :param p0Vec:侮辱类的条件概率数组
    :param p1Vec:非侮辱类条件概率数组
    :param pClass1:文档属于侮辱类的概率
    :return:
    """
    p1 = reduce(lambda x,y:x*y, vec2Classify*p1Vec)*pClass1  #积累相加
    p0 = reduce(lambda x,y:x*y, vec2Classify*p0Vec)*(1-pClass1)
    print('p0:',p0)
    print('p1:',p1)
    if p1>p0:
        return 1
    else:
        return 0


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()

p0: 0.0
p1: 0.0
['love', 'my', 'dalmation'] 属于非侮辱类
p0: 0.0
p1: 0.0
['stupid', 'garbage'] 属于非侮辱类

这样得到的结果就没有问题了，不存在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)    
    if p1 > p0:        
        return 1
    else:        
        return 0

if __name__ == '__main__':
	testingNB()

['love', 'my', 'dalmation'] 属于非侮辱类
['stupid', 'garbage'] 属于侮辱类

这样修改的原因是由于取自然对数，所以需要将惩罚换成加法，原理是log(ab) = loga + logb。至此，我们的朴素贝叶斯分类器就改进完毕了。

实验总结

通过本实验，您应该能达到以下两个目标：

1. 掌握朴素贝叶斯算法原理。
1. 熟悉朴素贝叶斯算法的初步应用。

参考文献及延伸阅读

参考资料：

1.哈林顿，李锐. 机器学习实战 : Machine learning in action[M]. 人民邮电出版社, 2013.
2.周志华. 机器学习:Machine learning[M]. 清华大学出版社, 2016.