利用朴素贝叶斯模型进行文档分类

       朴素贝叶斯模型进行分类的思路很简单，就是待分类的对象属于哪一类的概率大，就认为它属于相应的类别。

朴素贝叶斯分类模型的公式化描述如下：

$$p(c_i|x,y) = \dfrac{p(x,y|c_i)p(c_i)}{p(x)}$$

根据这一准则，可以定义贝叶斯分类准则为：
       如果 $p(c_1|x,y) > p(c_2|x,y)$ ，那么属于类别1。
       如果 $p(c_1|x,y) < p(c_2|x,y)$ ，那么属于类别2。

       由于对象的后验概率无法直接求出，只能借助贝叶斯公式进行求取，也就是利用上面的公式，等价于比较$p(x,y|c_1)p(c_1) 和 p(x,y|c_2)p(c_2)$的大小。

下面以文本分类的例子介绍贝叶斯分类算法的具体使用流程：

-1 准备数据：从文本中构建词向量
       我们把文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现在所有文档中的所有单词，再决定将哪些词纳入词汇表或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。

-2 训练算法： 从词向量计算概率
       假设词向量用字母$w=(w_1,w_2,...,w_n)$表示，则通过贝叶斯公式计算其属于类别的后验概率：

$$p(c_i|w) = \dfrac{p(w|c_i)p(c_i)}{p(w)}$$

       在计算$p(w|c_i)$的时候需要用到朴素贝叶斯的假设，即$w$的每个特征都是独立的，这就意味着可以使用$p(w_1|c_i)p(w_2|c_i)...p(w_n|c_i)$来计算上述的概率。

-3 测试算法
       使用测试文档进行测试，计算分类器的分类正确率。

下面是一个简单的实现代码：

# -*- coding:utf-8 -*-
__author__ = 'Microcosm'
'''
利用朴素贝叶斯模型进行文档分类
'''
import numpy as np


class Bayes:
    def loadDataSet(self):
        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(self,dataSet):
        vocabSet = set([])
        for element in dataSet:
            vocabSet = vocabSet | set(element)   # 集合求并集

        return list(vocabSet)

    def setOfWords2Vec(self,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 bagOfWords2VecMN(self,vocabList, inputSet):  # 构建词袋模型，每个词可以出现多次
        returnVec = [0] * len(vocabList)
        for word in inputSet:
            if word in vocabList:
                returnVec[vocabList.index(word)] += 1
        return returnVec

    def trainNB(self,trainMatrix, trainCategory):
        numTrainDocs = len(trainMatrix)
        numWords = len(trainMatrix[0])
        pAbusive = np.sum(trainCategory)/float(numTrainDocs)
        p0Num = np.ones(numWords)
        p1Num = np.ones(numWords)   # 防止为零的概率出现
        p0Denom = 2.0
        p1Denom = 2.0
        for i in range(numTrainDocs):
            if trainCategory[i] == 1:
                p1Num += trainMatrix[i]
                p1Denom += np.sum(trainMatrix[i])
            else:
                p0Num += trainMatrix[i]
                p0Denom += np.sum(trainMatrix[i])
        p1Vect = np.log(p1Num/p1Denom)
        p0Vect = np.log(p0Num/p0Denom)
        return p0Vect,p1Vect,pAbusive

    def classifyNB(self,vec2classify, p0Vec, p1Vec, pClass1):
        p1 = np.sum(vec2classify * p1Vec) + np.log(pClass1)
        p0 = np.sum(vec2classify * p0Vec) + np.log(1 - pClass1)
        if p1 > p0:
            return 1
        else:
            return 0

    def testingNB(self):
        listOposts,listClasses = self.loadDataSet()
        myVocabList = self.createVocabList(listOposts)
        trainMat = []
        for postinDoc in listOposts:
             trainMat.append(self.setOfWords2Vec(myVocabList,postinDoc))

        p0V,p1V,pAb = self.trainNB(trainMat,listClasses)
        testEntry = ['love', 'my', 'dalmation','stupid','stupid','stupid','stupid']
        thisDoc = np.array(self.setOfWords2Vec(myVocabList, testEntry))
        print "词集模型",testEntry, 'classified as: ', self.classifyNB(thisDoc,p0V,p1V,pAb)
        thisDoc = np.array(self.bagOfWords2VecMN(myVocabList, testEntry))
        print "词袋模型",testEntry, 'classified as: ', self.classifyNB(thisDoc,p0V,p1V,pAb)
        testEntry = ['love', 'my', 'dalmation','love', 'my', 'dalmation','stupid', 'garbage','sb']
        thisDoc = np.array(self.setOfWords2Vec(myVocabList, testEntry))
        print "词集模型",testEntry, 'classified as: ', self.classifyNB(thisDoc,p0V,p1V,pAb)
        thisDoc = np.array(self.bagOfWords2VecMN(myVocabList, testEntry))
        print "词袋模型",testEntry, 'classified as: ', self.classifyNB(thisDoc, p0V, p1V, pAb),


if __name__ == '__main__':
   bayes = Bayes()
   bayes.testingNB()

有三点需要注意:
1. 计算概率的时候为了防止0的出现，通常让分子加1,分母加2，这种方式称为laplace平滑。
2. 通常计算的是概率的对数，可以防止太多很小的数相乘造成的下溢出。
3. 代码中介绍了两种词向量模型，一种是伯努利模型，只考虑词是否出现，不考虑出现的次数。另一种是多项式模型，考虑了词出现的次数。这两种模型有时会导致不同的分类结果结果。

上述程序的运行结果为：
词集模型 [‘love’, ‘my’, ‘dalmation’, ‘stupid’, ‘stupid’, ‘stupid’, ‘stupid’] classified as: 0
词袋模型 [‘love’, ‘my’, ‘dalmation’, ‘stupid’, ‘stupid’, ‘stupid’, ‘stupid’] classified as: 1
the word: sb is not in my Vocabulary!
词集模型 [‘love’, ‘my’, ‘dalmation’, ‘love’, ‘my’, ‘dalmation’, ‘stupid’, ‘garbage’, ‘sb’] classified as: 1
词袋模型 [‘love’, ‘my’, ‘dalmation’, ‘love’, ‘my’, ‘dalmation’, ‘stupid’, ‘garbage’, ‘sb’] classified as: 0