朴素贝叶斯算法：实现邮件分类

最新推荐文章于 2024-03-25 14:31:00 发布

JiangNanMax

最新推荐文章于 2024-03-25 14:31:00 发布

阅读量1.6w

点赞数 21

分类专栏： Python 深度学习

本文链接：https://blog.csdn.net/j__max/article/details/82965180

版权

Python 同时被 2 个专栏收录

18 篇文章 1 订阅

订阅专栏

深度学习

6 篇文章 0 订阅

订阅专栏

朴素贝叶斯算法：实现邮件分类

注：代码和数据已上传：https://download.csdn.net/download/j__max/10705454

一、实验准备

1、实验内容和目的

使用5000封邮件作为训练集，训练朴素贝叶斯分类器，然后使用该分类器对1000封邮件进行分类，给出准确率结果
其中训练集为文件spam_train.txt，测试集为文件spam_test.txt。它们的存储形式为：每封邮件以一个标签(0或1)开头，然后以一个换行符来标示一封邮件的结尾
这里先给出我最后测试的准确率：98.3% ，接下来对我的实现过程进行详细说明

2、实验原理

朴素贝叶斯算法是有监督的学习算法，可以用来解决分类问题。朴素贝叶斯基于贝叶斯定理和特征条件独立假设，它假设每个特征条件之间是独立的，比如一个单词出现的概率和其它相邻单词没有关系，因此我们称之为“天真”的贝叶斯算法

2.1 基于贝叶斯决策理论的分类方法

朴素贝叶斯是贝叶斯决策理论的一部分，要完全掌握朴素贝叶斯的话有必要了解一下贝叶斯决策理论
- 假设有一个数据集，由两类数据组成(体现为圆点和三角形)，分布情况如下图所示：
- 我们现在用p0(x,y)表示数据点(x,y)属于类别0(图中用圆点表示的类别)的概率，用p1(x,y)表示数据点(x,y)属于类别1(图中用三角形表示的类别)的概率，那么对于一个新数据点(x,y)，可以使用下面的规则来判断它的类别：
  - 如果p0(x,y) > p1(x,y)，那么数据点(x,y)的类别为0
  - 如果p1(x,y) > p0(x,y)，那么数据点(x,y)的类别为1
- 也就是说，我们会高概率对应的类别。这也就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策

2.2 条件概率

在2.1中提到了概率p0和p1，那么如何计算p0和p1？这就需要理解条件概率的计算。相信只要上过概率论，肯定对符号p(x,y | c)很熟悉，下面通过一个例子来复习一下条件概率
- 假设现在有一个装了7块石头的罐子，其中3块灰色的，4块黑色的(如下图所示)。如果从罐中随机取出一块石头，那么是灰色石头的可能性是多少？显然是3/7。我们使用P(gray)来表示取到灰色石头的概率，其概率值可以通过灰色石头数量除以总的石头数量来得到
- 那如果这7块石头如下图所示放在两个桶中，那么上述概率应该怎么计算？
- 要计算P(gray)或者P(black)，事先得知道石头所在桶的信息会不会改变结果？你有可能已经想到计算从B桶中取到灰色石头概率的办法，这就是所谓的条件概率。假定计算的是从B桶中取到灰色石头的概率，这个概率可以记作P(gray | bucketB),我们称之为“在已知石头出自B桶的条件下，取出灰色石头的概率”。不难算出，P(gray | bucketA)=1/2，P(gray | bucketB)=1/3。条件概率的计算公式如下所示：
  - P(gray | bucketB) = P(gray and bucketB) / P(bucketB)

2.3 使用条件概率来分类

