机器学习实战3-贝叶斯分类

1 基础名词解释

1.1 概率： 已知模型和参数，预测出现某个结果的概率。

1.2 统计：已知大量数据，利用数据去预测模型及其参数。

1.3 先验概率： 根据以往经验和分析得到的概率，如抛硬币，我们抛之前，就认为硬币向上概率为0.5.

1.4 后验概率： 事情已发生，判断事情发生由那个原因引起的概率。（由果溯因）

1.5 P(x|θ): x表示一个具体数据，θ表示模型参数；x确定，表示为似然函数；θ确定，表示为概率函数。

1.6 极大似然估计(MLE)：已知一组样本数据，假定该数据满足某种模型，依据数据对模型的参数进行估计。

2 过滤网站恶意留言

朴素贝叶斯分类：

关于该公式的几点说明：

1. 1. 该公式用于预测，c为分类的类别，可以有c1、c2、····ci等等若干种，下例中只有两种，即是否侮辱性词汇。
   2. X为属性向量，即总有d个属性，xi为第i个属性所对应的值。
   3. P(xi|c)根据训练数据集求出。
   4. 朴素贝叶斯分类的一个关键点是：属性条件独立性假设，即假设所有属性间相互独立，所有属性独立对分类结果产生影响。
   5. P(x)不会影响判断结果，故并不需要知道。

例子：关于一个输入文本，判断其是否含有侮辱性言论语言

思路剖一下：

1. 1. 需要数据:待测文本，已经带有标签的数据样本（即已标出是否为侮辱性）
   2. 建立词汇库，将所有出现的词语不重复放入库中，此即属性
   3. 将每条样本与词汇库比对，即建立属性值矩阵
   4. 根据样本集求出相关概率值，p1,p2,pc
   5. 比较待测数据两种情况下的概率，概率大的则为判断结果

代码如下： 

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([])
    #set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等(set之间)。
    for document in dataSet:
        vocabSet=vocabSet|set(document)
    return list(vocabSet)

# 判断输入文档中词是否在词汇表中出现，输出一个向量表（0或1）
def setOfWords2Vec(vocabList,inputSet):
    returnVec=[0]*len(vocabList) #创建一个与词汇表等长的初始0向量
    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) #初始化p0num,p1num为0向量
    p1Num=ones(numWords)
    p0Denom=2.0
    p1Denom=2.0
    # 从第一个样本到最后一个样本依次检查，如果该样本的标签是1（即为侮辱性），
    # 则将该样本数据加入p1num中，否则放入p0num中，p1denom表示的是放入p1num的样本1总和
    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()
    myVolcabList=createVocabList(listOPosts)
    trainMat=[]
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVolcabList,postinDoc))
    p0v,p1v,pAb=trainNB0(array(trainMat),array(listClasses))
    testEntry=['love','my','dalmation']
    thisDoc=array(setOfWords2Vec(myVolcabList,testEntry))
    print(testEntry ,'classified as: ',classifyNB(thisDoc,p0v,p1v,pAb))
    testEntry=['stupid','garbage']
    thisDoc=array(setOfWords2Vec(myVolcabList,testEntry))
    print(testEntry,' classified as: ',classifyNB(thisDoc,p0v,p1v,pAb))

testingNB()

结果如下：

3 过滤垃圾邮件

内容介绍：

1. 两个文件夹各取25个邮件，spam装着垃圾邮件，ham则是有用邮件。
2. 以上50个邮件均属带标签，即均可做训练样本，随机抽取其中10个样本作为测试集，即可验证分类精度。
3. 运用上例中的诸多函数。

主程序如下：

