【机器学习】朴素贝叶斯法（2）——案例：垃圾邮件分类

最新推荐文章于 2025-06-22 14:47:23 发布

原创最新推荐文章于 2025-06-22 14:47:23 发布 · 2.7k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#机器学习

机器学习专栏收录该内容

50 篇文章

订阅专栏

本文介绍如何利用朴素贝叶斯算法进行文本分类，通过构建词向量并计算概率实现垃圾邮件识别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

此文介绍了朴素贝叶斯的相关理论，如果理论知识还没能很好的掌握，我们可以通过代码来进一步理解。

在我们进行垃圾文件分类前，我们先思考一个问题：我们知道，朴素贝叶斯是基于概率论的，那么对于一个纯文本的邮件，我们该如何计算相关概率呢？

我们需要先从文本中获取特征，然后将每一个文本片段表示为一个词条向量，用1表示出现在文档中，用0表示未出现，这样就可以将一个纯文本的文档转换为一个数字向量，基于这些向量我们就可以计算相关概率。

解决上面问题的前提是获取文本的特征，需要拆分文本这在后面具体案例中会介绍。

下面我们先来看看，如何将一个以及分好词的文本转换为词向量。

从文本中构建词向量

（1）首先，我们将所有文档中的单词合在一起并除去重复的单词构建成一个词列表；

（2）基于前面创建的词列表，依次将每个文本转换为词向量，具体做法如下：

创建一个和词列表相同长度的0填充列表；
对于每个文本，查询每个单词在词列表中的位置，对应的0填充的列表的对应位置数目+1，这样每个样本就会形成一个长度相同的向量，如[0,0,1,0,1,…]，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']]
    classVec = [0, 1, 0, 1, 0, 1]  # 1 代表侮辱性文字， 0 代表正常言语
    return postingList, classVec  # 返回词条集合和类别标签


# 创建一个在所有文档中出现的不重复词的列表
# 使用了python的set数据类型，将词条列表输给set构造函数，set就会返回一个不重复的词表
def createVocabList(dataSet):
    vocabSet = set([])  # 创建一个空集
    for document in dataSet:
        vocabSet = vocabSet | set(document)  # 创建两个集合的并集
    return list(vocabSet)


# 文档向量
def setOfWords2Vec(vocabList, inputSet):  # 词汇表、某个文档
    returnVec = [0] * len(vocabList)  # 创建一个和词汇表等长的0向量
    for word in inputSet:  # 遍历文档所有单词
        if word in vocabList:  # 判断，如果出现了词汇表中的单词
            returnVec[vocabList.index(word)] = 1  # 文档向量对应位置设为1
        else:
            print("the word: %s is not in my Vocabulary!" % word)  # 否则输出不再我的词汇表中
    return returnVec  # 输出是文档向量，向量的每个元素为1或0，分别表示词汇表中的单词在输入文档中是否出现


# 测试
listOPosts, listClasses = loadDataSet()
print("训练样本：", listOPosts)
print("样本标签：", listClasses)
myVocabList = createVocabList(listOPosts)
print("我的词列表为：", myVocabList)

print("第一个样本的词向量为:", setOfWords2Vec(myVocabList, listOPosts[0]))
print("第二个样本的词向量为:", setOfWords2Vec(myVocabList, listOPosts[1]))

运行结果1：

这里写图片描述

从词向量计算概率

我们得到了每个样本的词向量，如下图：（由于set函数每次输出不一样所以这里得到可能不一样，但结构是一样的）

这里写图片描述

看到这些数据，是不是似曾相识？是的，这跟理论部分的西瓜数据类似，只不过这里的每个特征是一个单词，每个单词的属性值只有1和0，1表示该单词在该文本中出现，0则相反。

首先，计算先验概率：

$p (侮辱类) = 3 6 = 0.5 ， p (非侮辱类) = 3 6 = 0.5$ $p(侮辱类) = \frac{3}{6} = 0.5，p(非侮辱类)=\frac{3}{6}=0.5$
再求，条件概率，（用出现次数除以相应类的总词数）例如：
$p (第一个词 | 侮辱类) = 2 19 \approx 0.10526$ $p(第一个词|侮辱类) = \frac{2}{19} \approx 0.10526$
$p (第一个词 | 非侮辱类) = 1 24 \approx 0.04167$ $p(第一个词|非侮辱类) = \frac{1}{24} \approx 0.04167$
注：这边与西瓜数据集的计算方法有些不同

下面我们直接来看代码，注意：这里面使用了Numpy进行计算处理，大大方便了计算。

代码