2.1节提到贝叶斯决策理论要求计算两个概率p0(x,y)和p1(x,y)：
- 如果p0(x,y) > p1(x,y)，那么数据点(x,y)的类别为0
- 如果p1(x,y) > p0(x,y)，那么数据点(x,y)的类别为1
但这两个准则并不是贝叶斯决策理论的所有内容。使用p0()和p1()只是为了尽可能简化描述，而真正需要计算和比较的是p(c₀ | x,y)和p(c₁ | x,y)。这些符号所代表的具体意义是：给定某个由x、y表示的数据点，那么该数据点来自类别c₀的概率是多少？数据点来自类别c₁的概率又是多少？使用这些定义，可以定义贝叶斯准则为：
- 如果P(c₀ | x,y) > P(c₁ | x,y)，那么属于类别0
- 如果P(c₁ | x,y) > P(c₀ | x,y)，那么属于类别1
基于贝叶斯准则，可以训练出一个功能强大的贝叶斯分类器，接下来对我构造的分类器进行详细说明

二、进行实验

1、算法思路

其实在实验原理部分，已经是详细的算法思路了，因为朴素贝叶斯的核心思想，就是实验原理中说明的三个部分。简单来说，整体的思路过程就是：对于给定的训练集，首先基于特征条件独立假设学习输入/输出的联合概率分布。然后基于此模型，对于给定的输入x，利用贝叶斯定理求出后验概率最大的输出y

2、算法步骤

(1) 对训练数据进行处理，提出每一个训练数据和其对应的标签
(2) 根据训练数据，生成一个词汇表
(3) 向量化每个训练样本，然后结合生成的词汇表，训练朴素贝叶斯分类器
(4) 对测试数据进行处理，提出每一个测试数据和其对应的标签
(5) 向量化每个测试数据，使用朴素贝叶斯分类器对其进行分类
(6) 即通过比较概率p0和p1的大小，判断其属于哪个类别

3、代码实现

注：代码中的所有函数功能已注释在函数头部，具体的代码作用也在代码后面进行了注释说明
(1) 处理数据文件。这里因为训练数据和测试数据的存放格式一样的，因此能够使用同一个功能函数loadFile进行处理。对邮件内容进行切分，取出每封邮件对应的类别标签，生成每封邮件对应的词条向量，返回这两部分

def loadFile(filename):
    """
    函数说明：
        加载数据文件
    :param filename:
        文件名
    :return:
        contentList - 切分邮件内容得到的词条
        classVec - 类别标签向量
    """
    file = open(filename)

    contentList = []
    classVec = []

    contents = file.readlines()
    for line in contents:
        content = line.strip('\n').split(' ')   #以空格为分割符，切分邮件的内容，得到该邮件对应的词条
        classVec.append(int(content[0]))    #取出邮件的类别标签
        del(content[0])     #删掉词条中的类别标签
        contentList.append(content)

    return contentList, classVec

(2) 根据处理训练数据得到的词条，汇总生成一个词汇表。其中使用set取并集的特性，去除重复的词汇

def createVocabList(dataSet):
    """
    函数说明：
        根据训练数据，生成一个词汇表
    :param dataSet:
        切分所有邮件得到的词条
    :return:
        list(vocabSet) - 使用训练数据生成的不重复的词汇表
    """
    vocabList = set([])  #创建一个空集合
    for content in dataSet:
        vocabList = vocabList | set(content)   #通过取并集的方式去重，扩充词汇表

    return list(vocabList)   #以list的形式返回词汇表

(3) 根据vocabList词汇表，将每个wordsSet词条向量化，向量的每个值为1或0，分别表示该词有或者没有在词汇表中出现

def Words_to_Vec(vocabList, wordsSet):
    """
    函数说明：
        根据vocabList词汇表，将每个wordsSet词条向量化，向量的每个值为1或0，分别表示该词有或者没有在词汇表中出现
    :param vocabList:
        词汇表
    :param inputSet:
        切分每封邮件得到的词条
    :return:
        词条向量
    """
    returnVec = [0] * len(vocabList)

    for word in wordsSet:   #判断每个词是否在词汇表中出现
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1    #在词汇表中出现的话则该词对应的位置标记为1

        else:
            print("The word %s is not in the VocabList!" % word)

    return returnVec

(4) 向量化每个训练样本，然后结合生成的词汇表，训练朴素贝叶斯分类器。其中使用了拉普拉斯平滑的方法

