机器学习实战第四章朴素贝叶斯算法照葫芦画瓢算法实践

完成了朴素贝叶斯分类器的主要算法，并且利用其过滤了辣鸡邮件，及对个人发布的大量广告中学习分类器，并将学习结果转换成可以理解的信息。

用到了feedparse库中相关的函数来访问RSS源，如果是在windos下，且装有anaconda的情况下，可以不需要去官网上下包，解压再安装，直接在命令行中

输入conda install feedparse一般就能安装成功，非常方便。

# -*- coding: utf-8 -*-
"""
照葫芦画瓢完成于2017.4.23 20:25
算法名称 : 基于朴素贝叶斯的分类方法
算法整体思路：
  通过统计想要的不同类型的数据出现的频率，转换成概率，依照条件概率进行具体的分类，主要对于一些相关文本的属性进行分类。
  1.从文本中构建词向量
  2.通过构建出的词向量计算概率
  3.构建文件词袋模型
  4.切分文本，解析文本，构建训练集，利用朴素贝叶斯对测试集中的文本进行分类
作者:
    zzt941006
"""
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 代表侮辱性文字 0代表正常言论,也即每一行里的文字代表的是侮辱性的还是正常向的
    return postingList,classVec
def createVocabList(dataSet):
    vocabSet = set([])
    for document in dataSet: # 每次取出list中的一行
        vocabSet = vocabSet | set(document) #去重取并集
        #print document,len(vocabSet)
    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
#训练算法通过词向量计算概率
#对于for循环里的计算，我们可以发现，比如my这个词，在分类0里面出现3次，则最后的p0Num数组所对应的my那个位置上的值就是3，而p0Denom代表
#所有非侮辱性文档中的单词总数，比如第一篇有7个第三篇有8个第五篇有9个一共出现了24次，故p(my|非侮辱性文档) = 3 / 24 =1 / 8
def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)#共有多少个文档，即文档的行数，根据输入数据的话是6行
    numWords = len(trainMatrix[0])#单词表的长度，基于总单词表构成的文档向量，其每一行的元素个数，去重之后的单词表长度为32故大小为32
    pAbusive = sum(trainCategory) / float(numTrainDocs)#侮辱性文档的概率
   # print numTrainDocs,numWords,pAbusive
    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])#记录第i篇侮辱性文档中共有多少个单词出现
            #print i,trainCategory[i],trainMatrix[i],sum(trainMatrix[i])
        else:
             p0Num += trainMatrix[i]#记录所有分类为非侮辱性文档中的每个词汇一共出现了多少次
             p0Denom +=sum(trainMatrix[i])#记录第i篇非侮辱性文档中共有多少个单词出现
            # print i,trainCategory[i],trainMatrix[i],sum(trainMatrix[i])
    p1Vect = log(p1Num / p1Denom) #在所有侮辱性文档中，每个单词出现的概率，取个log
    p0Vect = log(p0Num / p0Denom) #在所有非侮辱性文档中，每个单词出现的概率,取个log
    
    return p0Vect,p1Vect,pAbusive
#注意一下这里概率的计算。p1 = p (ci = 1 | w) = p(w|ci = 1) * p(ci = 1) / p(w)
#而p0的计算也要除以p(w)忽略分母，只管分子，即只考虑 p(w | ci = 1) * p(ci = 1)和 p(w|ci = 0) * p(ci = 0)的大小即可以知道属于哪一类
#那么此时取个log防止过小，则有log(p(w | ci = 1) * p(ci = 1)) = Σlog(p(wj | ci = 1)) + log(p(ci = 1))
#log(p(w | ci = 0) * p(ci = 0)) = Σlog(p(wj | ci = 0)) + log(p(ci = 0)) = Σlog(p(wj | ci = 0)) + log(1-p(ci = 1))
#从而对应了下面这个分类函数的p1和p0的计算方式，又因为在train中，已经取了log 所以求和只要单纯的向量相乘求和即可
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)
    p0 = sum(vec2Classify * p0Vec) + log(1-pClass1)
    if p1 > p0:
        return 1
    if p0 > p1:
        return 0
