基于贝叶斯决策理论的分类方法

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

假设现在我们有一个数据集，它由两类数据组成

p1(x,y)表示数据点(x,y)属于类别1（图中用圆点表示的类别）的概率 ,用p2(x,y)表示数据点(x,y)属于类别2（图中用三角形表示的类别）的概率

对于一个新数据点(x,y) ,如果 p1(x,y) > p2(x,y)，那么类别为1 ,如果 p2(x,y) > p1(x,y)，那么类别为2

也就是说，我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

条件概率

条件概率的计算公式如下所示：

P(gray ∣bucket B)=P(gray and bucketB) /P(bucket B)\mathrm{P}(\text { gray } | \text { bucket } \mathrm{B})=\mathrm{P}(\text { gray and bucketB) } / \mathrm{P}(\text { bucket } \mathrm{B})P( gray ∣ bucket B)=P( gray and bucketB) /P( bucket B)

另一种有效计算条件概率的方法称为贝叶斯准则 ,即如果已知P(x|c)，要求P(c|x)

p(c∣x)=p(x∣c)p(c)p(x)p(c | x)=\frac{p(x | c) p(c)}{p(x)}p(c∣x)=p(x)p(x∣c)p(c)

使用条件概率来分类

前面提到贝叶斯决策理论要求计算两个概率p1(x, y)和p2(x, y)

使用p1( )和p2( )只是为了尽可能简化描述，而真正需要计算和比较的是p(c1|x, y)和p(c2|x, y)。这些符号所代表的具体意义是：给定某个由x、 y表示的数据点，那么该数据点来自类别c1的概率是多少？

应用贝叶斯准则得到

p(ci∣x,y)=p(x,y∣ci)p(ci)p(x,y)p\left(c_{i} | x, y\right)=\frac{p\left(x, y | c_{i}\right) p\left(c_{i}\right)}{p(x, y)}p(ci∣x,y)=p(x,y)p(x,y∣ci)p(ci)

 如果P(c1|x, y) > P(c2|x, y)，那么属于类别c1。
 如果P(c1|x, y) < P(c2|x, y)，那么属于类别c2。

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

机器学习的一个重要应用就是文档的自动分类。在文档分类中，整个文档（如一封电子邮件）是实例，而电子邮件中的某些元素则构成特征。朴素贝叶斯是上节介绍的贝叶斯分类器的一个扩展，是用于文档分类的常用算法。

朴素贝叶斯的一般过程
(1) 收集数据：可以使用任何方法。本章使用RSS源。
(2) 准备数据：需要数值型或者布尔型数据。
(3) 分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。
(4) 训练算法：计算不同的独立特征的条件概率。
(5) 测试算法：计算错误率。
(6) 使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。

要得到好的概率分布，就需要足够的数据样本，假定样本数为N。由统计学知，如果每个特征需要N个样本，那么对于10个特征将需要N10N^{10}N10个样本，对于包含1000个特征的词汇表将需要N1000N^{1000}N1000个样本。可以看到，所需要的样本数会随着特征数目增大而迅速增长

如果特征之间相互独立，那么样本数就可以从N1000N^{1000}N1000减少到1000×N。所谓独立（independence）指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其他单词相邻没有关系。

使用 Python 进行文本分类

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

朴素贝叶斯分类器通常有两种实现方式：一种基于贝努利模型实现，一种基于多项式模型实现。这里采用前一种实现方式。该实现方式中并不考虑词在文档中出现的次数，只考虑出不出现，因此在这个意义上相当于假设词是等权重的。

1. 准备数据：从文本中构建词向量

我们将把文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现在所有文档中的所有单词，再决定将哪些词纳入词汇表或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。

词表到向量的转换函数

# 加载数据集函数
def loadDataSet():# 定义邮件列表postingList = [['my', 'dog', 'has', 'flea', \'problem', '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']]# 定义标签向量，1——abusive，0——not abusive,1 代表侮辱性文字， 0代表正常言论classVec = [0, 1, 0, 1, 0, 1]return postingList, classVec

