进击数据挖掘十大算法(三):朴素贝叶斯

一、概述

贝叶斯分类算法是统计学的一种概率分类方法,朴素贝叶斯分类是贝叶斯分类中最简单的一种。其分类原理就是利用贝叶斯公式根据某特征的先验概率计算出其后验概率,然后选择具有最大后验概率的类作为该特征所属的类。之所以称之为 ”朴素” ,是因为贝叶斯分类只做最原始、最简单的假设:所有的特征之间是统计独立的

假设某样本X有 $\alpha_1,\alpha_2,\ldots,\alpha_n$ 个属性,那么有

$$P(x) = P(\alpha_1,\alpha_2,\ldots,\alpha_n) = P(\alpha_1) * P(\alpha_2) * \cdots * P(\alpha_n)$$

满足这样的公式就说明特征统计独立。

1.1 条件概率公式

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

根据文氏图可知:在事件B发生的情况下,事件A发生的概率就是P(A∩B)除以P(B)。

$$ P(A|B) = \frac{P(A\bigcap B)}{P(B)}$$

$$ \Rightarrow 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) $$

$$\Rightarrow P(A|B) = \frac{P(B|A) * P(A)}{P(B)}$$

接着看**全概率公式**,如果事件$A_1,A_2,A_3,\ldots,A_n$构成一个完备事件且都有正概率,那么对于任意一个事件B则有:

$$P(B) = P(BA_1)+P(BA_2)+\cdots+P(BA_n)$$

$$=P(BA_1)P(A_1)+P(BA_2)P(A_2)+\ldots+P(BA_n)P(A_n)$$

</br>

$$P(B) = \sum_{i=1}^{n}P(A_i)P(B|A_i)$$

1.2 贝叶斯推断

根据条件概率和全概率公式,可以得到贝叶斯公式如下:

$$ P(A|B) = P(A)\frac{P(B|A)}{P(B)} $$

$$ P(A_i|B) = P(A_i)\frac{P(B|A_i)}{\sum_{i=1}^{n}P(A_i)P(B|A_i)} $$

P(A)称为”先验概率”(Prior probability),即在B事件发生之前,我们对A事件概率的一个判断。
P(A|B)称为”后验概率”(Posterior probability),即在B事件发生之后,我们对A事件概率的重新评估。
P(B|A)/P(B)称为”可能性函数”(Likely hood),这是一个调整因子,使得预估概率更接近真实概率。
所以条件概率可以理解为:后验概率 = 先验概率 * 调整因子
如果”可能性函数”>1,意味着”先验概率”被增强,事件A的发生的可能性变大;
如果”可能性函数”=1,意味着B事件无助于判断事件A的可能性;
如果”可能性函数”<1,意味着”先验概率”被削弱,事件A的可能性变小。

1.3 嫁?还是不嫁?这是一个问题……

为了加深对朴素贝叶斯的理解,我们举个栗子!

假如某男(帅,性格不好,不上进)向女生求婚,该女生嫁还是不嫁?
根据贝叶斯公式:

$$P(A|B) = P(A)\frac{P(B|A)}{P(B)} $$

转换成分类任务的表达式:

$$P(类别|特征) = P(类别)\frac{P(特征|类别)}{P(特征)} $$

我们这个例子,按照朴素贝叶斯的求解,可以转换为计算$P(嫁|帅 性格不好 不上进)和P(不嫁|帅 性格不好 不上进)$,最终选择嫁与不嫁的答案。

根据贝叶斯公式可知:

$$P(嫁|帅 性格不好 不上进)=P(嫁)\frac{P(帅|嫁)P(性格不好|嫁)P(不上进|嫁)}{P(帅 性格不好 不上进)}$$

$$P(不嫁|帅 性格不好 不上进)=P(不嫁)\frac{P(帅|不嫁)P(性格不好|不嫁)P(不上进|不嫁)}{P(帅 性格不好 不上进)}$$

分母的计算用到的是全概率公式:

$$P(B) = \sum_{i=1}^{n}P(A_i)P(B|A_i)$$

所以

