机器学习—朴素贝叶斯及其优化

机器学习—朴素贝叶斯

本文代码均来自《机器学习实战》

朴素贝叶斯的两个基本假设：

1. 独立：一个特征出现的可能性和与它和其他特征相邻没有关系
2. 每个特征同等重要

这段代码是以文本分类为例介绍朴素贝叶斯算法的

要从文本中获取特征，需要先拆分文本。这里的特征是来自文本的词条（token），一个词条是字符的任意组合。可以把词条想象为单词，也可以使用非单词词条，如URL、IP地址或者任意其他字符串。然后将一个文本片段表示为一个词向量，其中值为1表示词条出现，0表示词条未出现。

以在线社区的留言板为例，为了不影响社区的发展，我们要屏蔽侮辱性的言论，所以要构建一个快速过滤器，如果某条留言使用了负面或者侮辱性的言语，那么就将该留言表示为内容不当。过滤这类内容是一个很常见的需求。对此问题建立两个类别：侮辱类和非侮辱类，使用1和0分别表示。
————————————————
版权声明：本文为CSDN博主「WordZzzz」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u011475210/article/details/77922565

'''
Created on Oct 19, 2010

@author: Peter
'''
#和其他复杂模型不一样，朴素贝叶斯的思想和操作比较简单，它一般是内嵌在处理具体问题的函数中的，而不像神经网络模型或者决策树等等有自己独立的方法
from numpy import *
#训练集
def loadDataSet():
    #features
    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']]
    #labels
    classVec = [0,1,0,1,0,1]    #1 is abusive（虐待）, 0 not
    return postingList,classVec
                 
def createVocabList(dataSet):
    #将data中出现的所有词放在一个列表中
    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):
    #返回训练集中的哪些词在这个样本中出现了
    #vocabList是词库，inputSet是输入的该条样本
    returnVec = [0]*len(vocabList)#创建一个所含元素都为0的向量
    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 trainNB0(trainMatrix,trainCategory):#朴素贝叶斯分类器训练函数
    #trainMatrix是训练集data，trainCategory是训练集样本的labels
    numTrainDocs = len(trainMatrix)#训练集样本个数
    numWords = len(trainMatrix[0])#训练集中单词一共有多少个
    pAbusive = sum(trainCategory)/float(numTrainDocs)#返回的结果是“训练集中样本有多少百分比是侮辱性文档”,即P(c)
    #初始化概率的分子变量
    p0Num = ones(numWords)
    p1Num = ones(numWords)      
    #初始化概率的分母变量
    p0Denom = 2.0; p1Denom = 2.0 
    """
    为什么这里初始化的时候是2.0而不是0呢？因为我们在这里用到了拉普拉斯平滑这一改进技术
    由于P(C|w)=P(w|c)*P(c)/P(w)，这里的P(w|c)是通过p0Vect和p1Vect得到的，但是会发生这样一种情况：
    就是在原本的训练集中，某个词没有出现过label为ci的某个类，但是在实际上的文本中却出现了，但是如果我们用上面的式子计算的话，得到概率却是0（因为P（w|c)是0），
    但其实它出现的概率可能不是0，而只是比较小而已；或者更严重的，我们的样本数量和典型性受限，不能代表总体特征。
    这种情况下，就需要我们使用拉普拉斯平滑这一技术，这是经常使用了朴素贝叶斯方法上的技术：
    具体操作上就是：将所有词的出现数初始化为1，并将分母初始化为2
    更详细的内容可以见下面的分析
    """    
    #遍历所有data                   
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]#p1Num统计总体中的哪些词出现在了被标记为侮辱性的文档中，它不是一个数，而是一个向量，是侮辱性文档中字符出现的叠加
            #例如[0,1,2,0],0表示这个词从来没有在侮辱性文档中出现过，而1,2,3分别表示他们出现了1次、2、3次
            p1Denom += sum(trainMatrix[i])#侮辱性文档的总词数
        else:
            p0Num += trainMatrix[i]#同上，只不过这次操作的是非侮辱性的那些
            p0Denom += sum(trainMatrix[i])
    #对每个元素做除法求概率
    p1Vect = log(p1Num/p1Denom)          #change to log()，原本的朴素贝叶斯模型中这里应该是不带log的，它表示的是P(w|ci),这里是改进后的模型
    #注意，p1Vect是一个数组，每个元素表示已知是侮辱性文档的前提下这个词出现的概率，就是P(wj|ci)
    p0Vect = log(p0Num/p0Denom)          #change to log()
    return p0Vect,p1Vect,pAbusive#返回P(w|c)和P(c)
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #p1是判断为侮辱性文档的概率，即P(C|w)=P(w|c)*P(c)/P(w),由于分母都是一样的P(w),所以这里只计算分子
    #按元素相乘再相加，为什么是加上log(pClass1),不应该是P(w|c)*P(c)吗，因为这里我们改进了，都把他们做了log变换，所以原来的乘法自然也变成加法了
    """
    1. 为什么要改进成log:
    小数连乘会造成所得值几乎等于 0 的结果，从而无法比较大小。鉴于此，往往在实际运算中，会借助 log 函数
    因为概率处于[0,1]区间，由log的函数图像可知，这样改造之后不会改变增减性，但是会起到特征放大的作用
    2.为什么没计算P（w):
    贝叶斯式子的那个分母在比较的时候根本不需要，就不算了
    """
    """
    *(星号)运算的作用
    对数组执行对应位置相乘
    对矩阵执行矩阵乘法运算
    """
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else: 
        return 0
