机器学习之朴素贝叶斯_朴素贝也是

机器学习之朴素贝叶斯

一、朴素贝叶斯

首先我们要了解一下什么是朴素贝叶斯呢
想必大家都听过大名鼎鼎的贝叶斯公式，当然没听过我待会也会在过一遍
朴素贝叶斯（Naive Bayes）是一种基于概率理论的分类算法，以贝叶斯理论为理论基础，通过计算样本归属于不同类别的概率来进行分类，是一种经典的分类算法。朴素贝叶斯是贝叶斯分类器里的一种方法，之所以称它朴素，原因在于它采用了特征条件全部独立的假设。

二、贝叶斯决策理论

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

朴素贝叶斯是贝叶斯决策理论的一部分，所以讲述朴素贝叶斯之前有必要快速了解一下贝叶斯决策理论。

假设现在有一个数据集，它由两类数据组成（红色和蓝色），数据分布如下图所示。

现在用p 1 ( x , y ) p1(x,y)p1(x,y)表示数据点( x , y ) (x,y)(x,y)属于类别1（图中圆点表示的类别）的概率，用p 2 ( x , y ) p2(x,y)p2(x,y)表示数据点( x , y ) (x,y)(x,y)属于类别2（图中三角形表示的类别）的概率，那么对于一个新的数据的( x , y ) (x,y)(x,y)，可以用下面的规则来判断它的类别：

如果p 1 ( x , y ) > p 2 ( x , y ) p1(x,y) > p2(x,y)p1(x,y)>p2(x,y)，那么类别为1
如果p 1 ( x , y ) < p 2 ( x , y ) p1(x,y) < p2(x,y)p1(x,y)<p2(x,y)，那么类别为2
也就是说，会 选择高概率所对应的类别。这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

三、相应的数学知识

1.首先就是贝叶斯准则，贝叶斯准则告诉我们如何交换条件概率中的条件与结果，即如果已知P(x|c)，要求P(c|x)，那么可以使用下面的计算方法

2.全概率公式

除了条件概率以外，在计算p 1 p1p1和p 2 p2p2的时候，还要用到全概率公式
设事件A1,A2,A3…An两两互斥，又事件B满足

全概率公式可以写为

3.贝叶斯推断

对条件概率公式进行变形，可以得到如下形式:

P(A)称为"先验概率"（Prior probability），即在B事件发生之前，对A事件概率的一个判断。
P(A|B)称为"后验概率"（Posterior probability），即在B事件发生之后，对A事件概率的重新评估。

称为"可能性函数"（Likelyhood），这是一个调整因子，使得预估概率更接近真实概率

所以，条件概率可以理解成下面的式子：后验概率 ＝ 先验概率 ｘ 调整因子

四、使用条件概率来分类

贝叶斯决策理论要求计算两个概率 p1(x,y)和p2(x,y)
如果p1(x,y)>p2(x,y)，那么类别为1
如果p1(x,y)<p2(x,y)，那么类别为2

具体地，应用贝叶斯准则得到：

这些符号所代表的具体意义是：给定某个由x、y表示的数据点，那么该数据点来自类别c1和来自类别c2的概率是多少？
使用贝叶斯准则，可以通过已知的三个概率值来计算未知的概率值。

五、我们具体来实操一下文本分类

要从文本中获取特征，需要先拆分文本。这里的特征是来自文本的词条（token），一个词条是字符的任意组合。可以把词条想象为单词，也可以使用非单词词条，如URL、IP地址或者任意其他字符串。然后将每一个文本片段表示为一个词条向量，其中值为1表示词条出现在文档中，0表示词条未出现。

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

第一步，从文本中构建词向量

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

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

'''
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                                               #返回文档向量

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

其中：
postingList 是原始的 词条列表；
myVocabList 是 词汇表，是所有单词出现的集合，没有重复的元素；.
trainMat 是所有的词条向量组成的列表，它里面存放的是根据 myVocabList 向量化的 词条向量。

词汇表是用来将词条向量化的，一个单词在词汇表中出现过一次，那么就在相应位置记作1，如果没有出现就在相应位置记作0。

第二步，从词向量计算概率

现在已经知道一个词是否出现在一篇文档中，也知道该文档所属的类别。将重写贝叶斯准则，将之前的x、y 替换为w。粗体w表示这是一个向量，即它由多个数值组成。在这个例子中，数值个数与词汇表中的词个数相同。

用上述公式，对每个类计算该值，然后比较这两个概率值的大小。如何计算呢？首先可以通过类别i ii（侮辱性留言或非侮辱性留言）中文档数除以总的文档数来计算概率p(ci)，接下来计算p（w|ci）就要用到朴素贝叶斯假设，如果将w展开为一个个独立特征，那么就可以将上述概率写作p（w0,w1,w2…,wn）这里假设所有词都互相独立，该假设也称作条件独立性假设，它意味着可以使用p(w0|ci)p(w1|ci)…p(wn|ci)来计算上述概率，这就极大地简化了计算的过程。

以下是这一步的Python程序，也是最重要的一步

'''
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.zeros(numWords); p1Num = np.zeros(numWords)#创建numpy.zeros数组,词条出现数初始化为0
		p0Denom = 0.0; p1Denom = 0.0    #分母初始化为0
		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 = p1Num/p1Denom
		p0Vect = p0Num/p0Denom
		return p0Vect,p1Vect,pAbusive#返回属于侮辱类的条件概率数组，属于非侮辱类的条件概率数组，文档属于侮辱类的概率


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

