刻意练习：机器学习实战 --Task02朴素贝叶斯

刻意练习：机器学习实战 --Task02朴素贝叶斯
一.朴素贝叶斯 概述
贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。本章首先介绍贝叶斯分类算法的基础——贝叶斯定理。最后，我们通过实例来讨论贝叶斯分类的中最简单的一种: 朴素贝叶斯分类。
对于分类问题，其实谁都不会陌生，日常生活中我们每天都进行着分类过程。例如，当你看到一个人，你的脑子下意识判断他是学生还是社会上的人；你可能经常会走在路上对身旁的朋友说“这个人一看就很有钱”之类的话，其实这就是一种分类操作。
既然是贝叶斯分类算法，那么分类的数学描述又是什么呢？
从数学角度来说，分类问题可做如下定义：
已知集合
和
，确定映射规则y = f(x)。其中C叫做类别集合，其中每一个元素是一个类别，而I叫做项集合（特征集合），其中每一个元素是一个待分类项，f叫做分类器。分类算法的任务就是构造分类器f。
分类算法的内容是要求给定特征，让我们得出类别，这也是所有分类问题的关键。那么如何由指定特征，得到我们最终的类别，也是我们下面要讲的，每一个不同的分类算法，对应着不同的核心思想。
二.朴素贝叶斯分类所运用的思想
那么既然是朴素贝叶斯分类算法，它的核心算法又是什么呢？
是下面这个贝叶斯公式：

换个表达形式就会明朗很多，如下：

我们最终求的p(类别|特征)即可！就相当于完成了我们的任务。
三.代码实现
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']]
    #类别标签向量(0为侮辱性，1为非侮辱性)
    classVec = [0,1,0,1,0,1]                                                                   #类别标签向量，1代表侮辱性词汇，0代表不是
    return postingList,classVec
def createVocabList(dataSet):
    """
    将切分的实验样本词条整理成不重复的词条列表
    - - - -
    dataSet - 样本数据集
    """
    #创建一个空集
    vocabSet = set([])
    for document in dataSet: 
        #取并集              
        vocabSet = vocabSet | set(document) 
    return list(vocabSet)
def setOfWords2Vec(vocabList, inputSet):
    """
    根据词汇表，将inputSet向量化（变为0和1组成的向量）
    - - - -
    vocabList - 词汇表
    inputSet - 切分的词条列表
    """
    returnVec = [0] * len(vocabList)
    for word in inputSet:    
        #如果词条存在于词汇表中，则令对应位置为1
        if word in vocabList: 
            returnVec[vocabList.index(word)] = 1
        else: print("the word: %s is not in my Vocabulary!" % word)
    return returnVec

我们逐个解释三个函数的意思
def loadDataSet()
就是创建实验样本，并给出每个样本是带有侮辱性词汇还是没有带有侮辱性词汇带有的用1标记，反之用0标记，把标记存入classVec中。
def createVocabList(dataSet)
当我们要统计所有词条的时候，我们要把相同的词条算作一种词条，这也是显然的，我们通过对数据表每一列与下一列取并集的方式剔除了相同的词条。得到了最终的词汇表。
def setOfWords2Vec(vocabList, inputSet)
setOfWords2Vec函数使listOPosts中的句子由myVocabList来表示，根据词汇表，将inputSet向量化（变为0和1组成的向量），还有就是setOfWords2Vec函数使listOPosts中的句子由myVocabList来表示，比如listOPosts[0]中有help这个单词，那么myVocabList[2]就是1。而trianMat就是listOPosts中的六句话全部用myVocabList来表示。
2.训练算法：从词向量计算概率
现在已经知道了一个词是否出现在一篇文档中，也知道该文档所属的类别。接下来我们重写贝叶斯准则，将之前的 x, y 替换为 w. 粗体的 w 表示这是一个向量，即它由多个值组成。在这个例子中，数值个数与词汇表中的词个数相同。

