【读书笔记】 机器学习实战-4.7节 朴素贝叶斯 个人广告倾向

机器学习实战

朴素贝叶斯分类器 分析个人广告倾向

#!/usr/bin/python
# -*- coding: utf-8 -*-
from numpy import *
import feedparser

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  # index()函数
        else:
            print"the word %s is not in my Vocabulary!" %word
    return returnVec

# 词袋模型
def bagOfWords2VecMN(vocabList, inputSet):  # 输入：词汇表 输入文档
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec


#训练函数：
def trainNB0(trainMatrix, trainCategory):  # naive bayes 输入：训练文档矩阵  训练文档类别
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory)/float(numTrainDocs)   # 计算p(Ci) pabusive:侮辱文档概率，   1-pabusive ：正常文档概率
    p0Num = ones(numWords); p1Num = ones(numWords)      # 分别统计各类别单词出现的次数 change to ones()
    p0Denom = 2.0; p1Denom = 2.0
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]                     # numpy.array的数组运算
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = log(p1Num/p1Denom)                         # 计算p(Wj | Ci) ; change to log(): 防止下溢出
    p0Vect = log(p0Num/p0Denom)
    return p0Vect,p1Vect,pAbusive

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):   # 输入：需分类的向量；P(Wj | C0)向量；P(Wj | C1)向量；P(C1)
    p1 = sum(vec2Classify* p1Vec)+log(pClass1)          # SUM(log(P(Wj|Ci))) + log(P(Ci))
    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)
    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)

# 统计所有词汇词频，返回词频前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]

def localWords(feed1,feed0):
    import feedparser   # RSS程序库
    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.extend(wordList)
        classList.append(1)  # 类别1
        wordList = textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)  # 类别0
    vocabList = createVocabList(docList)            # 创建词汇列表
    top30Words = calcMostFreq(vocabList,fullText)   # 获取词频前30的词汇
    for pairW in top30Words:
        if pairW[0] in vocabList:
            vocabList.remove(pairW[0])              # 移除词频前30的词汇
    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(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 'the error rate is: ',float(errorCount)/len(testSet)
    return vocabList,p0V,p1V

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]


ny = feedparser.parse('http://newyork.craigslist.org/stp/index.rss')
sf = feedparser.parse('http://sfbay.craigslist.org/stp/index.rss')
getTopWords(ny,sf)
#vocabList,pSF,pNY = localWords(ny,sf)

#spamTest()
#testingNB()
#listOPosts,listClasses = loadDataSet()
#myVocabList = createVocabList(listOPosts)
#trainMat = []
#for postinDoc in listOPosts:
#   trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
#p0V,p1V,pAb = trainNB0(trainMat,listClasses)
pass