#构建文档词袋模型，跟最开始的setOfWords2Vec只有一个区别，那就是在词袋中，每个单词可以出现多次，set中只是记录有多少个不同的单词。
#词袋模型中开一个长度为单词表总长度的数组，并初始化为全0，然后读所有的输入进来，统计输入的向量每个单词出现的次数。
#一句话概括就是set返回的是一个01矩阵，只有2种不同的元素，而bag里面的元素不止 0 和 1 两种取值
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 thisDoc,testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)
    testEntry = ['stupid', 'love','my','to','cute','please']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print thisDoc,testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)
#接受一个大字符串，并将其解析为字符串列表
def textPrase(bigString):
    import re
    listOfTokens = re.split(r'W*',bigString)#对字符串进行处理，按空格切分，并且去除标点符号
    return [tok.lower() for tok in listOfTokens if len(tok) > 2] #去除少于两个字符的字符串，并全部转为小写
#文件解析及完整的垃圾邮件测试函数，并使用朴素贝叶斯进行交叉验证
def spamTest():
    docList =[]#将这个脑补成loadDataSet里的postingList
    classList = []#对应每个docList每行的分类
    fullText = []#构建大单词表（不去重）
    for i in range(1,26):#分别读取25个H的txt和SP的txt，实际上就是导入并解析文件
        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)#把25个H的txt和SP的txt先加入docList中，然后去重构造出大单词表    
   #注意一下这里的分类是1和0间隔出现的
    trainingSet = range(50)# 0 - 49
    testSet = []
    for i in range(10):
        randIndex = int(random.uniform(0,len(trainingSet)))#取不重复的10个数字作为测试集的下标，故训练集只有40个
        testSet.append(trainingSet[randIndex])#加入测试集
        del(trainingSet[randIndex])#删除对应的下标
    #print testSet
    trainMat = []
    trainClasses = []
    for docIndex in trainingSet:#注意这里的 trainingSet只有40个元素了
        trainMat.append(bagOfWords2VecMN(vocabList,docList[docIndex]))#构造训练集矩阵，一堆01矩阵
        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)
#统计出现次数最多的前30个单词
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)
    return sortedFreq[:30]
#feed1 feed0为两个RSS源，说明在这里访问的是RSS源，而并非一成不变的文件其中要加入去除词频最高的30个单词的预处理，
#并返回相关的单词表和对应的概率，其余跟spam()非常类似，通过移除最高词频的单词这一预处理，可以提高准确率
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'])
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(1)
        wordList = textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)
    top30Words = calcMostFreq(vocabList,fullText)
    #print top30Words
  #  print len(vocabList),vocabList
    for pairW in top30Words:
       # print len(pairW),pairW[0],pairW[1]
        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)))#取不重复的20个数字作为测试集的下标
        testSet.append(trainingSet[randIndex])#加入测试集
        del(trainingSet[randIndex])#删除对应的下标
    #print testSet
    trainMat = []
    trainClasses = []
    for docIndex in trainingSet:
        trainMat.append(bagOfWords2VecMN(vocabList,docList[docIndex]))#构造训练集矩阵一堆01矩阵
        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,p0V,p1V
#将两个RSS源作为输入，通过训练后再利用朴素贝叶斯分类，返回排名最具代表性的词汇，可以设定一个阈值，来获取这些分类之后的词汇，并按照该词汇出现
#的条件概率的高低，进行排序输出
def getTopWords(ny,sf):
    import operator
    vocabList,p0V,p1V=localWords(ny,sf)
    
    topNY=[]; topSF=[]
    for i in range(len(p0V)):
        if p0V[i] > -6.0 : topSF.append((vocabList[i],p0V[i]))
        if p1V[i] > -6.0 : topNY.append((vocabList[i],p1V[i]))
    sortedSF = sorted(topSF, key=lambda pair: pair[1], reverse=True)
    print "SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**"
    for item in sortedSF:
        print item[0]
    sortedNY = sorted(topNY, key=lambda pair: pair[1], reverse=True)
    print "NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**"
    for item in sortedNY:
        print item[0]
    print "VC**VC**VC**VC**VC**VC**VC**VC**VC**VC**VC**VC**VC**VC**VC**VC**"
    print vocabList