def trainNB(trainMat, trainLabel):
    """
    函数说明：
        朴素贝叶斯分类训练函数
    :param trainMat:
        训练文档，即Words_to_Vec函数返回的词向量构成的矩阵
    :param trainLabel:
        训练数据的类别标签，即loadFile函数返回的classVec
    :return:
        p0Vec - 侮辱类的条件概率数组
        p1Vec - 非侮辱类的条件概率数组
        pNotAbusive - 文档属于侮辱类的概率
    """
    numTraindocs = len(trainMat)    #训练集的数量
    numWords = len(trainMat[0])     #每个词条向量的长度

    pNotAbusive = sum(trainLabel) / float(numTraindocs)    #文档属于非侮辱类的概率

    p0Num = np.ones(numWords)   #创建numpy.ones数组,词条出现数初始化为1，拉普拉斯平滑方法
    p1Num = np.ones(numWords)
    p0Denom = 2.0               ##分母初始化为2,拉普拉斯平滑方法
    p1Denom = 2.0

    for i in range(numTraindocs):
        if trainLabel[i] == 1:
            p1Num += trainMat[i]    #统计属于非侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)···
            p1Denom += sum(trainMat[i])
        else:
            p0Num += trainMat[i]    #统计属于侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
            p0Denom += sum(trainMat[i])

    p1Vec = np.log(p1Num / p1Denom) #取对数
    p0Vec = np.log(p0Num / p0Denom)

    return p0Vec, p1Vec, pNotAbusive

(5) 向量化每个测试数据，使用朴素贝叶斯分类器对其进行分类,通过比较概率p0和p1的大小，判断其属于哪个类别

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass0):
    """
    函数说明：
        朴素贝叶斯分类函数
    :param vec2Classify:
        待分类的词条向量
    :param p0Vec:
        侮辱类的条件概率数组
    :param p1Vec:
        非侮辱类的条件概率数组
    :param pClass0:
        文档属于侮辱类的概率
    :return:
        0 - 文档属于侮辱类
        1 - 文档属于分侮辱类
    """
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass0)  
    p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass0)
    if p1 > p0:
        return 1
    else:
        return 0

(6) 主函数，综合调用上述的功能函数，加载处理数据，训练分类器，然后对测试集邮件进行分类，最后计算分类的准确率

def main():
    trainList, trainLabel = loadFile('spam_train.txt')  #处理训练数据
    VocabList = createVocabList(trainList)  #生成词汇表

    '''
    #由于数据集较大，生成的词汇表内容较多，因此我把生成的词汇表写出到txt文件，后续可以直接调用
    file = open('VocabList.txt', 'w')
    file.write(str(VocabList))
    file.close()
    '''

    trainMat = []
    cnt = 0     #用来标记处理到第几组数据，在处理完每组数据后就会加1输出

    for train in trainList:     #生成训练集矩阵
        trainMat.append(Words_to_Vec(VocabList, train))
        cnt += 1
        print("当前处理到第%s组训练数据." % cnt)

    '''
    #由于数据集较大，生成训练集矩阵较慢，内容也较多，因此我把生成的矩阵写出到txt文件，后续可以直接调用
    file = open('trainMat.txt', 'w')
    file.write(str(trainMat))
    file.close()
    '''

    p0V, p1V, pAb = trainNB(np.array(trainMat), np.array(trainLabel))   #使用训练集矩阵训练分类器

    testList, testLabel = loadFile('spam_test.txt')     #处理测试数据
    resultLabel = []

    cnt = 0

    for test in testList:   #分类测试数据，将分类的标签放入resultLabel
        doc = np.array(Words_to_Vec(VocabList, test))

        if classifyNB(doc, p0V, p1V, pAb):
            resultLabel.append(1)
        else:
            resultLabel.append(0)

        cnt += 1
        print("当前处理到第%s组测试数据." % cnt)

    cc = 0  #分类正确的个数
    for i in range(len(testLabel)):     #对比分类标签和真实标签
        if testLabel[i] == resultLabel[i]:
            cc += 1

    print('预测准确率：' + str(100 * cc / float(len(testLabel))) + '%')   #计算准确率

