朴素贝叶斯分类器实现正面负面文本分类

朴素贝叶斯分类器，完成正面、负面文本分类任务

一、环境准备

1. Python 3.9.13

2. 安装必要的第三方库

pip install sklearn numpy

3. 编辑器自己选择,VsCode、Pycharm或者Jupyter notebook都行，由于我们的文本比较简单，所以对算力要求不高。

二、朴素贝叶斯必备基础知识

(一).什么是朴素贝叶斯

• 贝叶斯方法是以贝叶斯原理为基础，使用概率统计的知识对样本数据集进行分类。

• 朴素贝叶斯模型（Naive Bayesian Model，NBM）是在贝叶斯算法的基础上进行了相应的简化，即假定给定目标值时属性之间相互条件独立。

(二). 概率论基础

基础贝叶斯公式 (核心⭐⭐⭐⭐⭐必会)

• P(A) 这是概率中最基本的符号，表示 A 出现的概率。比如在投掷骰子时，P(2) 指的是骰子出现数字“2”的概率，这个概率是 六分之一。
• P(B|A) 是条件概率的符号，表示事件 A 发生的条件下，事件 B 发生的概率，条件概率是“贝叶斯公式”的关键所在，它也被称为“似然度”。
• P(A|B) 是条件概率的符号，表示事件 B 发生的条件下，事件 A 发生的概率，这个计算结果也被称为“后验概率”。

条件概率

条件概率是指事件A在事件B发生的条件下发生的概率。条件概率表示为：P（A|B），读作“A在B发生的条件下发生的概率”。

联合概率

表示两个事件共同发生的概率。A与B的联合概率表示为 P(AB) 或者P(A,B),或者P(A∩B)。

贝叶斯公式

设B1，B2，…Bn…是一完备事件组，则对任一事件A，P（A）>0，有

性质如下: 统计独立性 和 互斥性

• 当且仅当两个随机事件A与B满足 P(A∩B)=P(A)P(B)的时候，它们是统计独立的，这样联合概率可以表示为各自概率的简单乘积。

  同样，对于两个独立事件A与B有 P(A|B)=P(A) 以及 P(B|A)=P(B)

  换句话说，如果A与B是相互独立的，那么A在B这个前提下的条件概率就是A自身的概率；同样，B在A的前提下的条件概率就是B自身的概率。

• 当且仅当 A 与 B满足 P(A∩B)=0 且P(A)≠0，P(B)≠0 的时候，A与* B是互斥的。因此，

  P(A|B)=0 P(B|A)=0

  换句话说，如果B已经发生，由于A不能和B在同一场合下发生，那么A发生的概率为零；同样，如果A已经发生，那么B发生的概率为零。

先验概率

在贝叶斯统计推断中，不确定数量的先验概率分布是在考虑一些因素之前表达对这一数量的置信程度的概率分布。

（在贝叶斯看来，世界并非静止不动的，而是动态和相对的，他希望利用已知经验来进行判断，那么如何用经验进行判断呢？这里就必须要提到“先验”和“后验”这两个词语。我们先讲解“先验”，其实“先验”就相当于“未卜先知”，在事情即将发生之前，做一个概率预判。比如从远处驶来了一辆车，是轿车的概率是 45%，是货车的概率是 35%，是大客车的概率是 20%，在你没有看清之前基本靠猜，此时，我们把这个概率就叫做“先验概率”。）

后验概率

后验概率是信息理论的基本概念之一。在一个通信系统中，在收到某个消息之后，接收端所了解到的该消息发送的概率称为后验概率。后验概率的计算要以先验概率为基础。后验概率可以根据通过贝叶斯公式，用先验概率和似然函数计算出来

（我们知道每一个事物都有自己的特征，比如前面所说的轿车、货车、客车，它们都有着各自不同的特征，距离过远的时候，我们无法用肉眼分辨，而当距离达到一定范围内就可以根据各自的特征再次做出概率预判，这就是后验概率。比如轿车的速度相比于另外两者更快可以记做 P(轿车|速度快) = 55%，而客车体型可能更大，可以记做 P(客车|体型大) = 35%。）

全概率公式

(三).朴素贝叶斯算法原理

公式推导如下

(四).拉普拉斯平滑

拉普拉斯平滑(Laplacian smoothing) 是为了解决零概率的问题。

零概率问题：在计算事件的概率时，如果某个事件在观察样本库（训练集）中没有出现过，会导致该事件的概率结果是0。这是不合理的，不能因为一个事件没有观察到，就被认为该事件一定不可能发生（即该事件的概率为0）。

Laplacian smoothing 公式

• 核心: 分子加一，分母加K，K代表类别数目

(五).朴素贝叶斯分类优缺点

• 优点

  在数据较少的情况下仍然有效，可以处理多类别问题

• 缺点

  对于输入数据的准备方式较为敏感。

三、代码复现（基于Python）

1.纯手写实现

1.1 定义函数loadDataSet，实现数据集的生成

