机器学习实战学习笔记（三）：朴素贝叶斯
贝叶斯原理
之所以称之为“朴素”，是因为整个形式化过程只做最原始、最简单的假设。
优缺点
- 优点：在数据较少的情况下仍然有效，可以处理多类别问题。
- 确定：对于输入数据的准备方式比较敏感。
- 适用数据类型：标称型数据。
入门示例
二维坐标中，如果p1(x,y) > p2(x,y)，那么(x,y)属于类别1，否则属于类别2.
共有7块石头，3块灰色的，4块黑色的
p(gray) = 3/7
p(black) = 4/7现在将7块石头分到两只桶中，桶A包含2灰2黑，桶B包含1灰2黑
从A或B桶中取到灰色石头的概率：
p(gray|bucketA) = 2/4
p(gray|bucketB) = 1/3取到A桶或B桶的概率：
p(bucketA) = p(bucketB) = 1/2取到B桶中灰色石头的概率
p(gray and bucketB) = 1/7结论
p(gray|bucketB) = p(gray and bucketB)/p(bucketB) = 1/7 / 3/7 = 1/3
p(gray|bucketB) = p(bucketB|gray)p(gray)/p(bucketB) = 1/3 * 3/7 / 3/7贝叶斯推测：
p(c|x) = (p(x|c)p(c))/p(x)即：
p(gray|bucketB) = p(bucketB|gray)p(gray)/p(bucketB) = 1/3 * 3/7 / 3/7 = 1/3
在桶B中选到灰色石块的概率 = 在3块灰色石块中选一个石块是桶B中的石块的概率 * 选到灰色石块的概率 / 选到桶B中的石块的概率贝叶斯扩展
p(c|x,y) = ( p(x,y|c)p(c) ) / p(x,y)应用
如果P(c1|x, y) > P(c2|x, y) ，那么属于类别c1.
如果P(c1|x, y) < P(c2|x, y) ，那么属于类别c2.
机器学习的一个重要应用就是文档的自动分类。
朴素贝叶斯分类器中的一个假设是，每个特征同等重要。
应用（一）——判断留言是否为侮辱性留言
p(ci|w) = p(w|ci)*p(ci)/p(w)
联系示例：p(gray|bucketB) = p(bucketB|gray)p(gray)/p(bucketB)
ci: 类别，侮辱性类别，或者非侮辱性类别；
w: 要鉴别的文档向量，唯一词汇列表对比生成的文档向量；
from numpy import *
# 加载实验样本
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] # 0：非侮辱；1：侮辱性；
return postingList, classVec # 返回两个集合
# 样本去重
def createVocabList(dataSet):
vocabSet = set([]) # 构造一个空的集合
for document in dataSet:
vocabSet = vocabSet | set(document)
return list(vocabSet)
''' vocabList: 去重后的词汇集合 inputSet: 某个文档，被拆分成了词汇集合 return: 文档向量，词属于样本文档中的为1，否则为0 '''
def setOfWords2Vec(vocabList, inputSet):
returnVec = [0]*len(vocabList) # 初始化length长度向量
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] = 1 # 1输入文档的词出现在词汇表里，0表示未出现
# else: print("the word: %s is not in my Vocabulary!" % word)
else:
print("###########################")
return returnVec
''' 朴素贝叶斯分类器训练函数 trainMatrix: 训练集文档向量，多个文档，且经过了向量化 trainCategory: 训练集类别 return: 每个侮辱性的词，在所有侮辱性的文档中的概率； 每个非侮辱性的词，在所有非侮辱性的文档中的概率； '''
def trainNB0(trainMatrix, trainCategory):
numTrainDocs = len(trainMatrix) # 文档数
numWords = len(trainMatrix[0]) # 第一个文档有多少词
pAbusive = sum(trainCategory)/float(numTrainDocs) # 侮辱性文档数量/文档数，即侮辱性文档概率
p0Num = zeros(numWords) # 初始化0集合，非侮辱性文档向量总和
p1Num = zeros(numWords) # 初始化0集合，侮辱性文档向量总和
p0Denom = 0.0 # 初始化0，非侮辱文档中有多少词包含在样本集中
p1Denom = 0.0 # 初始化0，侮辱文档中中有多少词包含在样本集中
for i in range(numTrainDocs): # 遍历每个文档
if trainCategory[i] == 1: #如果该文档是侮辱性的
p1Num += trainMatrix[i] # 文档加到p1Num集合中
p1Denom += sum(trainMatrix[i]) # 对文档中的1求和，有多少词属于样本中的
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
p1Vect = p1Num/p1Denom #
p0Vect = p0Num/p0Denom
return p0Vect, p1Vect, pAbusive
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
p1 = sum(vec2Classify * p1Vec) + log(pClass1) # element-wise mult
p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
if p1 > p0:
return 1
else:
return 0
def doMethod():
listOPosts, listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
trainMat = []
for postinDoc in listOPosts:
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
testEntry = ['love', 'my', 'dalmation']
docs = setOfWords2Vec(myVocabList, testEntry)
thisDoc = array(docs)
num = classifyNB(thisDoc, p0V, p1V, pAb)
print(num)
doMethod()利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，如果其中一个概率值为0，那么最后的乘积也为0。为降低这种影响，可以将所有词的出现数初始化为1，并将坟墓初始化为2。
另一个问题是下溢出，这是由于太多很小的数相乘造成的。当计算乘积，由于大部分因子都很小，所以程序会下溢出或者得到不正确的答案，可以通过取自然对数的lnX的方法处理，会简单些。