使用朴素贝叶斯过滤垃圾邮件
本文摘自《机器学习实战》，并对其进行了代码更新与完善。感兴趣者可回复获得资源！
准备数据：切分文本
现提供邮件文件夹：spam；非垃圾邮件文件夹：ham，各有25封邮件。（提取码：d0ee）
将邮件中的内容文本，进行分割，转换成一系列词语组成的列表
def textParse(bigString):
import re
listOfTokens=re.split('\W',bigString) #匹配非字母数字下划线
return [tok.lower() for tok in listOfTokens if len(tok)>2] #若文本中有URL，对其进行切分时，会得到很多词，为避免该情况，限定字符创的长度
准备数据：从文本中构建词向量
（1）首先将所有文档中的单词组成词汇表
#将文档矩阵中的所有词构成词汇表
def creatVocabList(dataset):
vocabSet=set([])
for document in dataset:
vocabSet=vocabSet|set(document) #两个集合的并集
return list(vocabSet)
（2）将每一篇文档转换为词汇表上的向量，现有两种模型：词集模型与词袋模型
词集模型：文档转换成的向量中的每一元素为1或0，分别表示词汇表中的单词在输入文档中是否出现。
词袋模型：文档转换成的向量中的每一元素，表示词汇表中的单词在输入文档中出现的次数
#将某一文档转换成词向量，该向量中所含数值数目与词汇表中词汇数目相同
#词集模型
def setOfWords2Vec(vocabList,inputSet): #参数分别为词汇表，输入文档
returnVec=[0]*len(vocabList)
for word in inputSet:
if word in vocabList:
#1表示词向量该位置对应的词汇表中的单词，出现在inpust文档中
returnVec[vocabList.index(word)]=1
return returnVec
#将某一文档转换成词向量，该向量中所含数值数目与词汇表中词汇数目相同
#词袋模型
def bagOfWords2Vec(vocabList,inputSet): #参数分别为词汇表，输入文档
returnVec=[0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)]+=1
return returnVec
训练算法：从词向量计算概率
#朴素贝叶斯分类器训练函数
#trainMatrix为文档词向量矩阵,
#trainCategory为每篇文档的类标签构成的向量
def trainNB0(trainMatrix,trainCategory):
numTrainDocs=len(trainMatrix) #总文档数
numWords=len(trainMatrix[0]) #所有词的数目
pAbusive=sum(trainCategory)/float(numTrainDocs) #侮辱性概率，即P(1)
p0Num=np.ones(numWords); p1Num=np.ones(numWords)
p0Deom=2.0; p1Deom=2.0
for i in range(numTrainDocs):
if trainCategory[i]==1:
p1Num+=trainMatrix[i] #向量相加
p1Deom+=sum(trainMatrix[i]) #所有垃圾邮件中出现的词条的总计数值
else:
p0Num+=trainMatrix[i]
p0Deom+=sum(trainMatrix[i])
p1Vect=np.log(p1Num/p1Deom) #在垃圾文档条件下词汇表中单词的出现概率
p0Vect=np.log(p0Num/p0Deom)
#pAbusive就是人以文档属于垃圾文档的概率
return p0Vect,p1Vect,pAbusive
测试算法：使用朴素贝叶斯进行交叉验证
#朴素贝叶斯分类函数
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass): #参数分别为：要分类的向量以及使用trainNB0()计算得到的三个概率
p1=sum(vec2Classify*p1Vec)+np.log(pClass)
p0=sum(vec2Classify*p0Vec)+np.log(1-pClass)
if p1>p0:
return 1 #表示侮辱性文档
else:
return 0
#测试算法：使用朴素贝叶斯交叉验证。同时保存分类模型的词汇表以及三个概率值，避免判断时重复求值
def spamTest():
docList = [] # 文档（邮件）矩阵
classList = [] # 类标签列表
for i in range(1, 26):
wordlist = textParse(open('data/spam/{}.txt'.format(str(i))).read())
docList.append(wordlist)
classList.append(1)
wordlist = textParse(open('data/ham/{}.txt'.format(str(i))).read())
docList.append(wordlist)
classList.append(0)
vocabList = creatVocabList(docList) # 所有邮件内容的词汇表
import pickle
file=open('data/vocabList.txt',mode='wb') #存储词汇表
pickle.dump(vocabList,file)
file.close()
# 对需要测试的邮件，根据其词表fileWordList构造向量
# 随机构建40训练集与10测试集
trainingSet = list(range(50))
testSet = []
for i in range(10):
randIndex = int(np.random.uniform(0, len(trainingSet)))
testSet.append(trainingSet[randIndex])
del (trainingSet[randIndex])
trainMat = [] # 训练集
trainClasses = [] # 训练集中向量的类标签列表
for docIndex in trainingSet:
# 使用词袋模式构造的向量组成训练集
trainMat.append(bagOfWords2Vec(vocabList, docList[docIndex]))
trainClasses.append(classList[docIndex])
p0v,p1v,pAb=trainNB0(trainMat,trainClasses)
file=open('data/threeRate.txt',mode='wb') #用以存储分类器的三个概率
pickle.dump([p0v,p1v,pAb],file)
file.close()
errorCount=0
for docIndex in testSet:
wordVector=bagOfWords2Vec(vocabList,docList[docIndex])
if classifyNB(wordVector,p0v,p1v,pAb)!=classList[docIndex]:
errorCount+=1
return float(errorCount)/len(testSet)
构造分类器
def fileClassify(filepath):
import pickle
fileWordList=textParse(open(filepath,mode='r').read())
file=open('data/vocabList.txt',mode='rb')
vocabList=pickle.load(file)
vocabList=vocabList
fileWordVec=bagOfWords2Vec(vocabList,fileWordList) #被判断文档的向量
file=open('data/threeRate.txt',mode='rb')
rate=pickle.load(file)
p0v=rate[0];p1v=rate[1];pAb=rate[2]
return classifyNB(fileWordVec,p0v,p1v,pAb)
if __name__=='__main__':
print('朴素贝叶斯分类的错误率为：{}'.format(spamTest())) #测试算法的错误率
filepath=input('输入需判断的邮件路径')
#判断某一路径下的邮件是否为垃圾邮件
if fileClassify('data/spam/1.txt')==1:
print('垃圾邮件')
else:
print('非垃圾邮件')