运行结果如下，p0V存放的是属于类别0的单词的概率，也就是非侮辱类词汇的概率。比如p0V的正数第1个概率，就是I这个单词属于非侮辱类的概率为0.04166667，换算成百分比，也就是4.17%。同理，p1V的正数第1个概率，就是I这个单词属于侮辱类的概率为0。简单的单词I，大家都知道是属于非侮辱类的，这么看，分类还是比较准确的。pAb是所有侮辱类的样本占所有样本的概率，从classVec中可以看出，一用有3个侮辱类，3个非侮辱类。所以侮辱类的概率是0.5。

因此，p0V和p1V存放的就是myVocabList中单词的条件概率，而pAb就是先验概率。

第三步，根据现实情况修改分类器

如果其中一个概率值为0，那么最后的乘积也为0。为降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。这种做法就叫做 拉普拉斯平滑(Laplace Smoothing) 又被称为 加1平滑，是比较常用的平滑方法，它就是为了解决0概率问题。

除了这个问题之外，另一个遇到的问题是下溢出， 这是由于太多很小的数相乘造成的。当计算乘积:

由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。一种解决办法是对乘积取 自然对数,同时，采用 自然对数 进行处理不会有任何损失。
下图给出函数f(x)和lnf(x)的图像

检查这两条曲线，就会发现它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。

将上面的贝叶斯训练函数改成这个

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


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

这样就没有0概率了

第四步，还有一个分类函数,以及用测试集测试一下效果

'''
Parameters:
	vec2Classify - 待分类的词条数组
	p0Vec - 侮辱类的条件概率数组
	p1Vec -非侮辱类的条件概率数组
	pClass1 - 文档属于侮辱类的概率
Returns:
	0 - 属于非侮辱类
	1 - 属于侮辱类
'''
# 函数说明:朴素贝叶斯分类器分类函数
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
	p1 = sum(vec2Classify * p1Vec)
	p0 = sum(vec2Classify * p0Vec) 
	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']
	thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
	print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
	testEntry = ['stupid', 'garbage']
	thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
	print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))


if __name__ == '__main__':
	testingNB()

['love', 'my', 'dalmation'] classified as:  0
['stupid', 'garbage'] classified as:  1
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

可以看到，[love my dalmation]是非侮辱的，[stupid garbage]是侮辱的，说明分类情况还算OK
这就是我们的朴素贝叶斯啦

朴素贝叶斯的变体

1 高斯分布朴素贝叶斯（Gaussian Naive Bayes）

通过假设P(xi|Y)是服从高斯分布(也就是正态分布),xi为特征数据，Y为标签数据，每一列的xi都服从正太分布，那么训练模型的过程就相当于求解P为最大值时的正太分布公式中的期望和标准差，用模型做预测想到要已知期望方差求对应的概率

下面我们用鸢尾花数据来做一次高斯分布朴素贝叶斯

import sklearn.datasets as datasets
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split

iris = datasets.load_iris()
feature = iris.data
target = iris.target
x_train,x_test,y_train,y_test = train_test_split(feature,target,test_size=0.2,random_state=2020)
gaussion = GaussianNB()

gaussion.fit(x_train,y_train)
gaussion.score(x_test,y_test)  #预测对的得分
gaussion.predict(x_test)  #测试集的预测值
gaussion.predict_proba(x_test)  #测试集的预测概率
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2 多项式分布朴素贝叶斯（Multinomial Naive Bayes）