loadDataSet()创建了一些实验样本。该函数返回的第一个变量是进行词条切分后的文档集合, loadDataSet( )函数返回的第二个变量是一个类别标签的集合。这里有两类，侮辱性和非侮辱性。这些文本的类别由人工标注，这些标注信息用于训练程序以便自动检测侮辱性留言。

# 创建词汇列表
def createVocabList(dataSet):# 定义词汇集vocabSet = set([])# 遍历文档for document in dataSet:# 将每个document合并到vocabSet，|用来联合两个集合vocabSet = vocabSet | set(document)# 返回词汇集return list(vocabSet)

createVocabList()会创建一个包含在所有文档中出现的不重复词的列表

# 把单词转换成向量
def setOfWords2Vec(vocabList, inputSet):# 定义要返回的向量returnVec = [0] * len(vocabList)# 遍历输出集中的单词for word in inputSet:# 单词在词汇集中if word in vocabList:# 对应的位置设为1returnVec[vocabList.index(word)] = 1else:print"the word: %s is not in my Vocabulary!" % word# 返回向量return returnVec

setOfWords2Vec()函数的输入参数为词汇表及某个文档，输出的是文档向量，向量的每一元素为1或0，分别表示词汇表中的单词在输入文档中是否出现。

运行结果

# 准备数据：从文本中构建词向量运行结果:
listOPosts,listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
print(myVocabList)
#['has', 'problem', 'dalmation', 'I', 'how', 'licks', 'ate', 'cute',
# 'maybe', 'dog', 'love', 'garbage', 'please', 'help', 'flea', 'not',
# 'so', 'is', 'food', 'park', 'to', 'quit', 'stupid', 'him', 'posting', '
# stop', 'steak', 'mr', 'buying', 'my', 'take', 'worthless']

print(setOfWords2Vec(myVocabList,listOPosts[0]))
#listOPosts[0]: <class 'list'>: ['my', 'dog', 'has', 'flea', 'problem', 'help', 'please']
#[0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]

print(setOfWords2Vec(myVocabList,listOPosts[3]))
#listOPosts[3]: <class 'list'>: ['stop', 'posting', 'stupid', 'worthless', 'garbage']
#[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]

2. 训练算法：从词向量计算概率

前面介绍了如何将一组单词转换为一组数字，接下来看看如何使用这些数字计算概率。我们重写贝叶斯准则，将之前的x、 y 替换为w\boldsymbol{w}w。粗体w\boldsymbol{w}w表示这是一个向量，即它由多个数值组成。在这个例子中，数值个数与词汇表中的词个数相同。

p(ci∣w)=p(w∣ci)p(ci)p(w)p\left(c_{i} | \boldsymbol{w}\right)=\frac{p\left(\boldsymbol{w} | c_{i}\right) p\left(c_{i}\right)}{p(\boldsymbol{w})}p(ci∣w)=p(w)p(w∣ci)p(ci)

独立特征简化为p(w0∣ci)p(w1∣ci)p(w2∣ci)…p(wN∣ci)\mathrm{p}\left(\mathrm{w}_{0} | \mathrm{c}_{\mathrm{i}}\right) \mathrm{p}\left(\mathrm{w}_{1} | \mathrm{c}_{\mathrm{i}}\right) \mathrm{p}\left(\mathrm{w}_{2} | \mathrm{c}_{\mathrm{i}}\right) \ldots \mathrm{p}\left(\mathrm{w}_{\mathrm{N}} | \mathrm{c}_{\mathrm{i}}\right)p(w0∣ci)p(w1∣ci)p(w2∣ci)…p(wN∣ci)

函数的伪代码