def loadDataSet():
    """
    实现数据集的生成
    :return: 进行词条切分后的文档集合(训练集)postingList，postingList,类别标签的集合classVec(训练标签)
    """
    # 生成训练集：
    postingList = [['my', 'dog', 'has', 'flea', 'problems', 'stupid', 'please'],
                   ['maybe', 'not', 'take', 'him', 'to', 'bad', 'dog', 'park'],
                   ['like', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                   ['stop', 'posting', 'bad', 'worthless', 'garbage'],
                   ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                   ['quit', 'stupid', 'worthless', 'rubbish', 'dog', 'food', 'awfully']]
    # 生成训练标签
    classVec = [0, 1, 0, 1, 0, 1]  # 1 is abusive, 0 not
    return postingList, classVec

1.2 定义函数createVocabList。创建词汇表

def createVocabList(dataSet):
    """ 创建词汇表
    读取数据集中的每一句话，建立词汇表，要求存储整个数据集中的所有单词，且不能重复
    :param dataSet: 数据集
    :return: 词汇表list(vocabSet)
    """
    # 建立一个空列表
    vocabSet = set([])
    for document in dataSet:
        # 合并两个集合
        vocabSet = vocabSet | set(document)

    return list(vocabSet)

1.3 定义函数setOfWords2Vec，建立词袋模型

def setOfWords2Vec(vocabList, inputSet):
    """创建一个和词汇表等长的向量
    建立词袋模型,词袋模型将长度不定的句子转化为维度确定的特征向量，在词袋模型中，每个句子是一个样本，
    该样本的属性数量等于词汇表中的单词总数，每个属性的含义是：
    词汇表中对应位置的词在本句话中是否存在，存在为1，不存在为0。
    :param vocabList: 词汇表
    :param inputSet: 单个样本（句子）
    :return: 样本的特征向量
    """
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:  # 词汇表中对应位置的词在本句话中存在则为1
            returnVec[vocabList.index(word)] = 1
        else:
            print("the word: %s is not in my Vocabulary!" % word)

    return returnVec

1.4 定义函数trainNB0，实现朴素贝叶斯算法训练

def trainNB0(trainMatrix, trainCategory):
    """进行训练， 这里就是计算：条件概率 和 先验概率
    注：由于已知样本只有二类，因此可以只计算1类的先验概率，由于已知属性是二值化的，因此可以只计算属性值取1的类条件概率。
    :param trainMatrix: 训练属性集
    :param trainCategory: 训练标签集
    :return: 0类样本类条件概率p0Vect, 1类样本类条件概率p1Vect, 1类样本类条件概率pAbusive
    """
    # 计算总的样本数量,训练集trainMatrix的最外层数组长度
    numTrainDocs = len(trainMatrix)
    # 计算样本向量化后的长度， 这里等于词典长度。也就是训练集trainMatrix的第二层数组长度
    numWords = len(trainMatrix[0])
    # 计算1类的先验概率,就是trainCategory中1类样本的数量 / 样本总数numTrainDocs（1类样本的标签就是1本身，此处要进行拉普拉斯平滑）
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    # 进行初始化，用于向量化后的样本累加(初始化1不是全0，防止概率值为0).
    p0Num = np.ones(numWords)  # 属性值0出现的次数
    p1Num = np.ones(numWords)  # 属性值1出现的次数

    # 初始化求条件概率的分母为2， 防止出现0，无法计算的情况。
    p0Denom = 2.0
    p1Denom = 2.0  # change to 2.0
    # 遍历所有向量化后的样本， 并且每个向量化后的长度相等， 等于词典长度。
    for i in range(numTrainDocs):
        # 统计标签为1的样本： 向量化后的样本的累加， 样本中1总数的求和， 最后相除取log就是条件概率。
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        # 统计标签为0的样本： 向量化后的样本累加， 样本中1总数的求和， 最后相除取log就是条件概率。
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    # 求条件概率。改为 log() 防止出现0
    p1Vect = np.log(p1Num / p1Denom)  # 属性值0出现的概率
    p0Vect = np.log(p0Num / p0Denom)  # 属性值1出现的概率
    # 返回条件概率 和 先验概率
    return p0Vect, p1Vect, pAbusive

1.5 定义函数classifyNB，利用朴素贝叶斯算法进行预测

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    """ 利用朴素贝叶斯算法进行预测,通过条件概率 和 先验概率对新的样本进行向量化后分类。哪个类别的概率大，则属于哪个类别
    :param vec2Classify:特征向量化的样本
    :param p0Vec:0类属性取1的后验概率
    :param p1Vec:1类属性取1的类条件概率
    :param pClass1:1类先验概率
    :return:预测结果 0 or 1
    """
    # 向量化后的样本 分别 与 各类别的条件概率相乘 加上先验概率取log，之后进行大小比较, 输出类别。
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)  #
    p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
    # 若第1类的后验概率p1>若第0类的后验概率p0，则返回1，否则返回0
    if p1 > p0:
        return 1
    else:
        return 0

1.6 执行训练与测试（顶层代码）