# 朴素贝叶斯分类器训练函数
def trainNB0(trainMatrix, trainCategory):  # 文档矩阵、由每篇文档类别标签所构成的向量
    numTrainDocs = len(trainMatrix)  # 计算训练样本个数
    numWords = len(trainMatrix[0])  # 每个样本的词向量中的元素个数
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 计算p(1)

    p0Num = zeros(numWords)  # 创建一个0填充的矩阵，并且元素个数与词向量的元素个数相同，用于记录正常词语
    p1Num = zeros(numWords)  # 用于记录侮辱性词语

    p0Denom = 0.0
    p1Denom = 0.0

    for i in range(numTrainDocs):  # 遍历训练集中的所有文档
        if trainCategory[i] == 1:  # 如果类标签为1（即侮辱性文档）
            p1Num += trainMatrix[i]  # 该词对应的个数对应+1
            p1Denom += sum(trainMatrix[i])  # 加上该文档的总词数
        else:  # 如果类标签为0，做同样操作
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = p1Num / p1Denom  # 对每个元素除以该类别中的总词数
    p0Vect = p0Num / p0Denom
    return p0Vect, p1Vect, pAbusive  # 返回两个向量一个概率


# 测试
listOPosts, listClasses = loadDataSet()
print("训练样本：", listOPosts)
print("样本标签：", listClasses)
myVocabList = createVocabList(listOPosts)
print("我的词列表为：", myVocabList)  # 得到不含重复词的词列表

trainMat = []
# 使用词向量来填充trainMat列表
for postinDoc in listOPosts:
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))

# 打印trainMat
for i in range(len(trainMat)):
    print("第 %d 个样本的词向量为：" % (i + 1), trainMat[i])

p0V, p1V, pAb = trainNB0(trainMat, listClasses)
print("任意文档属于侮辱性文档的概率为：", pAb)
print("词列表中每个词在类别0中条件概率：", p0V)
print("词列表中每个词在类别1中条件概率：", p1V)

运行结果2
这里写图片描述

这边我们可以看到，和我们给出的示例计算的结果是一样的。

下面这一点非常重要：

在介绍理论知识的时候我们提到过，如果某些词在某一类中未出现，那么概率就会为0，在计算多个概率相乘以获得文档属于某个类别的概率的时候，值就会为0，为了降低这种影响，我们可以将所有词的出现次数初始化为1，并将分母初始化为2.0。

修改后的代码

# 朴素贝叶斯分类器训练函数
def trainNB0(trainMatrix, trainCategory):  # 文档矩阵、由每篇文档类别标签所构成的向量
    numTrainDocs = len(trainMatrix)  # 计算训练样本个数
    numWords = len(trainMatrix[0])  # 每个样本的词向量中的元素个数
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 计算p(1)

    p0Num = ones(numWords)  # 创建一个1填充的矩阵，并且元素个数与词向量的元素个数相同，用于记录正常词语
    p1Num = ones(numWords)  # 用于记录侮辱性词语

    p0Denom = 2.0
    p1Denom = 2.0

    for i in range(numTrainDocs):  # 遍历训练集中的所有文档
        if trainCategory[i] == 1:  # 如果类标签为1（即侮辱性文档）
            p1Num += trainMatrix[i]  # 每个侮辱性文档中每个词对应位置个数+1
            p1Denom += sum(trainMatrix[i])  # 每个侮辱性文档的总词数叠加
        else:  # 如果类标签为0，做同样操作
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = log(p1Num / p1Denom)  # 对每个元素除以该类别中的总词数
    p0Vect = log(p0Num / p0Denom)
    return p0Vect, p1Vect, pAbusive  # 返回两个向量一个概率

朴素贝叶斯分类函数

代码

# 朴素贝叶斯分类函数
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1): # 要分类的向量以及使用函数trainNB0计算的三个概率
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)  # 两个向量相乘（对应元素相乘），然后将词汇表中所有词的对应值相加，然后将该值加到类别的对数概率上
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0: # 比较类别的概率
        return 1
    else:
        return 0

# 测试
listOPosts, listClasses = loadDataSet()
print("训练样本：", listOPosts)
print("样本标签：", listClasses)
myVocabList = createVocabList(listOPosts)
print("我的词列表为：", myVocabList)  # 得到不含重复词的词列表

trainMat = []
# 使用词向量来填充trainMat列表
for postinDoc in listOPosts:
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))

p0V, p1V, pAb = trainNB0(trainMat, listClasses)

testEntry = ['love', 'my', 'dalmation']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print(testEntry, '分类为: ', classifyNB(thisDoc, p0V, p1V, pAb))
testEntry = ['stupid', 'garbage']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print(testEntry, '分类为: ', classifyNB(thisDoc, p0V, p1V, pAb))

运行结果3

这里写图片描述

至此，朴素贝叶斯法的一个简单的应用就OK了，我们再次思考：

如果，我们的文本中有重复的单词呢？set函数会去重，这样会不会影响分类结果呢？为此我们修改setOfWords2Vec函数。

代码

# 词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

案例：垃圾邮件分类

1.切分文本