计算每个类别中的文档数目
对每篇训练文档：对每个类别：如果词条出现在文档中→ 增加该词条的计数值增加所有词条的计数值对每个类别：对每个词条：将该词条的数目除以总词条数目得到条件概率返回每个类别的条件概率

该函数使用了NumPy的一些函数，故应确保将from numpy import *语句添加到bayes.py文件的最前面

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

# 条件概率的计算
def trainNB0(trainMatrix,trainCategory):# 计算文档的数目numTrainDocs = len(trainMatrix)# 计算单词的数目numWords = len(trainMatrix[0])# 计算类别的概率，abusive为1，not abusive为0pAbusive =sum(trainCategory) / float(numTrainDocs)# 初始化计数器，1行numWords列，p0是not abusive# p0Num =zeros(numWords)p0Num = ones(numWords)# 初始化计数器，p1是abusivep1Num = ones(numWords)# 初始化分母p0Denom = 2.0p1Denom = 2.0# 遍历文档for i in range(numTrainDocs):# 计算abusive对应的词汇的数目，trainMatrix为0-1值形成的向量if trainCategory[i] == 1:# p1Num存储的是每个词出现的次数p1Num += trainMatrix[i]# p1Denom存储的是词的总数目p1Denom += sum(trainMatrix[i])# 计算not abusive词汇的数目else:# 每个词在not abusive下出现的次数p0Num += trainMatrix[i]# not abusive下的总词数p0Denom += sum(trainMatrix[i])# 计算abusive下每个词出现的概率# p1Vect = p1Num / p1Denomp1Vect = log(p1Num / p1Denom)# 计算not abusive下每个词出现的概率# p0Vect = p0Num / p0Denomp0Vect = log(p0Num / p0Denom)# 返回词出现的概率和文档为abusive的概率，not abusive的概率为1-pAbusivereturn p0Vect,p1Vect,pAbusive

利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算p(w0∣1)p(w1∣1)p(w2∣1)\mathrm{p}\left(\mathrm{w}_{0} | 1\right) \mathrm{p}\left(\mathrm{w}_{1} | 1\right) \mathrm{p}\left(\mathrm{w}_{2} | 1\right)p(w0∣1)p(w1∣1)p(w2∣1)。如果其中一个概率值为0，那么最后的乘积也为0。为降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。

当计算乘积p(w0∣ci)p(w1∣ci)p(w2∣ci)…p(wN∣ci)\mathrm{p}\left(\mathrm{w}_{0} | \mathrm{c}_{\mathrm{i}}\right) \mathrm{p}\left(\mathrm{w}_{1} | \mathrm{c}_{\mathrm{i}}\right) \mathrm{p}\left(\mathrm{w}_{2} | \mathrm{c}_{\mathrm{i}}\right) \ldots \mathrm{p}\left(\mathrm{w}_{\mathrm{N}} | \mathrm{c}_{\mathrm{i}}\right)p(w0∣ci)p(w1∣ci)p(w2∣ci)…p(wN∣ci)时，由于大部分因子都非常小，所以程序会下溢出或者
得到不正确的答案。一种解决办法是对乘积取自然对数。在代数中有ln⁡(a⋆b)=ln⁡(a)+ln⁡(b)\ln \left(a^{\star} b\right)=\ln (a)+\ln (b)ln(a⋆b)=ln(a)+ln(b)，于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。

运行结果

# 从预先加载值中调入数据
listOPosts,listClasses = loadDataSet()
#listOPosts: <class 'list'>: [['my', 'dog', 'has', 'flea', 'problem', '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']]
#listClasses: <class 'list'>: [0, 1, 0, 1, 0, 1]
# 构建了一个包含所有词的列表myVocabList
myVocabList = createVocabList(listOPosts)
#myVocabList: <class 'list'>: ['ate', 'stupid', 'flea', 'mr', 'dog', 'my', 'love', 'licks', 'him', 'stop', 'dalmation', 'quit', 'I', 'not', 'help', 'please', 'take', 'garbage', 'cute', 'problem', 'to', 'posting', 'food', 'so', 'is', 'how', 'maybe', 'buying', 'worthless', 'steak', 'has', 'park']
trainMat = []
# for循环使用词向量来填充trainMat列表
for postinDoc in listOPosts:trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
#trainMat: <class 'list'>: [[0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0]]

