机器学习之四：朴素贝叶斯

1、条件概率：

$$P(A|B)=\frac {P(AB)}{P(B)}\quad$$
     可以得出：
$$P(AB)=P(A)P(B|A)=P(B)P(A|B)$$
2、全概率公式：
    设 $B_iB_j=\emptyset（i !=j）且B_1+B_2+B_3+...+b_B=\Omega$，则这样的一组事件被称为一个完备事件组，则有：
$$P(A)=P(A\Omega)=P(AB_1+AB_2+AB_3+...+AB_n)\\ =P(AB_1)+P(AB_2)+P(AB_3)+...+P(AB_n)$$
$$P(A)=P(B_1)P(A|B_1)+P(B_2)P(A|B_2)+P(B_3)P(A|B_3)\\ +...+P(B_n)P(A|B_n)$$
3、贝叶斯公式：
$$P(B_i|A)=\frac {P(AB_i)}{P(A)}\quad=\frac {P(B_i)P(A|B_i)}{\sum_j P(B_j)P(A|B_j)}\quad$$
     全概率公式中， $A$看成结果，$B_i$看成是导致结果发生的诸多原因之一，全概率公式是一个原因推导结果的过程。贝叶斯公式恰好相反，我们知道结果 $A$已经发生了，所要做的就是反过来研究造成结果发生的原因，是xx原因造成的可能性有多大，即结果推原因。
4、分类算法：
     给定训练数据集：$T=\{ (x_1,y_1),(x_2,y_2),...(x_n,y_n)\}$，由 $P(X,Y)$独立同分布产生，朴素贝叶斯法通过训练集学习联合概率分布 $P(X,Y)$，具体的学习以下先验概率及条件概率分布。
先验概率分布： $$P(Y=c_k)，k=1，2，3，。。，K$$
条件概率分布：
$$P(X=x|Y=c_k)=P(X^{(1)}=x^{(1)},...,X^{(n)}=x^{(n)}|Y=c_k),\\ k=1,2,3,...,k$$
     朴素贝叶斯对条件概率分布做了条件独立性假设，条件独立性假设等于是说用于分类的特征在类确定的条件下都是条件独立的，每个特征分量条件独立。由于这是一个较强的假设，朴素贝叶斯法也由此得名，这一假设使得贝叶斯法变得简单，但有时会牺牲一定的分类准确率。具体的，条件独立性假设是：
$$P(X=x|Y=c_k)=P(X^{(1)}=x^{(1)},...,X^{(n)}=x^{(n)}|Y=c_k) \\ =\prod_{j=1}^n P(X^{(j)}=x^{(j)}|Y=c_k)$$
     朴素贝叶斯进行分类时，对于给定的输入x，通过学习到的模型计算后验概率分布 $P(Y=c_k|X=x)$，将后验概率最大的类作为x的类输出，后验概率的计算根据贝叶斯定理进行：
$$P(Y=c_k|X=x)=\frac {P(Y=c_k,X=x)}{P(X=x)}\quad \\ =\frac {P(X=x|Y=c_k)P(Y=c_k)}{\sum_k P(X=x|Y=c_k)P(Y=c_k) }\quad \\ = \frac{P(Y=c_k)\prod_{j=1}^n P(X^{(j)}=x^{(j)}|Y=c_k)}{\sum_k P(Y=c_k) \prod_{j=1}^n P(X^{(j)}=x^{(j)}|Y=c_k)} \quad$$
     于是，朴素贝叶斯分类器可以表示为：
$$y=f(x)=arg\max_{c_k}\frac{P(Y=c_k)\prod_{j=1}^n P(X^{(j)}=x^{(j)}|Y=c_k)}{\sum_k P(Y=c_k) \prod_{j=1}^n P(X^{(j)}=x^{(j)}|Y=c_k)} \quad$$
     注意到，上式中分母对于所有的 $c_k$都是相同的，所以分类器表示为：
