《机器学习实战》Code2-朴素贝叶斯分类

本博客是学习《机器学习实战》例子后，自己对书上的例子代码总结的个人理解。在代码必要的地方，添加了注解。博客书写的目的是，方便后续的复习。

---

分类器往往会发生错误，所以，往往需要分类器给出一个最优的类别猜测的结果，同时给出这个猜测的概率值。而朴素贝叶斯分类正好可以解决这个问题。

贝叶斯分类的核心思想是：对于一个数据点（x，y），选择高概率对应的类别，也就是选择该概率正确的决策。具体过程，使用如下准则进行类别判断。

1. 如果P1（x，y）>P2（x，y）,那么类别是1；
2. 如果P1（x，y）<P2（x，y）,那么类别是2；

朴素贝叶斯的优点是，认为所有的影响因素认为是独立同分布的，并且他们各自对结果的影响都是一样的。这样会大大减少计算的复杂度。需要的样本个数也从N^1000下降到N*1000（如果每个特征需要N个样本，假设有1000个样本）。而且，在数据少的情况下，仍然有效，可以处理多分类的问题。

缺点，也同样是因为他的强假设，这样会导致精确性下降。比如下面邮件分类的问题，没能考虑到不同单词的影响权重IDF大小的区别，只使用了词频IF。

但是，总的来说，利大于弊，效果还是不错的。

---

机器学习实战中 Bayes例子 1

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from numpy import *

#BAYES book example 4-1   贝叶斯例子入门
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):
    #set: class set([iterable])  初始化必须是个列表，如果是字符串‘123’，那么等价为‘1’‘2’‘3’
    vocabSet = set([])  #create empty set
    for document in dataSet:
        vocabSet = vocabSet | set(document) #union of the two sets 并集
    return list(vocabSet)

def setOfWords2Vec(vocabList, inputSet):
    #[0] * length
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            #  集合操作 ： set.index(key)
            returnVec[vocabList.index(word)] = 1
        else: print "the word: %s is not in my Vocabulary!" % word
    return returnVec

#参数：文档矩阵，也就是setOfWords2Vec的结果--》词向量[0,1,      ]、文档的类别列表
def trainNB0(trainMatrix,trainCategory):
    #numTrainDocs 几篇文档
    numTrainDocs = len(trainMatrix)
    # 字典大小，字典不同的单词个数
    numWords = len(trainMatrix[0])
    # print 'numWords',numWords
    # p(c1)
    pAbusive = sum(trainCategory)/float(numTrainDocs)

    #贝叶斯法，处理平滑
    #p0Num用来记录，文档类别是0时候，每种单词一共出现的次数
    # p0Denom用来记录，当文档类别是0时候，所有文档的总长度
    p0Num = ones(numWords); p1Num = ones(numWords)
    # 每一个特征上面的值（词向量中具体一维度值），只有0,1（有和没有之分）两值
    p0Denom = 2.0; p1Denom = 2.0

    #对于第i篇文档
    for i in range(numTrainDocs):
        #如果是侮辱性训练文档
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
            # print 'p1Num/p1Denom',float(sum(trainMatrix[i])/sum(trainMatrix[i]))
            # print i, p1Num,p1Denom
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])

    #防止下溢  log(  P(x1|c1)*P(x2|c1)  )=log( P(x1|c1) )  +  log( P(x2|c1) )
    p1Vect = log(p1Num/p1Denom)          #change to log()
    p0Vect = log(p0Num/p0Denom)          #change to log()
    return p0Vect,p1Vect,pAbusive

#参数：测试文档的单词向量，P(x|c1),P(x|c0),P(c1)
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    #vec2Classify * p1Vec         为了找出该测试文档向量中所有出现的词的log（P(x|c1))
    # sum(vec2Classify * p1Vec)   sum(  log（P(xi|c1)) )
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else: 
        return 0

#词袋模型  袋子中，同一个单词可以出现多次
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

def tstingNB():
    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(bagOfWords2VecMN(myVocabList, testEntry))
    print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)

    testEntry = ['stupid', 'garbage']
    thisDoc = array(bagOfWords2VecMN(myVocabList, testEntry))
    print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)

# tstingNB()

---

机器学习实战中 Bayes例子 2------垃圾邮箱分类

#BAYES book example 4-2
#邮件的  贝叶斯分类

#文本进行分割
def textParse(bigString):    #input is big string, #output is word list
    import re
    #以非数字和字母的符号为分隔符
    listOfTokens = re.split(r'\W*', bigString)
    #邮件中，经常有地址，在进行分割的时候，会产生没用的字符串  比如 cn py m等。这些字符串常常小于3的
    # 长度，对他们进行剔除操作。
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]  #词袋模型中，单词只接受小写


#有50封电子邮件，并不是很多，其中随机选择10封当做是测试邮件
def spamTest():
    #交叉验证准确率具有随机性，可以多次进行交叉测试后，求出平均值当做是整个分类器的错误平均值
    avgerrorrate=0.0
    for testTime in range(100):
        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)  # create vocabulary
        # range 返回一个列表
        trainingSet = range(50);
        testSet = []  # create test set
        #print 'trainingSet', trainingSet

        # 可借鉴random函数的使用技巧
        for i in range(10):
            randIndex = int(random.uniform(0, len(trainingSet)))
            testSet.append(trainingSet[randIndex])
            del (trainingSet[randIndex])
           # print i, len(trainingSet)

        trainMat = [];
        trainClasses = []
        for docIndex in trainingSet:  # train the classifier (get probs) trainNB0
            trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
            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)
        avgerrorrate+=float(errorCount) / len(testSet)

    avgerrorrate=avgerrorrate/100.0
    print 'avgerrorrate',avgerrorrate


#spamTest()

---

编程get到的几个key point：

1. 对于分类问题，往往概率的计算方式比硬规则更有效。
2. 编程语言实现贝叶斯分类需要考虑很多实际的因素，下溢就是其中一个很重要的问题。可以通过对概率取对数来解决。
3. 词袋模型解决文档分类，比词集模型效率有所提高。