4、实验总结

测试最后得到的准确率为98.3%，自认为效果不错。有一处不足就是生成训练集矩阵trainMat要花较多时间，有考虑结合多线程或者多进程来加速这一过程
完成这次作业，个人总结了一点朴素贝叶斯算法的优缺点：
- 优点：
  - 有稳定的分类效率
  - 对小规模的数据表现很好，能个处理多分类任务，适合增量式训练
  - 对缺失数据不太敏感，算法也比较简单，常用于文本分类
- 缺点：
  - 理论上，朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此，这是因为朴素贝叶斯模型给定输出类别的情况下,假设属性之间相互独立，这个假设在实际应用中往往是不成立的，在属性个数比较多或者属性之间相关性较大时，分类效果不好。而在属性相关性较小时，朴素贝叶斯性能最为良好
  - 需要知道先验概率，且先验概率很多时候取决于假设，假设的模型可以有很多种，因此在某些时候会由于假设的先验模型的原因导致预测效果不佳
  - 由于我们是通过先验和数据来决定后验的概率从而决定分类，所以分类决策存在一定的错误率

三、完整代码

#!/usr/bin/python
# -*- coding utf-8 -*-
# Project: NB
# Author: jiangnan 
# Mail: jiangnanmax@gmail.com
# Date: 2018/9/26

import numpy as np

def loadFile(filename):
    """
    函数说明：
        加载数据文件
    :param filename:
        文件名
    :return:
        contentList - 切分邮件内容得到的词条
        classVec - 类别标签向量
    """
    file = open(filename)

    contentList = []
    classVec = []

    contents = file.readlines()
    for line in contents:
        content = line.strip('\n').split(' ')   #以空格为分割符，切分邮件的内容，得到该邮件对应的词条
        classVec.append(int(content[0]))    #取出邮件的类别标签
        del(content[0])     #删掉词条中的类别标签
        contentList.append(content)

    return contentList, classVecx


def createVocabList(dataSet):
    """
    函数说明：
        根据训练数据，生成一个词汇表
    :param dataSet:
        切分所有邮件得到的词条
    :return:
        list(vocabSet) - 使用训练数据生成的不重复的词汇表
    """
    vocabList = set([])  #创建一个空集合
    for content in dataSet:
        vocabList = vocabList | set(content)   #通过取并集的方式去重，扩充词汇表

    return list(vocabList)   #以list的形式返回词汇表


def Words_to_Vec(vocabList, wordsSet):
    """
    函数说明：
        根据vocabList词汇表，将每个wordsSet词条向量化，向量的每个值为1或0，分别表示该词有或者没有在词汇表中出现
    :param vocabList:
        词汇表
    :param inputSet:
        切分每封邮件得到的词条
    :return:
        词条向量
    """
    returnVec = [0] * len(vocabList)

    for word in wordsSet:   #判断每个词是否在词汇表中出现
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1    #在词汇表中出现的话则该词对应的位置标记为1

        else:
            print("The word %s is not in the VocabList!" % word)

    return returnVec


def trainNB(trainMat, trainLabel):
    """
    函数说明：
        朴素贝叶斯分类训练函数
    :param trainMat:
        训练文档，即Words_to_Vec函数返回的词向量构成的矩阵
    :param trainLabel:
        训练数据的类别标签，即loadFile函数返回的classVec
    :return:
        p0Vec - 侮辱类的条件概率数组
        p1Vec - 非侮辱类的条件概率数组
        pNotAbusive - 文档属于侮辱类的概率
    """
    numTraindocs = len(trainMat)    #训练集的数量
    numWords = len(trainMat[0])     #每个词条向量的长度

    pNotAbusive = sum(trainLabel) / float(numTraindocs)    #文档属于非侮辱类的概率

    p0Num = np.ones(numWords)   #创建numpy.ones数组,词条出现数初始化为1，拉普拉斯平滑方法
    p1Num = np.ones(numWords)
    p0Denom = 2.0               ##分母初始化为2,拉普拉斯平滑方法
    p1Denom = 2.0

    for i in range(numTraindocs):
        if trainLabel[i] == 1:
            p1Num += trainMat[i]    #统计属于非侮辱类的条件概率所需的数据，即P(w0|1),P(w1|1),P(w2|1)···
            p1Denom += sum(trainMat[i])
        else:
            p0Num += trainMat[i]    #统计属于侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
            p0Denom += sum(trainMat[i])

    p1Vec = np.log(p1Num / p1Denom) #取对数
    p0Vec = np.log(p0Num / p0Denom)

    return p0Vec, p1Vec, pNotAbusive