我们使用上述公式，对每个类计算该值，然后比较这两个概率值的大小。
问: 上述代码实现中，为什么没有计算P(w)？
答：根据上述公式可知，我们右边的式子等同于左边的式子，由于对于每个ci，P(w)是固定的。并且我们只需要比较左边式子值的大小来决策分类，那么我们就可以简化为通过比较右边分子值得大小来做决策分类。
首先可以通过类别 i (侮辱性留言或者非侮辱性留言)中的文档数除以总的文档数来计算概率 p(ci) 。接下来计算 p(w | ci) ，这里就要用到朴素贝叶斯假设。如果将 w 展开为一个个独立特征，那么就可以将上述概率写作 p(w0, w1, w2…wn | ci) 。这里假设所有词都互相独立，该假设也称作条件独立性假设（例如 A 和 B 两个人抛骰子，概率是互不影响的，也就是相互独立的，A 抛 2点的同时 B 抛 3 点的概率就是 1/6 * 1/6），它意味着可以使用 p(w0 | ci)p(w1 | ci)p(w2 | ci)…p(wn | ci) 来计算上述概率，这样就极大地简化了计算的过程。

import numpy as np
def trainNB0(trainMatrix,trainCategory):
    """
    分类器训练函数
    - - - -
    trainMatrix - 训练文档矩阵
    trainCategory - 训练类别标签向量，即classVec
    """
    #训练的文档数目
    numTrainDocs =len(trainMatrix)
    #词条数
    numWords = len(trainMatrix[0])
    #文档属于侮辱类的概率
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    #初始化概率
    p0Num = np.zeros(numWords)
    p1Num = np.zeros(numWords)
    p0Denom = 0.0
    p1Denom = 0.0
    for i in range(numTrainDocs):
        #统计属于侮辱类的条件概率所需的数据，即P(wi|1)
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        #统计属于非侮辱类的条件概率所需的数据，即P(wi|0)
        else:       
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    #对每个元素做除法
    p1Vect = p1Num/p1Denom
    p0Vect = p0Num/p0Denom 
    return p0Vect,p1Vect,pAbusive

在利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算 p(w0|1) * p(w1|1) * p(w2|1)。如果其中一个概率值为 0，那么最后的乘积也为 0。为降低这种影响，可以将所有词的出现数初始化为 1，并将分母初始化为 2 （取1 或 2 的目的主要是为了保证分子和分母不为0，大家可以根据业务需求进行更改）。

p0Num = np.ones(numWords)
    p1Num = np.ones(numWords)
    p0Denom = 2.0
    p1Denom = 2.0

另一个遇到的问题是下溢出，这是由于太多很小的数相乘造成的。当计算乘积 p(w0|ci) * p(w1|ci) * p(w2|ci)… p(wn|ci) 时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。（用 Python 尝试相乘许多很小的数，最后四舍五入后会得到 0）。一种解决办法是对乘积取自然对数。

p1Vect = np.log(p1Num/p1Denom)
    p0Vect = np.log(p0Num/p0Denom) 

在代数中有 ln(a * b) = ln(a) + ln(b), 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。
最后分类和测试函数如下：

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    """
    朴素贝叶斯分类器分类函数
    - - - -
    vec2Classify - 待分类的词条数组
    p0Vec - 侮辱类的条件概率数组
    p1Vec -非侮辱类的条件概率数组
    pClass1 - 文档属于侮辱类的概率
    """
    p1 = np.sum(vec2Classify * p1Vec) + np.log(pClass1)
    p0 = np.sum(vec2Classify * p0Vec) + np.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(np.array(trainMat),np.array(listClasses))
    #测试样本1
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
    print (testEntry,'classified as:' ,classifyNB(thisDoc,p0V,p1V,pAb))
    #测试样本2
    testEntry = ['stupid', 'garbage']                                       
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
    print (testEntry,'classified as:' ,classifyNB(thisDoc,p0V,p1V,pAb)) 

if __name__ == '__main__':
    testingNB()
      

最后我们得到结果：

['love', 'my', 'dalmation'] classified as: 0
['stupid', 'garbage'] classified as: 1

小结：
贝叶斯估计其实是涉及到了我们数理统计的知识，虽然概念我们已经理解透彻，但是运用到数据处理上还有所欠缺，尤其是对与def setOfWords2Vec(vocabList, inputSet)这个函数的理解，所以今后一定要多多联系。