$$P(帅 性格不好 不上进)=P(嫁)P(帅|嫁)P(性格不好|嫁)P(不上进|嫁)$$

$$+P(不嫁)P(帅|不嫁)P(性格不好|不嫁)P(不上进|不嫁)$$

由上表可以得出:

P(嫁)= 5/10 = 1/2

P(不嫁)= 5/10 = 1/2

P(帅|嫁) * P(性格不好|嫁) * P(不上进|嫁)= 4/5 * 1/5 * 1/5

P(帅|不嫁) * P(性格不好|不嫁) * P(不上进|不嫁) = 1/5 * 3/5 * 2/5

对于类别“嫁”的贝叶斯分子为:
P(嫁) * P(帅|嫁) * P(性格不好|嫁) * P(不上进|嫁) = 1/2 * 4/5 * 1/5 * 1/5 = 2/125
对于类别“不嫁”的贝叶斯分子为:
P(不嫁) * P(帅|不嫁) * P(性格不好|不嫁) * P(不上进|不嫁) = 1/2 * 1/5 * 3/5 * 2/5 = 3/125

所以最终结果为:
P(嫁|帅 性格不好 不上进) = (2/125) / (2/125 + 3/125) = 40%
P(不嫁|帅 性格不好 不上进) = (3/125) / (2/125 + 3/125) = 60%
60% > 40%,该女生选择不嫁。


二、朴素贝叶斯种类

在scikit-learn中,一共有3个朴素贝叶斯的分类算法。分别是GaussianNB,MultinomialNB和BernoulliNB。

2.1 GaussianNB

GaussianNB就是先验为高斯分布(正态分布)的朴素贝叶斯,假设每个标签的数据都服从简单的正态分布。

$$P(X_j=x_j|Y=C_k)=\frac{1}{\sqrt{2\pi\delta_k^2}}exp(-\frac{(x_j-\mu_k)^2}{2\delta_k^2})$$

其中$C_k$为Y的第k类类别。$\mu_k$和 $\delta_k^2$为需要从训练集估计的值。 #### 2.2 MultinomialNB 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类的样本个数。$\lambda$为一个大于0的常数,常常取为1,即拉普拉斯平滑。也可以取其他值。

2.3 BernoulliNB

BernoulliNB就是先验为伯努利分布的朴素贝叶斯。假设特征的先验概率为二元伯努利分布,即如下式:

$$ P(X_j=x_{jl}|Y=C_k)=P(j|Y=C_k)x_{jl}+(1-P(j|Y=C_k))(1-x_{jl})$$


此时$l$只有两种取值。$x_{jl}$只能取值0或者1。在伯努利模型中,每个特征的取值是布尔型的,即true和false,或者1和0。在文本分类中,就是一个特征有没有在一个文档中出现。

2.4总结

  • 一般来说,如果样本特征的分布大部分是连续值,使用GaussianNB会比较好。
  • 如果如果样本特征的分布大部分是多元离散值,使用MultinomialNB比较合适。
  • 而如果样本特征是二元离散值或者很稀疏的多元离散值,应该使用BernoulliNB。

三、使用朴素贝叶斯进行文档分类

朴素贝叶斯一个很重要的应用就是文本分类,所以我们以在线社区留言为例。为了不影响社区的发展,我们要屏蔽侮辱性的言论,所以要构建一个快速过滤器,如果某条留言使用了负面或者侮辱性的语言,那么就将该留言标志为内容不当。过滤这类内容是一个很常见的需求。对此问题建立两个类型:侮辱类和非侮辱类,使用1和0分别表示。我们把文本看成单词向量或者词条向量,也就是说将句子转换为向量。考虑出现所有文档中的单词,再决定将哪些单词纳入词汇表或者说所要的词汇集合,然后必须要将每一篇文档转换为词汇表上的向量。简单起见,我们先假设已经将本文切分完毕,存放到列表中,并对词汇向量进行分类标注。

3.1 构建词向量

留言文本已经被切分好,并且人为标注好类别,用于训练模型。类别有两类,侮辱性(1)和非侮辱性(0)。

