朴素贝叶斯算法 python 实现

转载自：https://github.com/apachecn/AiLearning/blob/master/docs/ml/4.%E6%9C%B4%E7%B4%A0%E8%B4%9D%E5%8F%B6%E6%96%AF.md 

应用贝叶斯准则:

使用上面这些定义，可以定义贝叶斯分类准则为:

• 如果 P(c1|x, y) > P(c2|x, y), 那么属于类别 c1;
• 如果 P(c2|x, y) > P(c1|x, y), 那么属于类别 c2.

在文档分类中，整个文档（如一封电子邮件）是实例，而电子邮件中的某些元素则构成特征。我们可以观察文档中出现的词，并把每个词作为一个特征，而每个词的出现或者不出现作为该特征的值，这样得到的特征数目就会跟词汇表中的词的数目一样多。

我们假设特征之间 相互独立 。所谓 独立(independence) 指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其他单词相邻没有关系，比如说，“我们”中的“我”和“们”出现的概率与这两个字相邻没有任何关系。这个假设正是朴素贝叶斯分类器中 朴素(naive) 一词的含义。朴素贝叶斯分类器中的另一个假设是，每个特征同等重要。

Note: 朴素贝叶斯分类器通常有两种实现方式: 一种基于伯努利模型实现，一种基于多项式模型实现。这里采用前一种实现方式。该实现方式中并不考虑词在文档中出现的次数，只考虑出不出现，因此在这个意义上相当于假设词是等权重的。

项目概述

构建一个快速过滤器来屏蔽在线社区留言板上的侮辱性言论。如果某条留言使用了负面或者侮辱性的语言，那么就将该留言标识为内容不当。对此问题建立两个类别: 侮辱类和非侮辱类，使用 1 和 0 分别表示。 

构建数据集

def loadDataset():
    """
    创建数据集
    :return: 单词列表postingList, 所属类别classVec
    """ 
    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','worhless','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

从文本中构建词向量

（1） 构建词表

def createVocabList(dataSet):
    """
    获取所有单词的集合
    :param dataSet: 数据集
    :return: 所有单词的集合(即不含重复元素的单词列表)
    """
    vocabSet = set([])  #构建空集合
    for document in dataSet:
        # 操作符，用于求两个集合的并集
        vocabSet = vocabSet | set(document)
    return list(vocabSet)

（2） 构建词向量

def setOfWords2Vec(vocabList,inputSet):  #输入的是此表和要构建的文档
    """
    遍历查看该单词是否出现，出现该单词则将该单词置1
    :param vocabList: 所有单词集合列表
    :param inputSet: 输入数据集
    :return: 匹配列表[0,1,0,1...]，其中 1与0 表示词汇表中的单词是否出现在输入的数据集中
    """
    # 创建一个和词汇表等长的向量，并将其元素都设置为0 
    returnVec = [0] * len(vocabList)
    #遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值设为1
    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  

（3）检查函数执行情况，检查词表，不出现重复单词，需要的话，可以对其进行排序。