# 将一个大字符串解析为字符列表，并去掉小于两个字符的字符串，转换为小写
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=[]
    # 两个文件夹中共50个文件，spam25个垃圾，ham25个有用邮件
    for i in range(1,26):
        wordList=textParse(open('email/spam/%d.txt'%i).read())
        docList.append(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) #存0-49个整数
    testSet=[]
    # 留存交叉验证：随机选出10个样本，将其作为测试集，其余40作训练集，计算错误率
    for i in range(10):
        randIndex=int(random.uniform(0,len(trainingSet))) #生成0-50间的随机数
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    trainMat=[]
    trainClasses=[]
    for docIndex in trainingSet:
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V,p1V,pSpam=trainNB0(array(trainMat),array(trainClasses))
    errorCount=0
    for docIndex in testSet:
        wordVector=setOfWords2Vec(vocabList,docList[docIndex])
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
    print('the error rate is: ',float(errorCount)/len(testSet))

4 获取区域倾向

内容介绍：

1. 使用RSS源作为数据集来源。
2. 两个来源即为两个标签。
3. 如上例一样可以进行分类，但分类之前需要取出词汇，但一小部分高频词汇是对分类精度有影响的(常用词汇，辅助词汇等)。
4. 最后还对两个不同源的高频词汇进行分析。
5. 本文中的rss源不可用，可使用其他源。

# RSS源分类器及高频词去除函数
# 找出排前三十的高频词汇
def calcMostFreq(vocabList,fullText):
    import operator
    freqDict={}
    for token in vocabList:
        freqDict[token]=fullText.count(token)
    sortedFreq=sorted(freqDict.iteritems(),key=operator.itemgetter(1),reverse=True)
    # sorted对可迭代的对象进行排序操作，iteritems()使字典变为可迭代对象，operator.itemgetter(1)使数目为比较元素，true降序
    return sortedFreq[:30]#输出是一个列表n*2，第一列单词，第二列次数

# 几乎和上例一模一样，访问为rss源，而不是文件，且获得排序最高100的单词并将他们移除
def localWords(feed1,feed0):
    import feedparser
    docList=[];classList=[];fullText=[]
    minLen=min(len(feed1['entries']),len(feed0['entries']))#取两个源中项目数量最少的
    for i in range(minLen):
        wordList=textParse(feed1['entries'][i]['summary'])# 每篇的摘要
        # append添加一个整体对象，extend将每个元素逐个添加
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList=textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList=createVocabList(docList)# 创建字库
    # 去除高频词汇三十个（会影响分类错误率）
    top30Words=calcMostFreq(vocabList,fullText)
    for pairW in top30Words:
        if pairW[0] in vocabList:
            vocabList.remove(pairW[0])
    trainingSet=range(2*minLen)
    testSet=[]
    for i in range(20):
        randIndex=int(random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    trainMat=[]
    trainClasses=[]
    for docIndex in trainingSet:
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V,p1V,pSpam=trainNB0(array(trainMat),array(trainClasses))
    errorCount=0
    for docIndex in testSet:
        wordVector=setOfWords2Vec(vocabList,docList[docIndex])
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
    print('the error rate is: ',float(errorCount)/len(testSet))
    return vocabList,p0V,p1V

# 显示最具表征性的词汇
def getTopWords(feed0,feed1):
    import operator
    vocabList,p0V,p1V=localWords(feed1,feed0)
    topfeed1=[]
    topfeed0=[]
    for i in range(len(p0V)):
        if p0V[i]>-6.0:
            topfeed0.append((volcabList[i],p0V[i]))
        if p1V[i]>-6.0:
            topfeed1.append((volcabList[i],p0V[i]))
    sortedFeed0=sorted(topfeed0,key=lambda pair:pair[1],reverse=True)
    for item in sortedFeed0:
        print(item[0])
    sortedFeed1=sorted(topfeed1,key=lambda pair:pair[1],reverse=True)
    for item in sortedFeed1:
        print(item[0])

 5 总结

后两例是对第一例的扩展理解，理解第一例即可对朴素贝叶斯分类的原理有很好的认识。主要参考书为周志华《机器学习》以及peter《python机器学习实战》。