# -*- coding: utf-8 -*-
"""
我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想,即选择具有最高概率的决策.
贝叶斯:p(A|B) = p(A) * p(B|A) / p(B)
我们把P(A)称为"先验概率"(Prior probability),即在B事件发生之前,我们对A事件概率的一个判断。
P(A|B)称为"后验概率"(Posterior probability),即在B事件发生之后,我们对A事件概率的重新评估。
也就是发生了事件B,对事件A进行修正,得到的概率
P(B|A)/P(B)称为"可能性函数"(Likelyhood),这是一个调整因子,使得预估概率更接近真实概率。
"""
import numpy as np
from functools import reduce
"""
函数说明:创建实验样本
Parameters:
无
Returns:
postingList 实验样本切分的词条
classVec 类别标签向量
"""
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]
return postingList, classVec
"""
函数说明:根据实验样本创建一个不重复的词条列表,也就是词汇表
Parameters:
dataSet 整理成的样本数据集
Returns:
vocabSet 词条列表,
"""
def createVocabList(dataSet):
#创建一个空的不重复的列表。重复的被删除,无序的
vocabSet = set([])
for document in dataSet:
#取并集
vocabSet = vocabSet | set(document)
return list(vocabSet)
"""
函数说明:根据vocabSet词汇表,将input向量化,向量的每个元素为0或者1
Parameters:
vocabSet 词汇表
inputSet 实验样本切分的词条,即句子
Returns:
returnVec 文档向量,词集模型
"""
def setOfWord2Vec(vocabList, inputSet):
returnVec = [0] * len(vocabList)
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:
trainMatrix 训练文档矩阵,即setOfWord2Vec返回值
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)
#分母初始化为零
p0Denom = 0.0
p1Denom = 0.0
for i in range(numTrainDocs):
#统计属于侮辱类的条件概率
if trainCategory[i] == 1:
p1Num += trainMatrix[i]
p1Denom += sum(trainMatrix[i])
#统计属于非侮辱类的条件概率
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
p1Vect = p1Num / p1Denom
p0Vect = p0Num / p0Denom
return p0Vect, p1Vect, pAbusive
"""
函数说明:朴素贝叶斯分类函数
Parameters:
vec2Classify 待分类的词条数组
p0Vec 非侮辱类的条件概率数组
p1Vec 侮辱类的条件概率数组
pClass1 句子属于侮辱类的概率
Returns:
0 非侮辱类
1 侮辱类
"""
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
"""
p(A+B) = p(A) + p(B) - p(AB)
当AB互斥: p(A+B) = p(A) + p(B)
当AB独立:
p(AB) = p(A) * p(B)
p(A1A2A3|B) = p(A1|B) * p(A2|B) * p(A3|B)
因此:贝叶斯:p(Ci|(x,y)) = p(Ci) * p((x,y)|Ci) / p(x,y)
s是句子,1是侮辱类,s1 s2 s3是句子拆分的词汇
p(1|s) = p(1) * p(s|1)
= p(1) * p(s1s2s3|1)
= p(1) *[ p(s1|1) * p(s2|1) * p(s3|1) ] 独立
"""
p1 = reduce(lambda x,y : x*y, vec2Classify * p1Vec) * pClass1
p0 = reduce(lambda x,y : x*y, vec2Classify * p0Vec) * (1.0 - pClass1)
print('p0:', p0)
print('p1:', p1)
if p1 > p0:
return 1
else:
return 0
if __name__ == '__main__':
List0Posts, ListClasses = loadDataSet()
myVocabList = createVocabList(List0Posts)
trainMat = []
for postinDoc in List0Posts:
trainMat.append(setOfWord2Vec(myVocabList, postinDoc))
p0V, p1V, pAb = trainNB0(np.array(trainMat), np.array(ListClasses))
test1 = ['love', 'my', 'dalmation']
#测试样本向量化
testVec = np.array(setOfWord2Vec(myVocabList, test1))
if classifyNB(testVec, p0V, p1V, pAb):
print(test1, '属于侮辱类')
else:
print(test1, '属于非侮辱类')
test2 = ['stupid', 'garbage']
#测试样本向量化
testVec2 = np.array(setOfWord2Vec(myVocabList, test2))
if classifyNB(testVec2, p0V, p1V, pAb):
print(test2, '属于侮辱类')
else:
print(test2, '属于非侮辱类')
朴素贝叶斯(一)
猜你喜欢
转载自blog.csdn.net/Lightlock/article/details/84852000
今日推荐
周排行