mysent = 'This  book  is the best book on Python or M.L. I have ever laid eyes  upon.'
print(mysent.split()) # 使用pytho的string.split()函数

import re

regEx = re.compile('\W')  # \W 表示非字母和数字
listOfTokens = regEx.split(mysent)  # 按照正则匹配切分
print(listOfTokens)

wordList = []
for tok in listOfTokens:
    if len(tok) > 0:  # 去除切分后的空字符串
        wordList.append(tok.lower())
print(wordList)

运行结果4

这里写图片描述

垃圾邮件分类

代码

from numpy import *

# 创建一个在所有文档中出现的不重复词的列表
# 使用了python的set数据类型，将词条列表输给set构造函数，set就会返回一个不重复的词表
def createVocabList(dataSet):
    vocabSet = set([])  # 创建一个空集
    for document in dataSet:
        vocabSet = vocabSet | set(document)  # 创建两个集合的并集
    return list(vocabSet)


# 词袋模型（文档中的词可以多次出现）
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0] * len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1  # 每出现一次，对应的数目就加1
    return returnVec


# 朴素贝叶斯分类器训练函数
def trainNB0(trainMatrix, trainCategory):  # 文档矩阵、由每篇文档类别标签所构成的向量
    numTrainDocs = len(trainMatrix)  # 计算训练样本个数
    numWords = len(trainMatrix[0])  # 每个样本的词向量中的元素个数
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 计算p(1)

    p0Num = ones(numWords)  # 创建一个1填充的矩阵，并且元素个数与词向量的元素个数相同，用于记录正常词语
    p1Num = ones(numWords)  # 用于记录侮辱性词语

    p0Denom = 2.0
    p1Denom = 2.0

    for i in range(numTrainDocs):  # 遍历训练集中的所有文档
        if trainCategory[i] == 1:  # 如果类标签为1（即侮辱性文档）
            p1Num += trainMatrix[i]  # 每个侮辱性文档中每个词对应位置个数+1
            p1Denom += sum(trainMatrix[i])  # 每个侮辱性文档的总词数叠加
        else:  # 如果类标签为0，做同样操作
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = log(p1Num / p1Denom)  # 对每个元素除以该类别中的总词数
    p0Vect = log(p0Num / p0Denom)
    return p0Vect, p1Vect, pAbusive  # 返回两个向量一个概率


# 朴素贝叶斯分类函数
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):  # 要分类的向量以及使用函数trainNB0计算的三个概率
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)  # 两个向量相乘（对应元素相乘），然后将词汇表中所有词的对应值相加，然后将该值加到类别的对数概率上
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:  # 比较类别的概率
        return 1
    else:
        return 0

# 接受一个大字符串并将其解析为字符串列表
def textParse(bigString):
    import re
    listOfTokens = re.split(r'\W', bigString)  # \W* 表示任意非字符或数字的组合出现零或更多次
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]  # 字符串长度大于2，转为小写

# 对贝叶斯垃圾邮件分类器进行自动处理
def spamTest():
    # 定义一些空列表
    docList = []
    classList = []
    fullText = []
    for i in range(1, 26):
        wordList = textParse(open('email/spam/%d.txt' % i,errors='ignore').read()) # 导入文件夹spam下的文件，并解析为词列表
        docList.append(wordList)  # 将整个词列表加到docList列表中，关于append和extend的用法可自行查询下
        fullText.extend(wordList) # 将词列表中的元素加到fullText列表中
        classList.append(1)   # 垃圾邮件标记为1
        wordList = textParse(open('email/ham/%d.txt' % i,errors='ignore').read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)

    vocabList = createVocabList(docList)  # 调用createVocabList函数创建一个在所有文档中出现的不重复词的列表
    trainingSet = list(range(50))
    testSet = []
    for i in range(10):
        randIndex = int(random.uniform(0, len(trainingSet))) # 0-50的随机整数
        testSet.append(trainingSet[randIndex])  # 在所有邮件中随机选取10个作为测试集
        del (trainingSet[randIndex]) # 删除用于作为测试集的邮件
    trainMat = []
    trainClasses = []
    for docIndex in trainingSet: # 遍历训练集
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))  # 用词袋模型对每个样本进行处理，返回邮件对应的词向量
        trainClasses.append(classList[docIndex])  # 训练样本的标签
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))  # 调用trainNB0训练函数
    errorCount = 0  # 用于记录分类错误的个数
    for docIndex in testSet:  # 遍历测试集
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]: # 分类结果与原标签不一致
            errorCount += 1 # 错误个数+1
            # print("分类错误：", docList[docIndex])
    # print('错误率为: ', float(errorCount) / len(testSet))
    return float(errorCount) / len(testSet)

# 测试（迭代10次求平均）
error = 0.0
for i in range(10):
    error += spamTest()
error = error / 10.0
print(error)