def testingNB():
    #一个测试用的例子，也是告诉我们这些函数的正确用法
    listOPosts,listClasses = loadDataSet()#加载data和labels
    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(setOfWords2Vec(myVocabList, testEntry))#将要判断的样本处理一哈
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testingNB()
词集模型与词袋模型
上面的代码有一个地方其实和我们的预想是有些不太一样的，就是它在统计总体中的哪些词出现在了样本中的时候只统计了0（没出现）和1（出现过），而不考虑出现的次数，这种模型被称为“词集模型”。相应的，统计出现次数的模型被称为词袋模型，这两种不好说哪种更好，但是他们之间的转换也是很容易的，对于上面的代码，我们只需要修改一个函数就好了：

词集模型的代码：

def setOfWords2Vec(vocabList, inputSet):
    #返回训练集中的哪些词在这个样本中出现了
    #vocabList是词库，inputSet是输入的该条样本
    returnVec = [0]*len(vocabList)#创建一个所含元素都为0的向量
    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(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

词集模型与词袋模型

上面的代码有一个地方其实和我们的预想是有些不太一样的，就是它在统计总体中的哪些词出现在了样本中的时候只统计了0（没出现）和1（出现过），而不考虑出现的次数，这种模型被称为“词集模型”。相应的，统计出现次数的模型被称为词袋模型，这两种不好说哪种更好，但是他们之间的转换也是很容易的，对于上面的代码，我们只需要修改一个函数就好了：

词集模型的代码：

def setOfWords2Vec(vocabList, inputSet):
    #返回训练集中的哪些词在这个样本中出现了
    #vocabList是词库，inputSet是输入的该条样本
    returnVec = [0]*len(vocabList)#创建一个所含元素都为0的向量
    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(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

对朴素贝叶斯方法的优化

其实上文中，我们已经进行并说明了一项优化了，就是将原有的概率变为对数，由于对数化了之后在[0.1]上值的变化更大了，这样就消除了概率计算下溢的风险。log和原曲线增减性相同，且在同样的位置取到极值点，所以这样的替换是可行的。

下面我们说明另一项优化：拉普拉斯平滑，这部分来源于博客https://cuijiahua.com/blog/2017/11/ml_5_bayes_2.html。

在计算的时候已经出现了概率为0的情况。如果新实例文本，包含这种概率为0的分词，那么最终的文本属于某个类别的概率也就是0了。显然，这样是不合理的，为了降低这种影响，可以将所有词的出现数初始化为1，并将分母初始化为2。这种做法就叫做拉普拉斯平滑(Laplace Smoothing)又被称为加1平滑，是比较常用的平滑方法，它就是为了解决0概率问题。

能体现这一优化的代码是：

p0Num = ones(numWords)
    p1Num = ones(numWords)      
    #初始化概率的分母变量
    p0Denom = 2.0; p1Denom = 2.0 

为什么这里初始化的时候是2.0而不是0呢？因为我们在这里用到了拉普拉斯平滑这一改进技术。由于P(C|w)=P(w|c)*P(c)/P(w)，这里的P(w|c)是通过p0Vect和p1Vect得到的，但是会发生这样一种情况：就是在原本的训练集中，某个词没有出现过label为ci的某个类，但是在实际上的文本中却出现了，但是如果我们用上面的式子计算的话，得到概率却是0（因为P（w|c)是0），但其实它出现的概率可能不是0，而只是比较小而已；或者更严重的，我们的样本数量和典型性受限，不能代表总体特征。

这种情况下，就需要我们使用拉普拉斯平滑这一技术，这是经常使用在朴素贝叶斯方法上的技术：

​ 具体操作上就是：将所有词的出现数初始化为1，并将分母初始化为2。当然，不是只有这一种写法的，具体来说应该是：

这里的K表示种类的个数，λ可以任取。由于我们是二分类所以K=2，这里我们取λ等于1，就是上面说的了，当然取其他的数字也可以。

这个式子的正确性是显而易见的，把所有情况的式子加起来还是1就能说明依然能正确表示概率。

这样做，就能保证对于每一种情况，都有了一个基础的概率。