python实现朴素贝叶斯算法_Python

本代码实现了朴素贝叶斯分类器（假设了条件独立的版本），常用于垃圾邮件分类，进行了拉普拉斯平滑。

关于朴素贝叶斯算法原理可以参考博客中原理部分的博文。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

									#!/usr/bin/python

									# -*- coding: utf-8 -*-

									from math import log

									from numpy import*

									import operator

									import matplotlib

									import matplotlib.pyplot as plt

									from os import listdir

									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

									def createVocabList(dataSet):

									  vocabSet = set([]) #create empty set

									  for document in dataSet:

									    vocabSet = vocabSet | set(document) #union of the two sets

									  return list(vocabSet)

									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

									def trainNB0(trainMatrix,trainCategory):  #训练模型

									  numTrainDocs = len(trainMatrix)

									  numWords = len(trainMatrix[0])

									  pAbusive = sum(trainCategory)/float(numTrainDocs)

									  p0Num = ones(numWords); p1Num = ones(numWords)  #拉普拉斯平滑

									  p0Denom = 0.0+2.0; p1Denom = 0.0 +2.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 = log(p1Num/p1Denom)    #用log()是为了避免概率乘积时浮点数下溢

									  p0Vect = log(p0Num/p0Denom)

									  return p0Vect,p1Vect,pAbusive

									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 bagOfWords2VecMN(vocabList, inputSet):

									  returnVec = [0] * len(vocabList)

									  for word in inputSet:

									    if word in vocabList:

									      returnVec[vocabList.index(word)] += 1

									  return returnVec

									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)

									def textParse(bigString): # 长字符转转单词列表

									  import re

									  listOfTokens = re.split(r'\W*', bigString)

									  return [tok.lower() for tok in listOfTokens if len(tok) > 2]

									def spamTest():  #测试垃圾文件 需要数据

									  docList = [];

									  classList = [];

									  fullText = []

									  for i in range(1, 26):

									    wordList = textParse(open('email/spam/%d.txt' % i).read())

									    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) 

									  trainingSet = 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(bagOfWords2VecMN(vocabList, docList[docIndex]))

									    trainClasses.append(classList[docIndex])

									  p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))

									  errorCount = 0

									  for docIndex in testSet: 

									    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)

									listOPosts,listClasses=loadDataSet()

									myVocabList=createVocabList(listOPosts)

									print myVocabList,'\n'

									# print setOfWords2Vec(myVocabList,listOPosts[0]),'\n'

									trainMat=[]

									for postinDoc in listOPosts:

									  trainMat.append(setOfWords2Vec(myVocabList,postinDoc))

									print trainMat

									p0V,p1V,pAb=trainNB0(trainMat,listClasses)

									print pAb

									print p0V,'\n',p1V

									testingNB()