模式识别和机器学习实战- 朴素贝叶斯分类 - Python实现 - 实战之文档分类和过滤垃圾邮件

前言

实验目的和要求：

1. 使用概率分布进行分类
2. 学习朴素贝叶斯分类器进行文本分类
3. 完成实战之过滤垃圾邮件

---

推荐使用Jupyter Notebook ，方便浏览代码，当然用pycharm也可以。

完整的代码会在文后给出

一、贝叶斯决策论概述

贝叶斯决策理论最核心思想：选择高概率对应的类别

我们用p1（x，y）表示数据点（x，y）属于类别1的概率，用p2（x，y）表示数据点（x，y）属于类别2的概率，若p1（x，y） > p2（x，y），那么类别为1。

那么我们需要简单了解一下概率论中的条件概率这个定义：P(A|B)表示事件B已经发生的前提下，事件A发生的概率，P(B|A)叫做事件B发生下事件A的条件概率。其基本求解公式为：P(A|B) = P(AB)/P(B) P(B|A) = P(A|B)*P(B)/P(A)

对应：P（类别|特征） = P（特征|类别）*P（类别）/P（特征）

---

举个生动形象的栗子：

现在有一个问题是，如果一对男女朋友，男生想向女生求婚，男生的四个特点分别是不帅，性格不好，身高矮，不上进，请你判断一下女生是嫁还是不嫁？

以下的表格是提前已知的一些数据 （与现实不一定相符合哈┗( ▔, ▔ )┛）

这是一个典型的分类问题，转为 数学问题 就是比较以下两项：
p(嫁|(不帅、性格不好、身高矮、不上进))
p(不嫁|(不帅、性格不好、身高矮、不上进))
这是在已知条件下的概率，谁的概率大，就能给出嫁或者不嫁的答案！

然后把条件概率展开来：

带入表格中的样本数据：
p(嫁) = 6/12（总样本数） = 1/2
p(不帅|嫁) = 3/6 = 1/2
p(性格不好|嫁)= 1/6
p(矮|嫁) = 1/6
p(不上进|嫁) = 1/6
p（不帅） = 4/12 = 1/3
p（性格不好） = 4/12 = 1/3
p（身高矮） = 7/12
p（不上进） = 4/12 = 1/3
得到的就是 p(嫁|(不帅、性格不好、身高矮、不上进)) ，即在不帅、性格不好、身高矮、不上进 的条件下，得到结果为 嫁 的概率（算了一下，结果只有 5%左右…）

二、实战之文档分类

1.先导入 numpy 库和数据集以及带有样本类别标签向量

2.需要将数据集中的所有单词生成一个词汇表 用 set 集合运算，利用集合元素的唯一性，求并集获得词汇表
3. 建立函数，输入为词汇表和新的样本；遍历所有输入词汇，如 果输入词出现和词汇表匹配，那么返回的向量对应的索引值为 1

调用函数查看输出值

4. 建立主要函数
   trainMatrix 为训练集的句子在词汇表中出现位置向量列表，traincategory 为训练集对应的标 签0 或 1；
   计算先验概率，因为侮辱性句子的类别标签为 1，直接用 sum 标签中所有 1 再除以总样本数，得 到 pAbusive；
   之后循环遍历所有句子，对于标签为 1 的，数量 p1Num 加 1，同时 p1Denom 也加上 1；对于标签为 0 的，直接加是句子的位置向量，对应的词加 1；
   最后返回的是取对数的向量 p1Vect 和 p0Vect，就是两种类别的概率分布。
   
5. 分类函数 classifyNB，对于已经知道属于类别 1 和类别 0 的概率分布；p1 表示数据 点属于类别 1 的概率，用 p0 表示数据点属于类别 0 的概率，若 p1> p2，那么类别为 1
   
6. 测试函数，输入一个新的样本[‘love’,‘my’, ‘dalmation’]，应用之前 的训练集和分类器，完成分类任务。
   

三、过滤垃圾邮件

1.首先进行文本信息录入，将 txt 文件的内容变成一个向量列表
如果在运行过程中出现的错误 ‘gbk’ codec can’t decode byte 0xae in position 199: illegal multibyte sequence 为文本中部分字符无法识别，经过排除在 23 号文件中修改，将无法识别的字符删去

2. 主函数
   先是读入数据，将所有 26 个邮件和标记读入
   

其后，用随机数的方式分割测试集；仍然用 trainNB 函数作为训练函数， 循环遍历，得到概率分布 p0V，p1V，pSpan；最后，用分类器识别，输出错误率。

初次错误率为 0，之后几次错误率为 0.1

三、实验结果与分析

• 错误率为何会忽上忽下，原因是测试集为随机生成的方式

• 贝叶斯电子邮件过滤器利用贝叶斯定理。贝叶斯定理在垃圾邮件的上下文中使用了几次：
  第一次，计算信息是垃圾的概率，知道一个给定的单词出现在此信息中；
  第二次，计算信息是垃圾的概率，考虑到所有的它的词（或它们的一个相关子集）

总代码

1.文档分类

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]   
    return postingList,classVec
                 
def createVocabList(dataSet):
    vocabSet = set([])  
    for document in dataSet:
        vocabSet = vocabSet | set(document)
    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 = 2.0; p1Denom = 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)          
    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 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))
    
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

def calcMostFreq(vocabList,fullText):
    import operator
    freqDict = {}
    for token in vocabList:
        freqDict[token]=fullText.count(token)
    sortedFreq = sorted(freqDict.items(), key=operator.itemgetter(1), reverse=True) 
    return sortedFreq[:30]  
testingNB()

2.过滤垃圾邮件
文件路径在 D:/email 下，根据自己情况修改

def textParse(bigString):    #数据预处理
    import re
    listOfTokens = re.split(r' |\n|\t|,|\.', bigString)
    return [tok.lower() for tok in listOfTokens if len(tok) > 2] 

def spamTest():  # 检测垃圾邮件
    docList=[]
    classList = []
    fullText =[]
    for i in range(1,26): 
        # 读取所有的26篇垃圾邮件，返回列表
        wordList = textParse(open('D:/email/spam/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1) #标记为1
        # 读取所有的26篇非垃圾邮件，返回列表
        wordList = textParse(open('D:/email/ham/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)#标记为0
    #把数据变成向量   
    vocabList = createVocabList(docList)
    trainingSet = list(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 ('错误率是: ',float(errorCount)/len(testSet))
    calcMostFreq(vocabList,fullText)
    
spamTest()