多项式朴素贝叶斯 (MultinomialNB)
基于原始的贝叶斯理论，假设概率服从一个简单的多项式分布。对于多项式分布，举个栗子来说明一下：
假设用X表示投掷一枚硬币的结果，正面的概率P(X=正|Y) = 0.5，反面的概率P(X=反|Y) = 0.5，并且这两种结果是相互独立的，且它们的和为1。这是多项式分布中的特殊的二项分布。只有两种可能的取值，不是正面就是反面。每掷一次硬币的测试过程就是一个样本，样本有两个特征x1：正面，x2：反面。出现哪一面，哪个特征值就为1，反之为0。
对于多项分布，可以以掷骰子为例。假设**X’**表示投骰子的结果，xi的取值就是[1,2,3,4,5,6]并且这六种结果是相互独立的，在样本的数量足够多的情况下，每一个点数出现的情况都是1/6。这就是多项分布。每投骰子的测试过程就是一个样本，样本有6个特征x1：点数为1，x2：点数为2…出现哪个点数，哪个特征值就为1，反之为0。

从上面所举的例子可以看出，多项式分布处理的是离散型的变量。

from sklearn.naive_bayes import MultinomialNB
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import numpy
# 64个特征，多分类问题，类别是10个
# 1. 加载数据集
digits = load_digits()
X = digits.data  # 样本
y = digits.target  # 标签
print(digits.data.shape)
print(numpy.unique(digits.target))
# 2. 划分数据集
X_trainer, X_test, Y_trainer, Y_test = train_test_split(X, y, test_size=0.3)
# 3. 调用MultinomialNB
mnb = MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)
mnb.fit(X_trainer, Y_trainer)
# 4. 查看预测结果
# 4.1 查看预测精确性
mnb_score = mnb.score(X_test, Y_test)  # 返回预测的精确性accuracy
print("Score：", mnb_score)
# 4.1 查看预测结果（对应输出每一个类别下的概率）
mnb_prob = mnb.predict_proba(X_test)  # 0-9中概率最大的标签是样本的标签
print("Predict_proba：", mnb_prob)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.伯努利分布朴素贝叶斯（Bernoulli Naive Bayes）

BernoulliNB对根据多元Bernoulli分布分布的数据实施朴素的贝叶斯训练和分类算法； 也就是说，可能有多个特征，但每个特征都假定为一个二进制值（伯努利，布尔值）变量。 因此，此类要求将样本表示为二进制值特征向量。

与多项式模型一样，伯努利模型适用于离散特征的情况，所不同的是，数据集中可以存在多个特征，但每个特征都是二分类的.伯努利模型中每个特征的取值只能是1和0(以文本分类为例，某个单词在文档中出现过，则其特征值为1，否则为0).伯努利模型需要比MultinomialNB多定义一个二值化的方法，该方法会接受一个阈值并将输入的特征二值化(1，0).当然也可以直接采用MultinomialNB，但需要预先将输入的特征二值化.
作用：
伯努利朴素贝叶斯与多项式朴素贝叶斯非常相似，都常用于处理文本分类数据。但由于伯努利朴素贝叶斯是处理二项 分布，所以它更加在意的是“是与否”。判定一篇文章是否属于体育资讯，而不是说属于体育类还是娱乐类。

基于伯努利贝叶斯的鸢尾花分类的代码实现

import sklearn.datasets as datasets  # 用于导入数据集
from sklearn.model_selection import train_test_split  # 用于数据集的拆分
from sklearn.naive_bayes import BernoulliNB   # 导入伯努利朴素贝叶斯算法

# 读取数据集
iris = datasets.load_iris()

# 提取特征数据和标签数据
feature = iris.data
target = iris.target

# 数据集的拆分
x_train, x_test, y_train, y_test = train_test_split(feature, target, test_size=0.2, random_state=2021)
# print(x_train)  # 可以看出训练集数据均为数值型类型，且相差不是很大，因此不需要做特征抽取和特征预处理

# 对数据集进行训练
mlt = BernoulliNB(binarize=6)  # 通过调节binarizer参数值的大小可以改善模型预测的准确率
mlt.fit(x_train, y_train)
score = mlt.score(x_test, y_test)
y_pred = mlt.predict(x_test)
y_true = y_test
print("预测鸢尾花类型为", y_pred)
print("实际鸢尾花类型为", y_true)
print("预测模型准确率为", score)

# 结果
# 预测鸢尾花类型为 [0 0 0 0 0 0 0 0 0 0 0 2 0 2 2 2 0 0 0 0 0 2 2 0 2 2 2 2 0 0]
# 实际鸢尾花类型为 [0 0 1 0 0 0 0 0 0 0 0 1 2 2 1 2 1 1 0 1 1 2 2 0 2 1 1 1 0 0]
# 预测模型准确率为 0.6333333333333333
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

由此可见，当待处理的样本数据是一个多分类的数据时，（鸢尾花的种类有三种（山鸢尾、杂色鸢尾、维吉尼亚鸢尾），需要判断它是哪一种），因此预测的结果偏差就较大。反之，如果样本数据中全部都是山鸢尾，那么训练后的模型就能很好地对一个未知的种类的鸢尾花它是不是山鸢尾而做出预测

​