$$y=f(x)=arg\max_{c_k} {P(Y=c_k)\prod_{j=1}^n P(X^{(j)}=x^{(j)}|Y=c_k)}$$
     注意：如果 $P(X=x|Y=c_k)$中的某一项为0，则其联合概率的乘积也可能为0，即公式的分子为0，为了避免这种现象出现，一般情况下会将这一项初始化为1，当然为了保证概率相等，分母应对应初始化为2（这里因为是2类，所以加2，如果是k类就需要加k，术语上叫做laplace光滑, 分母加k的原因是使之满足全概率公式）。

朴素贝叶斯的优点：
　　对小规模的数据表现很好，适合多分类任务，适合增量式训练。
缺点：
　　对输入数据的表达形式很敏感。
　　
5、代码实现：

#encoding=utf-8
import numpy as np

#加载数据
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:       
        vocabSet = vocabSet | set(document) #创建并集
    vacalist=list(vocabSet)   
    return vacalist 

#根据词汇表，将每一句话转化为向量。
# 词集模型：每个词的出现与否作为一个特征
# 词袋模型：每个词出现的次数作为一个特征
def bagOfWord2VecMN(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):
    numTrainDocs = len(trainMatrix)  # 训练文本数量，即样本大小
    numWords = len(trainMatrix[0])   # 词向量大小
    pAbusive = sum(trainCategory)/float(numTrainDocs)  # 每个类的先验概率：侮辱性言论占的比例

    #1、利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率如果其中一个概率值为0 , 那么最后的乘积也为0。为降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。
    p0Num = np.ones(numWords)  # 长度为词向量大小，元素都为1的列表，分子初始化为1
    p1Num = np.ones(numWords)  #计算频数分子初始化为1
    p0Denom = 2.0
    p1Denom = 2.0         #即拉普拉斯平滑
    for i in range(numTrainDocs):
        # 如果该句话为侮辱性文字
        if trainCategory[i]==1: 
            p1Num += trainMatrix[i]  # 统计侮辱性样本点中每个词出现的次数
            p1Denom += sum(trainMatrix[i])  # 侮辱性样本点中所有词出现的总次数
        # 如果该句话为正常文字
        else:
            p0Num += trainMatrix[i]  # 统计正常性样本点中每个词出现的次数
            p0Denom += sum(trainMatrix[i]) # 正常性样本点中所有词出现的总次数

  # 2、另一个遇到的问题是下溢出，这是由于太多很小的数相乘造成的。当计算分母乘积时，由于大部分因子者3非常小， 所以程序会下溢出或者得到不正确的答案。一种解决办法是对乘积取自然对数。在代数中有ln(a*b) = ln(a)+ln(b), 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。从函数f(x)和ln[f(x)]的曲线看，就会发现它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。通过修政return前的两行代码，将上述做法用到分类器中：
    # plVect = log(plNum/plDenom)
    # p0Vect = log(p0Num/p0Denom)
    p1Vect = np.log(p1Num/p1Denom) #注意，计算条件概率，然后取对数
    p0Vect = np.log(p0Num/p0Denom) #注意，计算条件概率，然后取对数
    return p0Vect,p1Vect,pAbusive#返回各类对应特征的条件概率向量，和各类的先验概率
# 进行分类
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)#注意，计算后验概率
    p0 = sum(vec2Classify * p0Vec) + np.log(1-pClass1)#注意，计算后验概率
    if p1 > p0:
        return 1
    else:
        return 0
# 测试
def testingNB():
    listOPosts,listClasses = loadDataSet()#加载原始数据和词向量
    myVocabList = createVocabList(listOPosts) #建立去重的所有词汇列表
    trainMat = [] # 保存每句话的词向量的列表
    # 对原始数据的每句话进行迭代，得出每句话的词向量
    for postinDoc in listOPosts:
        trainMat.append(bagOfWord2VecMN(myVocabList,postinDoc))
    # 每句话的词向量和该句话的类别 (0 | 1) 进行训练
    p0V,p1V,pAb = trainNB0(trainMat,listClasses)
    #测试
    testEntry = ['love','my','dalmation']
    thisDoc = bagOfWord2VecMN(myVocabList,testEntry)
    print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)

if __name__ == '__main__':
    testingNB()