此案例所有的函数:

  • loadDataSet:创建实验数据集
  • createVocabList:生成词汇表
  • setOfWords2Vec:生成词向量
  • get_trainMat:所有词条向量列表
  • trainNB:朴素贝叶斯分类器训练函数
  • classifyNB:朴素贝叶斯分类器分类函数
  • testingNB:朴素贝叶斯测试函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
"""
函数功能:创建实验数据集
参数说明:无参数
返回:
postingList:切分好的样本词条
classVec:类标签向量
"""
def loadDataSet():
dataSet=[['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 dataSet,classVec
1
dataSet,classVec=loadDataSet()

生成词汇表:

1
2
3
4
5
6
7
8
9
10
11
12
"""
函数功能:将切分的样本词条整理成词汇表(不重复)
参数说明:
dataSet:切分好的样本词条
返回:
vocabList:不重复的词汇表
"""
def createVocabList(dataSet):
vocabSet = set() # 创建一个空的集合
for doc in dataSet: # 遍历dataSet中的每一条言论
vocabSet = vocabSet | set(doc) # 取并集
return list(vocabSet)

1
vocabList = createVocabList(dataSet)

生成词向量:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"""
函数功能:
根据vocabList词汇表,将inputSet向量化,向量的每个元素为 1或 0
参数说明:
vocabList:词汇表
inputSet:切分好的词条列表中的一条
返回:
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(" %s is not in my Vocabulary!" % word )
return returnVec # 返回文档向量

所有词条向量列表:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
"""
函数功能:生成训练集向量列表
参数说明:
dataSet:切分好的样本词条
返回:
trainMat:所有的词条向量组成的列表
"""
def get_trainMat(dataSet):
trainMat = [] # 初始化向量列表
vocabList = createVocabList(dataSet) # 生成词汇表
for inputSet in dataSet: # 遍历样本词条中的每一条样本
returnVec = setOfWords2Vec(vocabList, inputSet) # 将当前词条向量化
trainMat.append(returnVec) # 追加到向量列表中
return trainMat

1
trainMat = get_trainMat(dataSet)

3.2 朴素贝叶斯分类器训练函数

词向量构建好之后,我们就可以来构建朴素贝叶斯分类器的训练函数了。

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
""" 函数功能:朴素贝叶斯分类器训练函数
参数说明:
trainMat:训练文档矩阵
classVec:训练类别标签向量
返回:
p0V:非侮辱类的条件概率数组
p1V:侮辱类的条件概率数组
pAb:文档属于侮辱类的概率
"""
def trainNB(trainMat,classVec):
n = len(trainMat) # 计算训练的文档数目
m = len(trainMat[0]) # 计算每篇文档的词条数
pAb = sum(classVec)/n # 文档属于侮辱类的概率
p0Num = np.zeros(m); p1Num = np.zeros(m) # 词条出现数初始化为0
p0Denom = 0; p1Denom = 0 # 分母初始化为0
for i in range(n): # 遍历每一个文档
if classVec[i] == 1: # 统计属于侮辱类的条件概率所需的数据
p1Num += trainMat[i]
p1Denom += sum(trainMat[i])
else: # 统计属于非侮辱类的条件概率所需的数据
p0Num += trainMat[i]
p0Denom += sum(trainMat[i])
p1V = p1Num / p1Denom
p0V = p0Num / p0Denom
return p0V,p1V,pAb # 返回属于非侮辱类,侮辱类和文档属于侮辱类的概率

测试函数,查看结果:
1
p0V,p1V,pAb = trainNB(trainMat, classVec)

3.3 测试朴素贝叶斯分类器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from functools import reduce
"""
函数功能:朴素贝叶斯分类器分类函数
参数说明:
vec2Classify:待分类的词条数组
p0V:非侮辱类的条件概率数组
p1V:侮辱类的条件概率数组
pAb:文档属于侮辱类的概率
返回:
0:属于非侮辱类
1:属于侮辱类
"""
def classifyNB(vec2Classify, p0V, p1V, pAb):
p1 = reduce(lambda x,y:x*y, vec2Classify * p1V) * pAb # 对应元素相乘
p0 = reduce(lambda x,y:x*y, vec2Classify * p0V) * (1 - pAb)
print('p0:',p0)
print('p1:',p1)
if p1 > p0:
return 1
else:
return 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
""" 函数功能:朴素贝叶斯测试函数
参数说明:
testVec:测试样本
返回:
测试样本的类别
"""
def testingNB(testVec):
dataSet,classVec = loadDataSet()
vocabList = createVocabList(dataSet)
trainMat= get_trainMat(dataSet)
p0V,p1V,pAb = trainNB(trainMat,classVec)
thisone = setOfWords2Vec(vocabList, testVec)
if classifyNB(thisone,p0V,p1V,pAb):
print(testVec,'属于侮辱类')
else:
print(testVec,'属于非侮辱类')
1
2
3
4
5
6
#测试样本1
testVec1 = ['love', 'my', 'dalmation']
testingNB(testVec1)
#测试样本2
testVec2 = ['stupid', 'garbage']
testingNB(testVec2)

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

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

利用贝叶斯分类器对文档进行分类时,要计算多个概率的乘积以获得文档属于某个类别的概率,即计算 p(w0|1)p(w1|1)p(w2|1)。如果其中有一个概率值为0,那么最后的成绩也为0。显然,这样是不合理的,为了降低这种影响,可以将所有词的出现数初始化为1,并将分母初始化为2。这种做法就叫做拉普拉斯平滑(Laplace Smoothing)又被称为加1平滑,是比较常用的平滑方法,它就是为了解决0概率问题。

另外一个遇到的问题就是下溢出,这是由于太多很小的数相乘造成的。我们在计算乘积时,由于大部分因子都很小,所以程序会下溢或者得不到正确答案。为了解决这个问题,对乘积结果取自然对数。通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时,采用自然对数进行处理不会有任何损失。下图给出函数f(x)和ln(f(x))的曲线。

检查这两条曲线就会发现它们在相同区域内同时增加或者减少,并且在相同点上取到极值。它们的取值虽然不同,但不影响最终结果。因此可以修改代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def trainNB(trainMat,classVec):
n = len(trainMat) # 计算训练的文档数目
m = len(trainMat[0]) # 计算每篇文档的词条数
pAb = sum(classVec)/n # 文档属于侮辱类的概率
p0Num = np.ones(m); p1Num = np.ones(m) # 词条出现数初始化为1
p0Denom = 2; p1Denom = 2 # 分母初始化为2
for i in range(n): # 遍历每一个文档
if classVec[i] == 1: # 统计属于侮辱类的条件概率所需的数据
p1Num += trainMat[i]
p1Denom += sum(trainMat[i])
else: # 统计属于非侮辱类的条件概率所需的数据
p0Num += trainMat[i]
p0Denom += sum(trainMat[i])
p1V = np.log(p1Num / p1Denom)
p0V = np.log(p0Num / p0Denom)
return p0V,p1V,pAb # 返回属于非侮辱类,侮辱类和文档属于侮辱类的概率

1
p0V,p1V,pAb = trainNB(trainMat,classVec)
1
2
3
4
5
6
7
def classifyNB(vec2Classify, p0V, p1V, pAb):
p1 = sum(vec2Classify * p1V) + np.log(pAb)
p0 = sum(vec2Classify * p0V) + np.log(1- pAb)
if p1 > p0:
return 1
else:
return 0

测试代码运行结果:

1
2
3
4
5
6
#测试样本1
testVec1 = ['love', 'my', 'dalmation']
testingNB(testVec1)
#测试样本2
testVec2 = ['stupid', 'garbage']
testingNB(testVec2)

这样看,结果就没什么问题了。
1
2
['love', 'my', 'dalmation'] 属于非侮辱类
['stupid', 'garbage'] 属于侮辱类


四、优点与缺点

优点:在数据较少的情况下仍然有效,可以处理多类别问题。
缺点:对于输入数据的准备方式较为敏感。
适用数据类型:标称型数据。


完整数据源码: QzmVc1/Data-Mining/Naive Bayes/
参考链接:
【菊安酱的机器学习】第3期 朴素贝叶斯算法
机器学习实战.pdf