机器学习之朴素贝叶斯

不同与决策树和逻辑回归等以往学习的分类算法,贝叶斯方法是概率框架下实施决策的基本方法。对分类任务来说,在所有相关概率都已知的理想情况下,贝叶斯决策论考虑如何基于这些概率和误判损失来选择最优的类别标记。该算法的有点在于简单易懂、学习效率高,适用于可以求出概率的数据。

贝叶斯决策论

使用贝叶斯判定准则来最小化决策风险,首先要获得后验概率P(c|x)。然而,机器学习要实现的是基于优先的训练样本尽可能准确的估计出后验概率P(c|x),大体来说,著有有两种策略:给定x,可通过直接建模P(c|x)来预测c,这样得到的是”判别式模型”;也可以对联合概率分布P(x,c)建模,然后由此获得P(c|x),这样得到的是“生成式模型”。显然,决策树,支持向量机等课归入判别式模型的范畴,对生成式模型来说,要考虑条件概率分布。

首先看贝叶斯公式:

贝叶斯公式

其中,P(c)是类“先验概率”;要求的P(c|x)是类“后验概率”;P(x|c)是样本x相对与类标记c的类条件概率,或称为”似然”;P(x)是用于归一化的调整因子,与类标记无关。调整因子可根据如下公式(全概率公式)求出:

具体推导过程详见概率论书或这里

朴素贝叶斯分类器

由于类条件概率P(x|c)是所有属性上的联合概率,难以从有限的训练样本直接估计而得。为避开这个障碍,朴素贝叶斯分类器采用了”属性条件独立性假设”:对已知类别,假设所有属性相互独立。换言之,假设每个属性独立地对分类器结果发生影响。

通常,我们所做的就是比较各种情况下的类后验概率来判断属于哪一类,由于对所有类别来说P(x)相同,因此根据贝叶斯判定准则有

这就是朴素贝叶斯分类器的表达式。

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

基于《机器学习实战》一书,以在线社区的留言版为例 。为了不影响社区的发展,我们要屏蔽侮辱性的言论,所以要构建一个快速过滤器,将一条留言分类为侮辱类或非侮辱类,使用1和0表示。

准备数据

首先将文本信息转化为单词向量或词条向量,还要准备一个容纳所有词汇的词汇表,目的是将一篇文章转化为一条由01构成的向量,01代表侮辱类或非侮辱类词汇,编写代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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 createVocabList(dataSet):
vocabSet = set([])
for document in dataSet:
vocabSet = vocabSet | set(document) # 进行或操作,相当于删除重复词汇
return list(vocabSet)
# 定义包含整个词汇表的向量,判断切分的词条的向量的位置,即如果该单词在词汇表里就为1,不在就为0
# 输入参数:vocabList:词汇表,inputSet:整个文档
# 输出参数:文档向量
def setOfWords2Vec(vocabList, inputSet):
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 vocavulary!" % word)
return returnVec
if __name__ == '__main__':
postingList, classVec = loadDataSet() # 加载数据
myVocabList = createVocabList(postingList) # 去除掉list中的重复词汇
print('myVocabList:\n',myVocabList)
trainMat = []
for postinDoc in postingList:
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
print("trainMat\n", np.mat(trainMat))

运行代码后可以产生如下结果:

trainMat
[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 0 1 1 0 0 0 1]
[0 0 0 0 1 1 0 1 0 0 0 0 1 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0]
[1 1 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 1 0 0 1 0 0]
[0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 1 0 0 0]
[0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0]]

从结果可以看出,trainMat存放已经根据输入的语句进行比对,然后转化为0或1后的词条向量。

训练算法

接下来,我们根据朴素贝叶斯公式,对每个类计算后验概率,然后比较这两个概率值的大小。该函数的伪代码如下:

1
2
3
4
5
6
7
8
9
计算每个类别中的文档数目
对每篇训练文档:
对每个类别:
如果词条出现在文档中->增加该词条数的计数值
增加所有词条的计数值
对每个类别:
对每个词条:
将该词条的数目除以总词条数目得到条件概率
返回每个类别的条件概率