def run_NB():
    """测试程序,对训练两条测试文本进行分类
    :return: None
    """
    # 调用loadDataSet函数生成训练样本listOPosts和标签listClasses
    listOPosts, listClasses = loadDataSet()
    # 调用createVocabList函数生成词汇表myVocabList,创建词典
    myVocabList = createVocabList(listOPosts)
    # 用于保存样本转向量之后的数据
    trainMat = []
    # 遍历每一个样本,转向量后,保存到列表中。
    for postinDoc in listOPosts:
        # 利用setOfWords2Vec函数，将原始训练样本listOPosts逐句转化成特征向量化的样本,存储在列表trainMat中
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))

    # 计算 条件概率 和 先验概率,调用trainNB0函数进行训练，将返回值赋值给p0V,p1V,pAb
    p0V, p1V, pAb = trainNB0(np.array(trainMat), np.array(listClasses))
    testEntry = ['love', 'my', 'dalmation']  # 生成测试样本
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))  # 利用setOfWords2Vec函数，将原始测试样本转化为特征向量化的样本，存储在thisDoc中
    if classifyNB(thisDoc, p0V, p1V, pAb):  # 利用classifyNB进行测试，输出结果。
        print(testEntry, '属于负面类')
    else:
        print(testEntry, '属于正面类')

    testEntry = ['bad', 'garbage']  # 生成测试样本
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))  # 利用setOfWords2Vec函数，将原始测试样本转化为特征向量化的样本，存储在thisDoc中
    if classifyNB(thisDoc, p0V, p1V, pAb):  # 利用classifyNB进行测试，输出结果。
        print(testEntry, '属于负面类')
    else:
        print(testEntry, '属于正面类')

if __name__ == '__main__':
    run_NB()  # 运行程序

运行结果

2. 调用 python第三方库

def loadDataSet():
    """实现数据集的生成
    :return: 训练集postingList，训练标签classVec
    """
    # 生成训练集：
    postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
                   ['maybe', 'not', 'take', 'him', 'to', 'bad', 'dog', 'park'],
                   ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                   ['stop', 'posting', 'bad', 'worthless', 'garbage'],
                   ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                   ['quit', 'buying', 'worthless', 'bad', 'dog', 'food']]
    # 生成训练标签：其中0为正面情感，1为负面情感。
    classVec = [0, 1, 0, 1, 0, 1]
    return postingList, classVec


def createVocabList(dataSet):
    """创建词汇表
    读取数据集中的每一句话，建立词汇表，要求存储整个数据集中的所有单词，且不能重复。
    :param dataSet:数据集
    :return: 词汇表list(vocabSet)
    """
    vocabSet = set([])
    for document in dataSet:
        vocabSet = vocabSet | set(document)
    return list(vocabSet)


def setOfWords2Vec(vocabList, inputSet):
    """建立词袋模型
    词袋模型将长度不定的句子转化为维度确定的特征向量，在词袋模型中，每个句子是一个样本，
    该样本的属性数量等于词汇表中的单词总数.每个属性的含义是：词汇表中对应位置的词在本句话中是否存在，存在为1，不存在为0。
    :param vocabList: 词汇表
    :param inputSet: 单个样本（句子）
    :return: 样本的特征向量returnVec
    """
    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 run_test():
    """执行训练与测试（顶层代码）
    :return: None
    """
    # 调用loadDataSet函数读取样本与标签listOPosts,listClasses
    listOPosts, listClasses = loadDataSet()
    # 调用createVocabList函数生成词汇表myVocabList
    myVocabList = createVocabList(listOPosts)
    trainMat = []
    for postinDoc in listOPosts:
        # 利用setOfWords2Vec函数，将原始训练样本listOPosts逐句转化成特征向量化的样本，存储在列表trainMat中
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))

    # 将BernoulliNB模型实例化，设置参数binarize=None（已经进行过二值化处理），prior=False（考虑先验概率）
    NB = BernoulliNB(binarize=None, fit_prior=False)
    # 利用BernoulliNB模型的.fit方法进行训练
    NB.fit(trainMat, listClasses)
    # 生成测试样本
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
    # 利用BernoulliNB模型的.predict方法进行测试，输出结果。注意.predict接收的是由全部变量构成的集合。
    if NB.predict([thisDoc])[0] == 1:
        print(testEntry, '属于负面类')
    else:
        print(testEntry, '属于正面类')
    testEntry = ['bad', 'garbage']

    thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
    if NB.predict([thisDoc])[0] == 1:
        print(testEntry, '属于负面类')
    else:
        print(testEntry, '属于正面类')


if __name__ == '__main__':
    # 引入必要的模块
    import numpy as np
    from sklearn.naive_bayes import BernoulliNB

    # 调用顶层函数执行输出测试结果
    run_test()

运行结果：

3. 自己动手

   1. 更改训练集为下

   postingList = [['my', 'dog', 'has', 'flea', 'problems', 'stupid', 'please'],
                  ['maybe', 'not', 'take', 'him', 'to', 'bad', 'dog', 'park'],
                  ['like', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                  ['stop', 'posting', 'bad', 'worthless', 'garbage'],
                  ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                  ['quit', 'stupid', 'worthless', 'rubbish', 'dog', 'food','awfully']]
   

   2. 更改测试样本并测试

---

全文完！