def classifyNB(vec2Classify, p0Vec, p1Vec, pClass0):
    """
    函数说明：
        朴素贝叶斯分类函数
    :param vec2Classify:
        待分类的词条向量
    :param p0Vec:
        侮辱类的条件概率数组
    :param p1Vec:
        非侮辱类的条件概率数组
    :param pClass0:
        文档属于侮辱类的概率
    :return:
        0 - 文档属于侮辱类
        1 - 文档属于分侮辱类
    """
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass0)  # 对应元素相乘。logA * B = logA + logB，所以这里加上log(pClass1)
    p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass0)
    if p1 > p0:
        return 1
    else:
        return 0

def main():
    trainList, trainLabel = loadFile('spam_train.txt')  #处理训练数据
    VocabList = createVocabList(trainList)  #生成词汇表

    '''
    #由于数据集较大，生成的词汇表内容较多，因此我把生成的词汇表写出到txt文件，后续可以直接调用
    file = open('VocabList.txt', 'w')
    file.write(str(VocabList))
    file.close()
    '''

    trainMat = []
    cnt = 0     #用来标记处理到第几组数据，在处理完每组数据后就会加1输出

    for train in trainList:     #生成训练集矩阵
        trainMat.append(Words_to_Vec(VocabList, train))
        cnt += 1
        print("当前处理到第%s组训练数据." % cnt)

    '''
    #由于数据集较大，生成训练集矩阵较慢，内容也较多，因此我把生成的矩阵写出到txt文件，后续可以直接调用
    file = open('trainMat.txt', 'w')
    file.write(str(trainMat))
    file.close()
    '''

    p0V, p1V, pAb = trainNB(np.array(trainMat), np.array(trainLabel))   #使用训练集矩阵训练分类器

    testList, testLabel = loadFile('spam_test.txt')     #处理测试数据
    resultLabel = []

    cnt = 0

    for test in testList:   #分类测试数据，将分类的标签放入resultLabel
        doc = np.array(Words_to_Vec(VocabList, test))

        if classifyNB(doc, p0V, p1V, pAb):
            resultLabel.append(1)
        else:
            resultLabel.append(0)

        cnt += 1
        print("当前处理到第%s组测试数据." % cnt)

    cc = 0  #分类正确的个数
    for i in range(len(testLabel)):     #对比分类标签和真实标签
        if testLabel[i] == resultLabel[i]:
            cc += 1

    print('预测准确率：' + str(100 * cc / float(len(testLabel))) + '%')   #计算准确率


if __name__ == '__main__':
    main()

JiangNanMax

关注

21
点赞
踩
136

收藏

觉得还不错? 一键收藏
打赏
14
评论
朴素贝叶斯算法：实现邮件分类

朴素贝叶斯算法：实现邮件分类一、实验准备1、实验内容和目的使用5000封邮件作为训练集，训练朴素贝叶斯分类器，然后使用该分类器对1000封邮件进行分类，给出准确率结果其中训练集为文件spam_train.txt，测试集为文件spam_test.txt。它们的存储形式为：每封邮件以一个标签(0或1)开头，然后以一个换行符来标示一封邮件的结尾这里先给出我最后测试的准确率：98.3...
复制链接

扫一扫