文章原创,最近更新：2018-08-21
前言:
本文介绍机器学习分类算法中的朴素贝叶斯分类算法并给出伪代码，Python代码实现。
学习参考链接:
1.第4章 基于概率论的分类方法：朴素贝叶斯
2.第五篇：朴素贝叶斯分类算法原理分析与代码实现
本章节的主要内容是:
重点介绍项目案例1:屏蔽社区留言板的侮辱性言论项目汇总代码。
1.朴素贝叶斯项目案例介绍:
项目案例1:
屏蔽社区留言板的侮辱性言论
项目概述:
构建一个快速过滤器来屏蔽在线社区留言板上的侮辱性言论。如果某条留言使用了负面或者侮辱性的语言，那么就将该留言标识为内容不当。对此问题建立两个类别: 侮辱类和非侮辱类，使用 1 和 0 分别表示。
朴素贝叶斯 工作原理:
提取所有文档中的词条并进行去重
获取文档的所有类别
计算每个类别中的文档数目
对每篇训练文档:
对每个类别:
如果词条出现在文档中-->增加该词条的计数值（for循环或者矩阵相加）
增加所有词条的计数值（此类别下词条总数）
对每个类别:
对每个词条:
将该词条的数目除以总词条数目得到的条件概率（P(词条|类别)）
返回该文档属于每个类别的条件概率（P(类别|文档的所有词条)）
开发流程：
- 收集数据: 可以使用任何方法
- 准备数据: 从文本中构建词向量
- 分析数据: 检查词条确保解析的正确性
- 训练算法: 从词向量计算概率
- 测试算法: 根据现实情况修改分类器
- 使用算法: 对社区留言板言论进行分类
数据集介绍
这个数据集是我们自己构造的词表.
2.词向量的介绍
朴素贝叶斯分类算法常常用于 文档的分类，而且实践证明效果挺不错的。
在说明原理之前，先介绍一个叫词向量的概念。 --- 它一般是一个布尔类型的集合，该集合中每个元素都表示其对应的单词是否在文档中出现。
比如说，词汇表只有三个单词：'apple', 'orange', 'melo'，某文档中，apple和melo出现过，那么其对应的词向量就是 {1, 0, 1}。
这种模型通常称为词集模型，如果词向量元素是整数类型，每个元素表示相应单词在文档中出现的次数(0表示不出现)，那这种模型就叫做词袋模型。
部分代码可用于由文档构建词向量以及测试结果,具体可参见第3部分的内容.
3.相关代码
3.1收集数据: 可以使用任何方法
打开文本编辑器，创建一个叫 bayes.py的新文件,然后将下面的代码添加到文件中。
具体知识点可参考如下链接:4-1节 朴素贝叶斯|准备数据：从文本中构建词向量|机器学习实战-学习笔记
import numpy as np
#用自定义函数loadDataSet创建实验文档样本
def loadDataSet():
"""
创建数据集
:return: 文档包含单词的列表postingList, 分类标签列表classVec
"""
#用列表postingList创建文档列表
postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'], #[0,0,1,1,1......]
['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创建标签，1代表侮辱性文字，0代表正常言论
classVec = [0, 1, 0, 1, 0, 1]
# 返回文档列表postingList及标签classVec
return postingList, classVec
测试代码及其结果如下:
listOPosts,listClasses =loadDataSet()
listOPosts
Out[73]:
[['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']]
3.2准备数据: 从文本中构建词向量
打开文本编辑器，然后将下面的代码添加到文件bayes.py。
具体知识点可参考如下链接:4-1节 朴素贝叶斯|准备数据：从文本中构建词向量|机器学习实战-学习笔记
def createVocabList(dataSet):
"""
获取所有单词的集合
:param dataSet: 数据集
:return: 所有单词的集合(即不含重复元素的单词列表)
"""
vocabSet = set()
for document in dataSet:
# 操作符 | 用于求两个集合的并集
vocabSet=set(document)|vocabSet
return list(vocabSet)
def setOfWords2Vec(vocabList, inputSet):
"""
遍历查看该单词是否出现，出现该单词则将该单词置1,否则该单词置0
:param vocabList: 所有单词集合列表
:param inputSet: 输入数据集
:return: 匹配列表[0,1,0,1...]，其中 1与0 表示词汇表中的单词是否出现在输入的数据集中
"""
# 创建一个和词汇表vocabList等长的向量returnVec,向量中每一元素都为0
returnVec = [0]*len(vocabList)# [0,0......]
#用变量word遍历输入文档inputSet中的所有单词
for word in inputSet:
# 如果单词在词汇表vocabList中
if word in vocabList:
# 则将输出文档向量中的值设为1
returnVec[vocabList.index(word)]=1
else:
# 否则输出“单词不在词汇表中”,%用作格式化字符串
print("the word:%s is not in my Vocabulary!"% word)
# 返回文档向量returnVec
return returnVec
测试代码及其结果如下:
listOPosts,listClasses =loadDataSet()
myVocabList = createVocabList(listOPosts)
myVocabList
Out[75]:
['is', 'licks', 'how', 'dalmation', 'my', 'cute', 'worthless', 'maybe', 'mr', 'stupid', 'help', 'problems', 'ate', 'quit', 'garbage', 'buying', 'steak', 'him', 'I', 'take', 'dog', 'flea', 'to', 'stop', 'please', 'food', 'park', 'has', 'not', 'posting', 'so', 'love']
setOfWords2Vec(myVocabList, listOPosts[0])
Out[76]:
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
3.3训练算法: 从词向量计算概率
由贝叶斯准则可知，某词向量X为分类 Ci 的概率可用如下公式来进行计算：
p(ci)表示该文档为分类ci的概率；p(w)为该文档对应词向量为w的概率；这两个量是很好求的，这里不多解释。关键要解决的是 p(w|ci)，也即在文档为分类 ci 的条件下，词向量为w的概率。
这里就要谈到为什么本文讲解的算法名为 "朴素" 贝叶斯。所谓朴素，就是整个形式化过程只做最原始假设。也就是说，假设不同的特征是相互独立的。但这和现实世界不一致，也导致了其他各种形形色色的贝叶斯算法。
在这样的假设前提下： p(w|ci) = p(w0|ci) * p(w1|ci) * p(w2|ci) * .... * p(wn|ci)。
而前面提到了w是指词向量，这里wn的含义就是词向量中的某个单词。
具体知识点可参考如下链接:4-2节 朴素贝叶斯|训练算法：从词向量计算概率|机器学习实战-学习笔记
可使用如下伪代码计算条件概率 p(wn|ci):
对每篇训练文档:
对每个类别：
增加该单词计数值
增加所有单词计数值
对每个类别:
对每个单词:
将该单词的数目除以单词总数得到条件概率
返回所有单词在各个类别下的条件概率
打开文本编辑器，然后将下面的代码添加到文件bayes.py。
def trainNB0(trainMatrix, trainCategory):
"""
训练数据原版
:param trainMatrix: 文件单词矩阵 [[1,0,1,1,1....],[],[]...]
:param trainCategory: 文件对应的标签类别[0,1,1,0....]，列表长度等于单词矩阵数，其中的1代表对应的文件是侮辱性文件，0代表不是侮辱性矩阵
:return:
p0Vect: 各单词在分类0的条件下出现的概率
p1Vect: 各单词在分类1的条件下出现的概率
pAbusive: 文档属于分类1的概率
"""
# 文件数
numTrainDocs = len(trainMatrix)
# 单词数
numWords = len(trainMatrix[0])
# 侮辱性文件的出现概率,即trainCategory中所有的1的个数
# 代表的就是多少个侮辱性文件,与文件的总数相除就得到了侮辱性文件的出现概率
pAbusive = sum(trainCategory) / float(numTrainDocs)
p0Num = np.zeros(numWords); p1Num =np.zeros(numWords)
p1Num = np.zeros(numWords); p1Num =np.zeros(numWords)
#整个数据集单词出现总数
p0Denom = 0.0
p1Denom = 0.0
for i in range(numTrainDocs):
if trainCategory[i]==1:
p1Num += trainMatrix[i] #[0,1,1,....] + [0,1,1,....]->[0,2,2,...]
# 对向量中的所有元素进行求和，也就是计算所有侮辱性文件中出现的单词总数
p1Denom += sum(trainMatrix[i])
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
# 类别1，即侮辱性文档的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表
# 即 在1类别下，每个单词出现的概率
p1Vect = p1Num / p1Denom# [1,2,3,5]/90->[1/90,...]
# 类别0，即正常文档的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表
# 即 在0类别下，每个单词出现的概率
p0Vect = p0Num / p0Denom
return p0Vect, p1Vect, pAbusive
测试代码及其结果如下:
import bayes
listOPosts,listClasses =loadDataSet()
myVocabList = createVocabList(listOPosts)
trainMat =[]
for postinDoc in listOPosts:
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V,P1V,PAb=bayes.trainNB0(trainMat, listClasses)
p0V
Out[93]:
array([ 0.04166667, 0.04166667, 0.04166667, 0.04166667, 0.125 ,
0.04166667, 0. , 0. , 0.04166667, 0. ,
0.04166667, 0.04166667, 0.04166667, 0. , 0. ,
0. , 0.04166667, 0.08333333, 0.04166667, 0. ,
0.04166667, 0.04166667, 0.04166667, 0.04166667, 0.04166667,
0. , 0. , 0.04166667, 0. , 0. ,
0.04166667, 0.04166667])
P1V
Out[94]:
array([ 0. , 0. , 0. , 0. , 0. ,
0. , 0.10526316, 0.05263158, 0. , 0.15789474,
0. , 0. , 0. , 0.05263158, 0.05263158,
0.05263158, 0. , 0.05263158, 0. , 0.05263158,
0.10526316, 0. , 0.05263158, 0.05263158, 0. ,
0.05263158, 0.05263158, 0. , 0.05263158, 0.05263158,
0. , 0. ])
PAb
Out[95]: 0.5
3.4测试算法: 根据现实情况修改分类器
对此公式:
上一步做的工作仅仅是将各个分量求出来了(p(w)为1)，而没有进行p(w0|ci) * p(w1|ci) * p(w2|ci) * .... * p(wn|ci)的累乘，也没有进行概率大小的比较。
剩下的工作看似简单但在具体实现上也涉及到两个问题。
问题一：p(wn|ci) 中有一个为0，导致整个累乘结果也为0。这是错误的结论。
解决方法：将所有词的出现次数初始化为1，并将分母初始化为2。问题二：即使 p(wn|ci) 不为0了，可是它的值也许会很小，这样会导致浮点数值类型的下溢出等精度问题错误。
解决方法：用 p(wn|ci) 的对数进行计算。
具体实现请参考下面代码。针对这两个问题，它对上一步的函数做了一点修改：
特别说明：在下面的代码实现中，w只包含在待分类文档中出现了的单词的特征位。
具体知识点可参考如下链接:4-2节 朴素贝叶斯|训练算法：从词向量计算概率|机器学习实战-学习笔记
打开文本编辑器，然后将下面的代码添加到文件bayes.py。
def trainNB0(trainMatrix, trainCategory):
"""
训练数据原版
:param trainMatrix: 文件单词矩阵 [[1,0,1,1,1....],[],[]...]
:param trainCategory: 文件对应的标签类别[0,1,1,0....]，列表长度等于单词矩阵数，其中的1代表对应的文件是侮辱性文件，0代表不是侮辱性矩阵
:return:
p0Vect: 各单词在分类0的条件下出现的概率
p1Vect: 各单词在分类1的条件下出现的概率
pAbusive: 文档属于分类1的概率
"""
# 总文件数
numTrainDocs = len(trainMatrix)
# 每个文件中的单词数
numWords = len(trainMatrix[0])
# 侮辱性文件的出现概率,即trainCategory中所有的1的个数
# 代表的就是多少个侮辱性文件,与文件的总数相除就得到了侮辱性文件的出现概率
pAbusive = sum(trainCategory) / float(numTrainDocs)
# p0Num 正常的统计,p1Num 侮辱的统计
p0Num = np.ones(numWords); p1Num =np.ones(numWords)
# 整个数据集单词出现总数，2.0根据样本/实际调查结果调整分母的值（2主要是避免分母为0，当然值可以调整）
# p0Num 正常的统计
# p1Num 侮辱的统计
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])
# 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
# log下什么都不写默认是自然对数
p1Vect = np.log(p1Num/p1Denom)
# 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
p0Vect = np.log(p0Num/p0Denom)
return p0Vect, p1Vect, pAbusive
测试代码及其结果如下:
import bayes
listOPosts,listClasses =loadDataSet()
myVocabList = createVocabList(listOPosts)
trainMat =[]
for postinDoc in listOPosts:
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V,P1V,PAb=bayes.trainNB0(trainMat, listClasses)
p0V
Out[173]:
array([-2.56494936, -2.56494936, -2.56494936, -2.56494936, -1.87180218,
-2.56494936, -3.25809654, -3.25809654, -2.56494936, -3.25809654,
-2.56494936, -2.56494936, -2.56494936, -3.25809654, -3.25809654,
-3.25809654, -2.56494936, -2.15948425, -2.56494936, -3.25809654,
-2.56494936, -2.56494936, -2.56494936, -2.56494936, -2.56494936,
-3.25809654, -3.25809654, -2.56494936, -3.25809654, -3.25809654,
-2.56494936, -2.56494936])
P1V
Out[174]:
array([-3.04452244, -3.04452244, -3.04452244, -3.04452244, -3.04452244,
-3.04452244, -1.94591015, -2.35137526, -3.04452244, -1.65822808,
-3.04452244, -3.04452244, -3.04452244, -2.35137526, -2.35137526,
-2.35137526, -3.04452244, -2.35137526, -3.04452244, -2.35137526,
-1.94591015, -3.04452244, -2.35137526, -2.35137526, -3.04452244,
-2.35137526, -2.35137526, -3.04452244, -2.35137526, -2.35137526,
-3.04452244, -3.04452244])
PAb
Out[175]: 0.5
3.5使用算法: 对社区留言板言论进行分类
具体知识点可参考如下链接:4-3节 朴素贝叶斯|朴素贝叶斯分类函数|机器学习实战-学习笔记
打开文本编辑器，然后将下面的代码添加到文件bayes.py。
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
"""
使用算法：
# 将乘法转换为加法
乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
:param vec2Classify: 待测数据[0,1,1,1,1...]，即要分类的向量
:param p0Vec: 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
:param p1Vec: 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
:param pClass1: 类别1，侮辱性文件的出现概率
:return: 类别1 or 0
"""
# 计算公式 log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
# 大家可能会发现，上面的计算公式，没有除以贝叶斯准则的公式的分母，也就是 P(w) （P(w) 指的是此文档在所有的文档中出现的概率）就进行概率大小的比较了，
# 因为 P(w) 针对的是包含侮辱和非侮辱的全部文档，所以 P(w) 是相同的。
# 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。
# 我的理解是：这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
# P(w|c1) * P(c1) ，即贝叶斯准则的分子
p1=sum(vec2Classify*p1Vec)+np.log(pClass1)
# P(w|c0) * P(c0) ，即贝叶斯准则的分子·
p0=sum(vec2Classify*p0Vec)+np.log(1.0-pClass1)
if p1>p0:
return 1
else:
return 0
def testingNB():
"""
测试朴素贝叶斯算法
"""
listOPosts,listClasses = loadDataSet()
# 创建包含在所有文档中不出现重复词对列表，即创建特征
myVocabList = createVocabList(listOPosts)
# 获取文档向量，向量的每一个元素为1或者0，分别表示词表中的单词在输入文档中是否出现
trainMat=[]
for postinDoc in listOPosts:
# 训练贝叶斯分类器
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V,P1V,PAb =trainNB0(trainMat, listClasses)
# 测试一
#创建测试样本
testEntry = ['love', 'my', 'dalmation']
#获取测试样本特征向量
thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
#输出分类结果
print (testEntry,'分类结果: ',classifyNB(thisDoc,p0V,P1V,PAb))
# 测试二
#创建测试样本
testEntry = ['stupid', 'garbage']
#获取测试样本特征向量
thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
#输出分类结果
print (testEntry,'分类结果: ',classifyNB(thisDoc,p0V,P1V,PAb))
测试代码及其结果如下:
import bayes
bayes.testingNB()
['love', 'my', 'dalmation'] 分类结果: 0
['stupid', 'garbage'] 分类结果: 1
4.总结
为突出重点，本文示例仅采用两个分类做测试。更多分类是同理的。
程序设计中应尽量以矩阵或者向量为单位来处理数据。这样能简化代码，增加效率，也能提高程序可读性。
该分类算法的优点是对于数据集较少的情况也能适用，能处理多类别问题；然而不足之处在于对数据集的准备方式比较敏感。