使用python代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
"""
朴素贝叶斯分类器训练函数
输入:文档矩阵trainMatrix,文档类别标签构成的向量trainCategory
改进:(1)拉普拉斯平滑:将词的出现数初始化为1,并将分母初始化为2
(2)对数似然:对乘积结果去自然对数
"""
def trainNB0(trainMatrix, trainCategory):
numTrainDocs = len(trainMatrix) # 计算训练的文档数量
numWords = len(trainMatrix[0]) # 计算每篇文档的单词数
pAbusive = sum(trainCategory)/float(numTrainDocs) # 文档属于侮辱性的概率
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])
p1Vect = np.log(p1Num/p1Denom)
p0Vect = np.log(p0Num/p0Denom)
return p0Vect,p1Vect,pAbusive
if __name__ == '__main__':
postingList, classVec = loadDataSet() # 加载数据
myVocabList = createVocabList(postingList) # 去除掉list中的重复词汇
print('myVocabList:\n',myVocabList)
trainMat = []
for postinDoc in postingList:
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
print("trainMat\n", np.mat(trainMat))
p0V, p1V, pAb = trainNB0(trainMat, classVec)
print('p0V:\n', p0V)
print('p1V:\n', p1V)
print('classVec:\n', classVec)
print('pAb:\n', pAb)

运行结果如下:

p0V:
[-3.25809654 -2.56494936 -2.56494936 -2.56494936 -3.25809654 -2.56494936
-3.25809654 -3.25809654 -1.87180218 -2.56494936 -2.56494936 -2.56494936
-3.25809654 -3.25809654 -2.56494936 -2.56494936 -2.56494936 -2.56494936
-2.56494936 -2.56494936 -3.25809654 -3.25809654 -2.56494936 -3.25809654
-2.56494936 -2.15948425 -2.56494936 -2.56494936 -3.25809654 -3.25809654
-2.56494936 -2.56494936]
p1V:
[-2.35137526 -3.04452244 -2.35137526 -3.04452244 -2.35137526 -3.04452244
-1.94591015 -2.35137526 -3.04452244 -3.04452244 -3.04452244 -3.04452244
-2.35137526 -2.35137526 -3.04452244 -3.04452244 -1.94591015 -3.04452244
-3.04452244 -3.04452244 -2.35137526 -2.35137526 -3.04452244 -1.65822808
-3.04452244 -2.35137526 -3.04452244 -2.35137526 -2.35137526 -2.35137526
-3.04452244 -3.04452244]
classVec:
[0, 1, 0, 1, 0, 1]
pAb:
0.5

p0v存放的是类别0的词汇也就是非侮辱性词汇,同理p1v存放的是侮辱性词汇,pAb表示侮辱类样本占所有样本的总数。可以看出,p0v和p1v存放的数据并不是标准的概率,因为如果用其中一个概率值为0,那么最后的乘积也同样为0,为了避免这种影响,需要采用”拉普拉斯平滑”的思想。具体来说,令N表示训练集D中可能的类别数,Ni表示第i个属性可能的取值数。

在本例中,就将所有词的出现数初始化为1,并将分母初始化为2。另外,当数据量比较庞大时,计算侮辱性或非侮辱性词汇占所有词汇的概率就会很小,这样当计算p(w1|c)p(w2|c)p(w3|c)……p(wn|c)时,由于大部分因子都比较小,所以程序会造成下溢出。这时有一种解决办法是对乘积取自然对数,在代数中有ln(a*b)=ln(a)+ln(b),这样就可以将乘法转化为加法,减少误差。

构建分类器

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
"""
说明:朴素贝叶斯分类器分类函数
Parameters:
vec2classify - 待分类的词条数组
p0vec - 侮辱类的条件概率数组
p1vec - 非侮辱类的条件概率数组
pClass1 - 文档属于侮辱类的概率
"""
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)
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
# 测试朴素贝叶斯分类器
def testingNB():
listOPosts, listClasses = loadDataSet() # 加载数据
myVocabList = createVocabList(listOPosts) # 创建词汇表
trainMat = []
for postinDoc in listOPosts:
trainMat.append(setOfWords2Vec(myVocabList, postinDoc)) # 将实验文档向量化存入trainMat
p0V, p1V, pAb = trainNB0(np.array(trainMat), np.array(listClasses)) # 训练朴素贝叶斯分类器
testEntry = ['love', 'my', 'dalmation']
thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry)) # 测试文档向量化
if classifyNB(thisDoc, p0V, p1V, pAb):
print(testEntry,'属于侮辱类')
else:
print(testEntry, '属于非侮辱类')
testEntry = ['stupid', 'garbage']
thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
if classifyNB(thisDoc, p0V, p1V, pAb):
print(testEntry,'属于侮辱类')
else:
print(testEntry, '属于非侮辱类')
if __name__ == '__main__':
testingNB()