p0v,p1v,pAb = trainNB0(trainMat,listClasses)
#?进入trainNB0函数进行# 条件概率的计算
def trainNB0(trainMatrix,trainCategory):numTrainDocs = len(trainMatrix) #numTrainDocs: 6numWords = len(trainMatrix[0]) #numWords: 32pAbusive =sum(trainCategory) / float(numTrainDocs) #pAbusive: 0.5p0Num = ones(numWords) #p0Num: [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]p1Num = ones(numWords)# p1Num == p0Nump0Denom = 2.0 #p0Denom: 2p1Denom = 2.0 #p1Denom: 2for i in range(numTrainDocs):if trainCategory[i] == 1:p1Num += trainMatrix[i]p1Denom += sum(trainMatrix[i])else:p0Num += trainMatrix[i]p0Denom += sum(trainMatrix[i])p1Vect = log(p1Num / p1Denom)p0Vect = log(p0Num / p0Denom)return p0Vect,p1Vect,pAbusive

3. 测试算法：根据现实情况修改分类器

朴素贝叶斯分类函数

#代码有4个输入：要分类的向量vec2Classify以及使用函数trainNB0()计算得到的三个概率。
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):# 计算abusive的概率p1 = sum(vec2Classify * p1Vec) + log(pClass1)# 计算not abusive的概率p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)# 根据概率大小判断属于哪个类if p1 > p0:return 1else:return 0

第二个函数是一个便利函数（convenience function），该函数封装所有操作，以节省输入代码的时间。

# 测试
def testingNB():# 加载数据集listOPosts,listClass = loadDataSet()# 创建词汇列表myVocabList = createVocabList(listOPosts)trainMat = []for postinDoc in listOPosts:trainMat.append(setOfWords2Vec(myVocabList,postinDoc))p0V,p1V,pAb = trainNB0(array(trainMat),array(listClass))# print p0V,p1V,pAb# print trainMattestEntry = ['love','my','dalmation']thisDoc = array(setOfWords2Vec(myVocabList,testEntry))#[0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0]print(testEntry, 'classified as:', classifyNB(thisDoc, p0V, p1V, pAb))#['love', 'my', 'dalmation'] classified as: 0testEntry = ['stupid', 'garbage']thisDoc = array(setOfWords2Vec(myVocabList, testEntry))#[0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]print(testEntry, 'classified as:', classifyNB(thisDoc, p0V, p1V, pAb))#['stupid', 'garbage'] classified as: 1

运行结果

['love', 'my', 'dalmation'] classified as: 0
['stupid', 'garbage'] classified as: 1

准备数据：文档词袋模型

目前为止，我们将每个词的出现与否作为一个特征，这可以被描述为词集模型（set-of-wordsmodel）。如果一个词在文档中出现不止一次，这可能意味着包含该词是否出现在文档中所不能表达的某种信息，这种方法被称为词袋模型（bag-of-words model）。在词袋中，每个单词可以出现多次，而在词集中，每个词只能出现一次。为适应词袋模型，需要对函数setOfWords2Vec()稍加修改，修改后的函数称为bagOfWords2Vec()。

# 把单词转换成向量,用词袋模型，计算词出现的次数
def bagOfWords2VecMN(vocabList,inputSet):# 定义要返回的向量returnVec = [0] * len(vocabList)# 遍历输出集中的单词for word in inputSet:# 单词在词汇集中if word in vocabList:# 对应的词出现次数 加1returnVec[vocabList.index(word)] += 1# 返回向量return returnVec