listPosts,listClasses = loadDataset()
print("原始的训练数据集是：
",listPosts,'
')
myVocabList = createVocabList(listPosts)
print("根据此数据集构建的词表是：
",myVocabList,'
')

　　输出结果：

原始的训练数据集是：
 [['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', 'worhless', 'garbage'], 
['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'], ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']] 

根据此数据集构建的词表是：
 ['posting', 'park', 'my', 'stop', 'worhless', 'I', 'buying', 'please', 'steak', 'mr', 'how', 'food', 'help', 'is', 
'problems', 'not', 'love', 'worthless', 'cute', 'ate', 'quit', 'has', 'him', 'dog', 'flea', 'maybe', 'to', 'take',
 'dalmation', 'stupid', 'licks', 'so', 'garbage']

(4) 检查函数有效性。例如：myVocabList 中索引为 2 的元素是什么单词？ 应该是是 help 。该单词在第一篇文档中出现了，现在检查一下看看它是否出现在第四篇文档中。

print(setOfWords2Vec(myVocabList,listPosts[0]))
print(setOfWords2Vec(myVocabList,listPosts[3]))

　　输出结果：

[0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1]

训练算法：从词向量计算概率

现在已经知道了一个词是否出现在一篇文档中，也知道该文档所属的类别。 接下来我们重写贝叶斯准则，将之前的 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) 来计算上述概率，这样就极大地简化了计算的过程。

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

另一个遇到的问题是下溢出，这是由于太多很小的数相乘造成的。当计算乘积 p(w0|ci) * p(w1|ci) * p(w2|ci)... p(wn|ci) 时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。（用 Python 尝试相乘许多很小的数，最后四舍五入后会得到 0）。一种解决办法是对乘积取自然对数。在代数中有 ln(a * b) = ln(a) + ln(b), 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。

1.4.1  朴素贝叶斯分类器训练函数

def trainNB0(trainMatrix,trainCategory):
    """
    训练数据原版
    :param trainMatrix: 文件单词矩阵 [[1,0,1,1,1....],[],[]...]
    :param trainCategory: 文件对应的类别[0,1,1,0....]，列表长度等于单词矩阵数，
    其中的1代表对应的文件是侮辱性文件，0代表不是侮辱性矩阵
    :return:
    """
    #文件数
    numTrainDocs = len(trainMatrix)
    #单词数
    numWords = len(trainMatrix[0])
    # 侮辱性文件的出现概率，即trainCategory中所有的1的个数
    # 代表的就是多少个侮辱性文件，与文件的总数相除就得到了侮辱性文件的出现概率
    pAbusive = 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 += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # 类别1，即侮辱性文档的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表
    # 即 在1类别下，每个单词出现的概率 
    p1Vect = np.log(p1Num / p1Denom)
    # 类别0，即正常文档的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表
    # 即 在0类别下，每个单词出现的概率
    p0Vect = np.log(p0Num / p0Denom)
    return p1Vect,p0Vect,pAbusive　

1.4.2  朴素贝叶斯分类函数

def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    """
    使用算法：
        # 将乘法转换为加法
        乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
        加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
    :param vec2Classify: 待测数据[0,1,1,1,1...]，即要分类的向量
    :param p0Vec: 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
    :param p1Vec: 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
    :param pClass1: 类别1，侮辱性文件的出现概率
    :return: 类别1 or 0
    """
    # 计算公式  log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
    # 大家可能会发现，上面的计算公式，没有除以贝叶斯准则的公式的分母，也就是 P(w) （P(w) 指的是此文档在所有的文档中出现的概率）就进行概率大小的比较了，
    # 因为 P(w) 针对的是包含侮辱和非侮辱的全部文档，所以 P(w) 是相同的。
    # 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。
    # 我的理解是：这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
    p1 = sum(vec2Classify*p1Vec) + np.log(pClass1)  # P(w|c1) * P(c1) ，即贝叶斯准则的分子 
    p0 = sum(vec2Classify*p0Vec) + np.log(1.0 - pClass1)  # P(w|c0) * P(c0) ，即贝叶斯准则的分子
    if p1 > p0:
        return 1 
    else:
        return 0 

1.4.3  测试朴素贝叶斯算法

　　

def testingNB():
    """
    测试朴素贝叶斯算法
    """
    # 1. 加载数据集
    listPosts,listClasses = loadDataset()
    #2. 创建单词集合
    myVocabList = createVocabList(listPosts)
    #3.计算单词是否出现并创建数据矩阵
    trainMat = []
    for postinDoc in listPosts:
        trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
    #4.训练数据
    p0V,p1V,pAb = trainNB0(np.array(trainMat),np.array(listClasses))
    #5.测试数据
    testEntry = ['love','my','dalmation']
    thisDoc = np.array(setOfWords2Vec(myVocabList,testEntry))
    print(testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))

　输出结果：

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