运行结果如下:

p0: -7.69484807238
p1: -9.82671449373
[‘love’, ‘my’, ‘dalmation’] 属于非侮辱类
p0: -7.2093402566
p1: -4.70275051433
[‘stupid’, ‘garbage’] 属于侮辱类

可以看出,已经实现了将基本词条按词汇进行分类。

使用朴素贝叶斯过滤垃圾邮件

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

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

首先是收集数据,数据集可以在这里下载。下面放代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
import re
import random
import numpy as np
# 将大字符串解析为字符串列表
def textParse(bigString):
listOfTokens = re.split(r'\W*', bigString) # 提取非特殊字符的字符串
return [tok.lower() for tok in listOfTokens if len(tok) > 2] # 返回大于等于两个字符的字符串
# 将切分的实验样本词条整理成不重复都的词条列表,也就是词汇表
def createVocabList(dataSet):
vocabSet = set([])
for document in dataSet:
vocabSet = vocabSet | set(document) # 取并集
return list(vocabSet)
# 将词条向量化
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词汇表,构建词袋模型
def bagOfWord2VecMN(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList: # 如果词条存在于词汇表中,则计数加一
returnVec[vocabList.index(word)] += 1
return returnVec
"""
朴素贝叶斯分类器训练函数
输入:文档矩阵trainMatrix,文档类别标签构成的向量trainCategory
改进:(1)拉普拉斯平滑:将词的出现数初始化为1,并将分母初始化为2
(2)对数似然:对乘积结果去自然对数
"""
def trainNB0(trainMatrix, trainCategory):
numTrainDocs = len(trainMatrix) # 计算训练的文档数量
numWords = len(trainMatrix[0]) # 计算每篇文档的单词数
pAbusive = sum(trainCategory)/float(numTrainDocs) # 文档属于侮辱性的概率
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])
p1Vect = np.log(p1Num/p1Denom)
p0Vect = np.log(p0Num/p0Denom)
return p0Vect,p1Vect,pAbusive
"""
说明:朴素贝叶斯分类器分类函数
Parameters:
vec2classify - 待分类的词条数组
p0vec - 侮辱类的条件概率数组
p1vec - 非侮辱类的条件概率数组
pClass1 - 文档属于侮辱类的概率
"""
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)
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
# 测试朴素贝叶斯分类器
def spanTest():
docList = []; classList = []; fullText = []
for i in range(1,26):
wordList = textParse(open('email/spam/%d.txt' % i, 'r').read())
docList.append(wordList)
fullText.extend(wordList)
classList.append(1) # 标记垃圾邮件
wordList = textParse(open('email/ham/%d.txt' % i, 'r').read())
docList.append(wordList)
fullText.extend(wordList)
classList.append(0) # 标记非垃圾邮件
vocabList = createVocabList(docList) # 创建不重复的词汇表
trainingSet = list(range(50)); testSet = [] # 训练集和测试集的列表
for i in range(10): # 随机选择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
print("分类错误的测试集:",docList[docIndex])
print('错误率:%.2f%%' % (float(errorCount) / len(testSet) * 100))
if __name__ == '__main__':
spanTest()

代码注释中已有详细的说明,分类输出结果如下:

分类错误的测试集: [‘experience’, ‘with’, ‘biggerpenis’, ‘today’, ‘grow’, ‘inches’, ‘more’, ‘the’, ‘safest’, ‘most’, ‘effective’, ‘methods’, ‘of_penisen1argement’, ‘save’, ‘your’, ‘time’, ‘and’, ‘money’, ‘bettererections’, ‘with’, ‘effective’, ‘ma1eenhancement’, ‘products’, ‘ma1eenhancement’, ‘supplement’, ‘trusted’, ‘millions’, ‘buy’, ‘today’]
错误率:10.00%

由于每次会随机选择10封信进行分类,所以每次的运行结果都会有所出入。如果想要更好地估计错误率,那么就应该将上述过程重复多次,比如说10次,然后求平均值。相比之下,将垃圾邮件误判为正常邮件要比将正常邮件归为垃圾邮件好。为了避免错误,有多种方式可以用来修正分类器,这些内容会在后续文章中进行讨论。

Powered by Hexo and Hexo-theme-hiker

Copyright © 2016 - 2019 Dreaouth All Rights Reserved.

访客数 : | 访问量 :