学习了那么多机器学习模型，一切都是为了实践，动手自己写写这些模型的实现对自己很有帮助的，坚持，共勉。本文主要致力于总结贝叶斯实战中程序代码的实现（python）及朴素贝叶斯模型原理的总结。python的numpy包简化了很多计算，另外本人推荐使用pandas做数据统计。
　　让你猜测一个身高2.16的人的职业，你一般会猜测他是篮球运动员。这个原理就是朴素贝叶斯原理，因为篮球运动员大多身高很高，所以这个人具有篮球运动员的条件，则猜测他是篮球运动员。
　　同理，另一个升高1.58的人，你应该不会猜他是篮球运动员。
　　条件贝叶斯公式：p(Ci | x,y)=p(x,y | Ci)*p(Ci) / p(x,y)
　　计算每个类别的概率，若p(C1 | x,y) &&p(~C1 | x,y), 则类别属于类C1，否则不属于类C1。
　　程序中在模型训练的时候，只需要先在训练样本中计算好先验概率 p(Ci) 和 条件概率&p(x,y | Ci) 即可，因为p(x,y)不随Ci变化，不影响p(Ci | x,y)的最好大小。
　　注：条件贝叶斯是保证条件之间独立的（文档分类中是假设一个词汇出现与其他词汇是否出现无关，然而同一主题的词汇一起出现的概率很高，存在关联），所以这个假设过于简单；尽管如此，然而事实表明，朴素贝叶斯的效果还很好。
三 实战1 -文本分类（应用过滤恶意留言等）
　　下面是二分类问题，文档只能属于0和1两个类别，
　　1 载入数据集：6条文本及它们各自的类别，这6条文本作为训练集。
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]
#1 is abusive, 0 not
return postingList,classVec
　　2 创建词汇表：利用集合结构内元素的唯一性，创建一个包含所有词汇的词表。
def createVocabList(dataSet):
vocabSet = set([])
#create empty set
for document in dataSet:
vocabSet = vocabSet | set(document) #union of the two sets
return list(vocabSet)
　　3 把输入文本根据词表转化为计算机可处理的01向量形式：
　　eq，测试文本1： ['love', 'my', 'dalmation']
　　　　词汇表：['cute', 'love', 'help', 'garbage', 'quit', 'I', 'problems', 'is', 'park', 'stop', 'flea', 'dalmation', 'licks', 'food', 'not', 'him', 'buying', 'posting', 'has', 'worthless', 'ate', 'to', 'maybe', 'please', 'dog', 'how', 'stupid', 'so', 'take', 'mr', 'steak', 'my']
　　　　向量化结果：[0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
def setOfWords2Vec(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] = 1
else: print "the word: %s is not in my Vocabulary!" % word
return returnVec
　　4训练模型：在训练样本中计算先验概率 p(Ci) 和 条件概率&p(x,y | Ci)，本实例有0和1两个类别，所以返回p(x,y | 0)，p(x,y | 1)和p(Ci)。
　　此处有两个改进的地方：
　　　　（1）若有的类别没有出现，其概率就是0，会十分影响分类器的性能。所以采取各类别默认1次累加，总类别（两类）次数2，这样不影响相对大小。
　　　　（2）若很小是数字相乘，则结果会更小，再四舍五入存在误差，而且会造成下溢出。采取取log，乘法变为加法，并且相对大小趋势不变。
def trainNB0(trainMatrix,trainCategory):
numTrainDocs = len(trainMatrix)
numWords = len(trainMatrix[0])
pAbusive = sum(trainCategory)/float(numTrainDocs)
p0Num = ones(numWords); p1Num = ones(numWords)
#change to ones()
p0Denom = 2.0; p1Denom = 2.0
#change to 2.0
for i in range(numTrainDocs):
if trainCategory[i] == 1:
p1Num += trainMatrix[i]
p1Denom += sum(trainMatrix[i])
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
p1Vect = log(p1Num/p1Denom)
#change to log()
p0Vect = log(p0Num/p0Denom)
#change to log()
return p0Vect,p1Vect,pAbusive
　　5 分类：根据计算后，哪个类别的概率大，则属于哪个类别。
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:
　　6 测试函数：
　　　　加载数据集+提炼词表；
　　　　训练模型：根据六条训练集计算先验概率和条件概率；
　　　　测试模型：对训练两条测试文本进行分类。
def testingNB():
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']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)
testEntry = ['stupid', 'garbage']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)
　　缺点：词表只能记录词汇是否出现，不能体现这个词汇出现的次数。改进方法：采用词袋模型，见下面垃圾邮件分类实战。
四 实战2-垃圾邮件分类
　　1 对邮件的文本划分成词汇，长度小于2的默认为不是词汇，过滤掉即可。返回一串小写的拆分后的邮件信息。
def textParse(bigString):
#input is big string, #output is word list
listOfTokens = re.split(r'\W*', bigString)
return [tok.lower() for tok in listOfTokens if len(tok) & 2]
　　2 文档词袋模型：使用数组代替集合数据结构，可以保存词汇频率信息。
def bagOfWords2VecMN(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
return returnVec
　　3 输入为25封正常邮件和25封垃圾邮件。50封邮件中随机选取10封作为测试样本，剩余40封作为训练样本。
　　　训练模型：40封训练样本，训练出先验概率和条件概率；
　　　测试模型：遍历10个测试样本，计算垃圾邮件分类的正确率。
def spamTest():
docList=[]; classList = []; fullText =[]
for i in range(1,26):
wordList = textParse(open('email/spam/%d.txt' % i).read())
# print wordList
docList.append(wordList)
fullText.extend(wordList)
classList.append(1)
wordList = textParse(open('email/ham/%d.txt' % i).read())
docList.append(wordList)
fullText.extend(wordList)
classList.append(0)
vocabList = createVocabList(docList)#create vocabulary
trainingSet = range(50); testSet=[]
#create test set
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:#train the classifier (get probs) trainNB0
trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
trainClasses.append(classList[docIndex])
p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
errorCount = 0
for docIndex in testSet:
#classify the remaining items
wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
if classifyNB(array(wordVector),p0V,p1V,pSpam) != classList[docIndex]:
errorCount += 1
print "classification error",docList[docIndex]
print 'the error rate is: ',float(errorCount)/len(testSet)
#return vocabList,fullText
　　上面我处理的样本的属性值都是分类型的，然而数值型的朴素贝叶斯能处理吗？
　　1 朴素贝叶斯处理数值型数据的方法：　　（1） 区间离散化，设阈值，分段。　　（2） 高斯化：求出概率密度函数，假设变量服从正态分布，根据已有变量统计均值和方差，　　　　得出概率密度函数，这样就解决了计算连续值作为分类的条件概率值。　　　　　　参考：/?p=2683　　2 除0问题：　　　　Laplace校准 所有计算均加一，总类别数目加n；　　3 下溢出：很小的值相乘，四舍五入误差　　　　采用log 乘法变相加；
　　4移除停用词：也可以提高文本分类的性能
参考：书&机器学习实战& Peter
阅读(...) 评论()朴素贝叶斯算法中如何用python实现tf-idf权重计算方式_机器学习吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：6,527贴子：
朴素贝叶斯算法中如何用python实现tf-idf权重计算方式收藏
机器学习实战书上有bool，词频权重实现方式，请教大神tf-idf权重计算法方式用python怎么实现
没基础?别怕,全程一对一辅导,硅谷的实战项目让你快速成长为数据分析师,获得名企认可,升职加薪.立即免费试学.
谢谢大神们，急求
有知道的希望给点代码
这些在sklearn里面都有成熟的工具，可以直接用
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或数据挖掘（9）
出处：fengfenggirl（@也爱数据挖掘）　
网址：/fengfenggirl/p/classification_evaluate.html
今天介绍一下朴素贝叶斯分类算法，讲一下基本原理，再以文本分类实践。
一个简单的例子
朴素贝叶斯算法是一个典型的统计学习方法，主要理论基础就是一个贝叶斯公式，贝叶斯公式的基本定义如下：
这个公式虽然看上去简单，但它却能总结历史，预知未来。公式的右边是总结历史，公式的左边是预知未来，如果把Y看出类别，X看出特征，P(Yk|X)就是在已知特征X的情况下求Yk类别的概率，而对P(Yk|X)的计算又全部转化到类别Yk的特征分布上来。
举个例子，大学的时候，某男生经常去图书室晚自习，发现他喜欢的那个女生也常去那个自习室，心中窃喜，于是每天买点好吃点在那个自习室蹲点等她来，可是人家女生不一定每天都来，眼看天气渐渐炎热，图书馆又不开空调，如果那个女生没有去自修室，该男生也就不去，每次男生鼓足勇气说：“嘿，你明天还来不？”,“啊，不知道，看情况”。
然后该男生每天就把她去自习室与否以及一些其他情况做一下记录，用Y表示该女生是否去自习室，即Y={去，不去}，X是跟去自修室有关联的一系列条件，比如当天上了哪门主课，蹲点统计了一段时间后，该男生打算今天不再蹲点，而是先预测一下她会不会去，现在已经知道了今天上了常微分方法这么主课，于是计算P(Y=去|常微分方程)与P(Y=不去|常微分方程)，看哪个概率大，
P(Y=去|常微分方程) & P(Y=不去|常微分方程)，那这个男生不管多热都屁颠屁颠去自习室了，否则不就去自习室受罪了。P(Y=去|常微分方程)的计算可以转为计算以前她去的情况下，那天主课是常微分的概率P(常微分方程|Y=去)，注意公式右边的分母对每个类别（去/不去）都是一样的，所以计算的时候忽略掉分母，这样虽然得到的概率值已经不再是0~1之间，但是其大小还是能选择类别。
后来他发现还有一些其他条件可以挖，比如当天星期几、当天的天气，以及上一次与她在自修室的气氛，统计了一段时间后，该男子一计算，发现不好算了，因为总结历史的公式：
这里n=3，x(1)表示主课，x(2)表示天气，x(3)表示星期几，x(4)表示气氛，Y仍然是{去，不去}，现在主课有8门，天气有晴、雨、阴三种、气氛有A+,A,B+,B，C五种，那么总共需要估计的参数有8*3*7*5*2=1680个，每天只能收集到一条数据，那么等凑齐1680条数据大学都毕业了，男生打呼不妙，于是做了一个独立性假设，假设这些影响她去自习室的原因是独立互不相关的，于是
有了这个独立假设后，需要估计的参数就变为，(8+3+7+5)*2 = 46个了，而且每天收集的一条数据，可以提供4个参数，这样该男生就预测越来越准了。
朴素贝叶斯分类器
讲了上面的小故事，我们来朴素贝叶斯分类器的表示形式：
当特征为为x时，计算所有类别的条件概率，选取条件概率最大的类别作为待分类的类别。由于上公式的分母对每个类别都是一样的，因此计算时可以不考虑分母，即
朴素贝叶斯的朴素体现在其对各个条件的独立性假设上，加上独立假设后，大大减少了参数假设空间。
在文本分类上的应用
文本分类的应用很多，比如垃圾邮件和垃圾短信的过滤就是一个2分类问题，新闻分类、文本情感分析等都可以看成是文本分类问题，分类问题由两步组成：训练和预测，要建立一个分类模型，至少需要有一个训练数据集。贝叶斯模型可以很自然地应用到文本分类上：现在有一篇文档d（Document），判断它属于哪个类别ck，只需要计算文档d属于哪一个类别的概率最大：
在分类问题中，我们并不是把所有的特征都用上，对一篇文档d，我们只用其中的部分特征词项&t1,t2,…,tnd&（nd表示d中的总词条数目），因为很多词项对分类是没有价值的，比如一些停用词“的,是,在”在每个类别中都会出现，这个词项还会模糊分类的决策面，关于特征词的选取，我的这篇文章有介绍。用特征词项表示文档后，计算文档d的类别转化为：
注意P(Ck|d)只是正比于后面那部分公式，完整的计算还有一个分母，但我们前面讨论了，对每个类别而已分母都是一样的，于是在我们只需要计算分子就能够进行分类了。实际的计算过程中，多个概率值P(tj|ck)的连乘很容易下溢出为0，因此转化为对数计算，连乘就变成了累加：
我们只需要从训练数据集中，计算每一个类别的出现概率P(ck)和每一个类别中各个特征词项的概率P(tj|ck)，而这些概率值的计算都采用最大似然估计，说到底就是统计每个词在各个类别中出现的次数和各个类别的文档的数目：
其中，Nck表示训练集中ck类文档的数目，N训练集中文档总数；Tjk表示词项tj在类别ck中出现的次数，V是所有类别的词项集合。这里对词的位置作了独立性假设，即两个词只要它们出现的次数一样，那不管它们在文档的出现位置，它们大概率值P(tj|ck)都是一样，这个位置独立性假设与现实很不相符，比如“放马屁”跟“马放屁”表述的是不同的内容，但实践发现，位置独立性假设得到的模型准确率并不低，因为大多数文本分类都是靠词的差异来区分，而不是词的位置，如果考虑词的位置，那么问题将表达相当复杂，以至于我们无从下手。
然后需要注意的一个问题是ti可能没有出现在ck类别的训练集，却出现在ck类别的测试集合中，这样因为Tik为0，导致连乘概率值都为0，其他特征词出现得再多，该文档也不会被分到ck类别，而且在对数累加的情况下，0值导致计算错误，处理这种问题的方法是采样加1平滑，即认为每个词在各个类别中都至少出现过一次，即
下面这个例子来自于参考文献1，假设有如下的训练集合测试集：
现在要计算docID为5的测试文档是否属于China类别，首先计算个各类的概率，P(c=China)=3/4,P(c!=China)=1/4，然后计算各个类中词项的概率：
注意分母（8+6）中8表示China类的词项出现的总次数是8，+6表示平滑，6是总词项的个数，然后计算测试文档属于各个类别的概率：
可以看出该测试文档应该属于CHina类别。
文本分类实践
我找了搜狗的搜狐新闻数据的历史简洁版，总共包括汽车、财经、it、健康等9类新闻，一共16289条新闻，搜狗给的数据是每一篇新闻用一个txt文件保存，我预处理了一下，把所有的新闻文档保存在一个文本文件中，每一行是一篇新闻，同时保留新闻的id，id的首字母表示类标，预处理并分词后的示例如下：
我用6289条新闻作为训练集，剩余1万条用于测试，采用互信息进行文本特征的提取，总共提取的特征词是700个左右。
分类的结果如下：
总共10000条新闻，分类正确的8343条，正确率0.8343，这里主要是演示贝叶斯的分类过程，只考虑了正确率也没有考虑其他评价指标，也没有进行优化。贝叶斯分类的效率高，训练时，只需要扫描一遍训练集，记录每个词出现的次数，以及各类文档出现的次数，测试时也只需要扫描一次测试集，从运行效率这个角度而言，朴素贝叶斯的效率是最高的，而准确率也能达到一个理想的效果。
我的实现代码如下：
#!encoding=utf-8
import random
import sys
import math
import collections
import sys
def shuffle():
'''将原来的文本打乱顺序，用于得到训练集和测试集'''
datas = [line.strip() for line in sys.stdin]
random.shuffle(datas)
for line in datas:
print line
lables = ['A','B','C','D','E','F','G','H','I']
def lable2id(lable):
for i in xrange(len(lables)):
if lable == lables[i]:
raise Exception('Error lable %s' % (lable))
def docdict():
return [0]*len(lables)
def mutalInfo(N,Nij,Ni_,N_j):
#print N,Nij,Ni_,N_j
return Nij * 1.0 / N * math.log(N * (Nij+1)*1.0/(Ni_*N_j))/ math.log(2)
def countForMI():
'''基于统计每个词在每个类别出现的次数，以及每类的文档数'''
docCount = [0] * len(lables)
#每个类的词数目
wordCount = collections.defaultdict(docdict)
for line in sys.stdin:
lable,text = line.strip().split(' ',1)
index = lable2id(lable[0])
words = text.split(' ')
for word in words:
wordCount[word][index] += 1
docCount[index] += 1
miDict = collections.defaultdict(docdict)
#互信息值
N = sum(docCount)
for k,vs in wordCount.items():
for i in xrange(len(vs)):
N11 = vs[i]
N10 = sum(vs) - N11
N01 = docCount[i] - N11
N00 = N - N11 - N10 - N01
mi = mutalInfo(N,N11,N10+N11,N01+N11) + mutalInfo(N,N10,N10+N11,N00+N10)+ mutalInfo(N,N01,N01+N11,N01+N00)+ mutalInfo(N,N00,N00+N10,N00+N01)
miDict[k][i] = mi
fWords = set()
for i in xrange(len(docCount)):
keyf = lambda x:x[1][i]
sortedDict = sorted(miDict.items(),key=keyf,reverse=True)
for j in xrange(100):
fWords.add(sortedDict[j][0])
print docCount
#打印各个类的文档数目
for fword in fWords:
print fword
def loadFeatureWord():
'''导入特征词'''
f = open('feature.txt')
docCounts = eval(f.readline())
features = set()
for line in f:
features.add(line.strip())
return docCounts,features
def trainBayes():
'''训练贝叶斯模型，实际上计算每个类中特征词的出现次数'''
docCounts,features = loadFeatureWord()
wordCount = collections.defaultdict(docdict)
tCount = [0]*len(docCounts)
#每类文档特征词出现的次数
for line in sys.stdin:
lable,text = line.strip().split(' ',1)
index = lable2id(lable[0])
words = text.split(' ')
for word in words:
if word in features:
tCount[index] += 1
wordCount[word][index] += 1
for k,v in wordCount.items():
scores = [(v[i]+1) * 1.0 / (tCount[i]+len(wordCount)) for i in xrange(len(v))]
print '%s\t%s' % (k,scores)
def loadModel():
'''导入贝叶斯模型'''
f = open('model.txt')
scores = {}
for line in f:
word,counts = line.strip().rsplit('\t',1)
scores[word] = eval(counts)
return scores
def predict():
'''预测文档的类标，标准输入每一行为一个文档'''
docCounts,features = loadFeatureWord()
docscores = [math.log(count * 1.0 /sum(docCounts)) for count in docCounts]
scores = loadModel()
rCount = 0
docCount = 0
for line in sys.stdin:
lable,text = line.strip().split(' ',1)
index = lable2id(lable[0])
words = text.split(' ')
preValues = list(docscores)
for word in words:
if word in features:
for i in xrange(len(preValues)):
preValues[i]+=math.log(scores[word][i])
m = max(preValues)
pIndex = preValues.index(m)
if pIndex == index:
rCount += 1
print lable,lables[pIndex],text
docCount += 1
print rCount,docCount,rCount * 1.0 / docCount
if __name__==&__main__&:
#shuffle()
#countForMI()
#trainBayes()
代码里面，计算特征词与训练模型、测试是分开的，需要修改main方法，比如计算特征词：
$cat train.txt | python bayes.py & feature.txt
训练模型：
$cat train.txt | python bayes.py & model.txt
预测模型：
cat test.txt | python bayes.py & predict.out
本文介绍了朴素贝叶斯分类方法，还以文本分类为例，给出了一个具体应用的例子，朴素贝叶斯的朴素体现在条件变量之间的独立性假设，应用到文本分类上，作了两个假设，一是各个特征词对分类的影响是独立的，另一个是词项在文档中的顺序是无关紧要的。朴素贝叶斯的独立性假设在实际中并不成立，但在分类效上依然不错，加上独立性假设后，对与属于类ck的谋篇文档d，其p(ck|d)往往会估计过高，即本来预期p(ck|d)=0.55，而朴素贝叶斯却计算得到p(ck|d)=0.99，但这并不影响分类结果，这是朴素贝叶斯分类器在文本分类上效果优于预期的原因。
王斌 译.信息检索导论. 人民邮电出版社
codemeals. 文本特征选择. cnblogs.
李航.统计学习方法.清华大学出版社
陈希孺. 概率论与数理统计.中国科学技术出版社.
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：55516次
排名：千里之外
原创：15篇
转载：59篇
(1)(10)(7)(5)(8)(5)(6)(15)(16)(1)}