文章目录
提示：参考书籍图灵程序设计丛书《机器学习实战》
一、基于贝叶斯决策理论的分类方法
贝叶斯决策理论的核心思想是：选择高概率所对应的类别，选择具有最高概率的决策。有时也被总结成“多数占优”的原则。
现在我们有一个数据集，它由两类数据组成，数据分布如图：
其中，假设两个概率分布的参数已知，并用p1(x,y)表示当前数据点(x,y)属于类别1（图中圆点）的概率；用p2(x,y)表示当前数据点(x,y)属于类别2（图中三角形）的概率。
具体到实例，对于一个数据点(x,y)，可以用如下规则判定它的类别：
若p1(x,y)>p2(x,y)，那么点(x,y)被判定为类别1。
若p1(x,y)<p2(x,y)，那么点(x,y)被判定为类别2。
（使用条件概率分类）
当然，在实际情况中，单单依靠以上的判定无法解决所有的问题，因为p1(x,y),p2(x,y)还不是贝叶斯决策理论的所有内容，使用p1(x,y)和p2(x,y) 只是为了简化描述。更多的，我们使用p(ci|x,y) 来确定给定坐标的点(x,y)，该数据点来自类别ci的概率是多少。具体地，应用贝叶斯准则可得到，该准则可以通过已知的三个概率值来计算未知的概率值：
则以上判定法则可转化为：
若p(c1|x,y)>p(c2|x,y)，那么点(x,y)被判定为类别c1。
若p(c1|x,y)<p(c2|x,y)，那么点(x,y)被判定为类别c2。
下面看一下什么是条件概率。
二、条件概率
有一个装了 7 块石头的罐子，其中 3 块是白色的，4 块是黑色的。如果从罐子中随机取出一块石头，那么是白色石头的可能性是多少？显然，取出白色石头的概率为 3/7 ，取到黑色石头的概率是 4/7 。我们使用 P(white) 来表示取到白色石头的概率，其概率值可以通过白色石头数目除以总的石头数目来得到。
如果这 7 块石头如下图所示，放在两个桶中，那么上述概率应该如何计算？
要计算 P(white) 或者 P(black) ，显然，石头所在桶的信息是会改变结果的，这就是条件概率 。假定计算的是从 B 桶取到白色石头的概率，这个概率可以记作 P(white|bucketB) ，我们称之为 “在已知石头出自 B 桶的条件下，取出白色石头的概率”。很容易得到，P(white|bucketA) 值为 2/4 ，P(white|bucketB)的值为 1/3 。
条件概率计算公式：
P(white|bucketB) = P(white and bucketB) / P(bucketB)
我们来看看上述公式是否合理。首先，用B桶中灰色石头个数除以两个桶中总的个数，得到P(white|bucketB)=1/7。由于B桶有3块石头，总数为7，于是P(bucketB)等于3/7.所以
P(white|bucketB) = P(white and bucketB) / P(bucketB)=（1/7）/（3/7）=1/3。这个公式
虽然对于这个简单例子来说有点复杂，但存在更多特征时是非常有效的。用代数方法计算条件概率时，该公式也很有用。
另外一种有效计算条件概率的方法称为贝叶斯准则。贝叶斯准则告诉我们如何交换条件概率中的条件与结果，即如果已知 P(x|c)，要求 P(c|x)，那么可以使用下面的计算方法:
三、使用python进行文本分类
1.准备数据：从文本中构建词向量
词表到向量的转换函数
#朴素贝叶斯
import numpy as np
# 数据可视化
import matplotlib.lines as mlines
import matplotlib.pyplot as plt
import matplotlib as mpl
from numpy import *
import operator
from os import listdir
import numpy as np
from functools import reduce
#词表到向量的转换函数
#创建一些实验样本
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)
# 文档词集模型：每个词只能出现一次
def setOfWords2Vec(vocabList,inputSet):
returnVec=[0]*len(vocabList) #创建一个和词汇表等长的向量，将其元素都设置为0
for word in inputSet:#遍历文档中所有单词，如果出现词汇表中的单词，则将输出文档向量中对应的值设置为1
if word in vocabList:
returnVec[vocabList.index(word)] = 1
else:
print("the word: %s is not in my Vocabulary!" % word)
#输出的是向量文档，向量的每个元素为1或0，分别表示词汇表中的单词在输入文档中是否出现
return returnVec
if __name__ == '__main__':
# 词表到向量的转换函数
# 创建一些实验样本
listOPosts, listClasses =loadDataSet()
# 创建一个包含在所有文档中出现的不重复词的列表
myVocabList =createVocabList(listOPosts)
print(myVocabList)
returnVec=setOfWords2Vec(myVocabList,listOPosts[0])
print(returnVec)
测试结果
2.训练算法：从词向量计算概率
前面介绍了如何将一组单词转换为一组数字，接下来看看如何使用这些数字计算概率。
现在已经知道一个词是否出现在一篇文档中，也知道该文档所属的类别。接下来我们重写贝叶斯准则，将之前的 x, y 替换为 w，表示这是一个向量，即它由多个值组成。在这个例子中，数值个数与词汇表中的词个数相同。
我们使用上述公式，对每个类计算该值，然后比较这两个概率值的大小。首先可以通过类别 i (侮辱性留言或者非侮辱性留言)中的文档数除以总的文档数来计算概率 p ( c i ) 。接下来计算p(w/ci)，这里就要用到朴素贝叶斯的假设。如果将w展开为一个个独立特征，那么将上述概率写作p（w0,w1,w2…wn/ci）。这里的假设所有词相互独立，该假设也称作条件独立性假设，它意味着可以使用p(w0/ci)p(w1/ci)p(w2/ci)…p(wn/ci)来计算上述概率，这就极大地简化了计算的过程。
#朴素贝叶斯分类器训练函数
def trainNB0(trainMtrix,trainCategory):
numTrainDocs=len(trainMtrix) #计算训练的文档数目
numWords=len(trainMtrix[0]) #计算每篇文章的词条数
pAbusive=sum(trainCategory)/float(numTrainDocs) #文档属于侮辱类的概率
p0Num=np.zeros(numWords);p1Num=np.zeros(numWords)#创建numpy.zeros数组
p0Denom=0.0;p1Denom=0.0 #分母初始化为0.0
for i in range(numTrainDocs):
if trainCategory[i]==1: #统计属于侮辱类的条件概率
p1Num+=trainMtrix[i] #向量相加
p1Denom+=sum(trainMtrix[i]) #统计属于非侮辱类的条件概率
else:
p0Num+=trainMtrix[i]
p0Denom+=sum(trainMtrix[i])
p1Vect=p1Num/p1Denom #对每个元素做除法
p0Vect=p0Num/p1Denom
#返回属于侮辱类的条件概率
return p0Vect,p1Vect,pAbusive
if __name__ == '__main__':
#朴素贝叶斯分类器训练函数
listOPosts, listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
trainMat = []
for postinDoc in listOPosts:
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V, p1V, pAb = trainNB0(trainMat, listClasses)
print(pAb)
print(p0V)
print(p1V)
测试结果
3.测试算法：根据现实情况修改分类器
在利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算
如果其中一个概率值为 0，那么最后的乘积也为 0。为降低这种影响，可以将所有词的出现数初始化为 1，并将分母初始化为 2
可以将trainNB0()的
p0Num=np.zeros(numWords);
p1Num=np.zeros(numWords)
p0Denom=0.0;
p1Denom=0.0
改成
p0Num = np.ones(numWords)
p1Num = np.ones(numWords)
p0Denom = 2.0 # 0 非侮辱性词汇出现总数
p1Denom = 2.0 # 1 侮辱性词汇出现总数
另一个遇到的问题是下溢出，这是由于太多很小的数相乘造成的。当计算乘积
时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。一种解决办法是对乘积取自然对数。在代数中有 ln(a * b) = ln(a) + ln(b), 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。
如图给出了函数 f(x) 与 ln(f(x)) 的曲线。可以看出，它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。我们将上述方法添加到分类器中
p1Vect = log(p1Num / p1Denom)
p0Vect = log(p0Num / p0Denom)
代码如下（示例）：
#朴素贝叶斯分类函数
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
p1=sum(vec2Classify*p1Vec)+log(pClass1)
p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
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))
pv0, pv1, pAb = trainNB0(trainMat, listClasses)
testEntry=['love','my','dalmation']
thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
print(testEntry,'classified as:',classifyNB(thisDoc,pv0,pv1,pAb))
testEntry=['stupid','garbage']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print(testEntry, 'classified as:', classifyNB(thisDoc, pv0, pv1, pAb))
if __name__ == '__main__':
# 朴素贝叶斯分类函数
testingNB()
测试结果
4.准备数据：文档词袋模型
目前为止，我们将每个词的出现与否作为一个特征 ，这可以被描述为词集模型 ，如果一个词在文档中出现不止一次，这可能意味着包含该词是否出现在文档中所不能表达的某种信息，这种方法被称为词袋模型。在词袋中，每个单词可以出现多次，而在词集中，每个单词只能出现一次。
#朴素贝叶斯词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
# 创建一个其中所含元素都为0的向量
returnVec = [0] * len(vocabList)
# 遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值加1
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
return returnVec
六、示例：使用朴素贝叶斯过滤垃圾邮件
1.准备数据：切分文本
if __name__ == '__main__':
mysent = "This book is the best book on Python or M.L. I have ever laid eyes upon."
testSplit = mysent.split()
print(testSplit)
#去掉里面除单词，数字外的任意空字符串，可以计算字符串的长度
import re
regEx = re.compile('\\W+')
listOfSent = regEx.split(mysent)
print(listOfSent)
#将字符串转换成小写
result = [tok.lower() for tok in listOfSent if len(tok) > 0]
print(result)
emailText = open('email/ham/6.txt').read()
listOfTokens=regEx.split(emailText)
测试结果：
2.测试算法：使用朴素贝叶斯进行交叉验证
#文件解析及完整的垃圾邮件测试函数
def textParse(bigSreing):
import re
listOfTokens = re.split(r'\w*', bigSreing)
return (tok.lower() for tok in listOfTokens if len(tok) > 2)
def spamTest():
docList = [];classList = [];fullText = [] # 每封邮件的词汇表 # 每篇邮件的分类 # 所有邮件的词汇表(一个列表)
for i in range(1, 26):
# 导入文件夹 spam 下的文件，切分，解析数据，并归类为 1 类别
wordList = textParse(open('email/spam/%d.txt' % i).read()) #导入解析文本文件
docList.append(wordList)
fullText.extend(wordList)
classList.append(1)
# 导入文件夹 ham 下的文件切分，解析数据，并归类为 0 类别
wordList = textParse(open('email/ham/%d.txt' % i,'r',encoding='UTF-8',errors='ignore').read())
docList.append(wordList)
fullText.extend(wordList)
classList.append(0)
vocabList = createVocabList(docList) # 创建词汇表（去重）
trainingSet = list(range(50));testSet = []#训练集 测试集
for i in range(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(array(trainMat), array(trainClasses))
errorCount = 0
for docIndex in testSet: ## 遍历测试集，对每封邮件进行分类
wordVector = setOfWords2Vec(vocabList, docList[docIndex])
if classifyNB(array(wordVector), p0V, p1V, pSpam) != \
classList[docIndex]:
errorCount += 1
print("the error rate is : ", float(errorCount) / len(testSet))
if __name__ == '__main__':
spamTest()
测试结果：
spamTest()输出10封随机选择的电子邮件上的分类错误率。既然这些电子邮件是随机选择的，所以每次输出都会有差别。这边会把错误邮件误判为正常邮件。但不会把正常邮件判断为垃圾邮件,这个不错。
总结
遇到了一个问题：提示直接打开文件错误
把
wordList = textParse(open(‘email/ham/%d.txt’ % i).read())
改成
wordList = textParse(open(‘email/ham/%d.txt’ % i,‘r’,encoding=‘UTF-8’,errors=‘ignore’).read())
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
