机器学习 | 朴素贝叶斯

Li.879

已于 2023-11-19 14:33:09 修改

阅读量123

点赞数

文章标签：机器学习算法人工智能

于 2023-11-19 14:31:50 首次发布

本文链接：https://blog.csdn.net/m0_65437885/article/details/134484954

版权

一、贝叶斯定理

事件B发生的条件下，事件A发生的概率，成为事件A的条件概率，表示为P(A|B)

$P(A|B) = \frac{P(AB)}{P(B)}$

根据上式，可得：

$P(AB)=P(A|B)P(B)$

同理，事件B在事件A发生的条件下的概率为：

$P(B|A) = \frac{P(AB)}{P(A)}$

$P(AB)=P(B|A)P(A)$

由上述可得贝叶斯公式：

$P(A|B)=\frac{P(A)P(B|A)}{P(B)}$

二、朴素贝叶斯分类器

基本概述

朴素贝叶斯分类器是基于贝叶斯定理的概率分类算法。其核心思想是通过计算后验概率来进行分类。对于给定的输入特征，通过计算每个可能类别的后验概率，选择具有最高概率的类别作为输出。朴素贝叶斯分类器的关键在于属性条件独立性假设。

内容理解

先验概率P(X)、P(Y)：根据以往的经验和分析得到的概率。
后验概率P(Y|X)：观测到 X 后对结果 Y 的估计，即给定数据样本 X 时 Y 成立的概率。反映了在看到数据样本 X 后 Y 成立的置信度。
事件独立性：当 $P(A_{1},A_{2},A_{3},...,A_{n}) = P(A_{1})P(A_{2})P(A_{3})...P(A_{n})$ 成立时，则称A1,A2,...,An为相互独立的事件，每个事件发生的概率互不影响。
朴素：假设属性特征之间相互独立。那么贝叶斯公式中的 P(X|Y) 等价于：

$P(X|Y)=P(x_{1}|Y)P(x_{2}|Y)P(x_{3}|Y)...P(x_{d}|Y)=\prod_{i=1}^{d}P(x_{i}|Y)$

其中 d 为属性数目， $x_{i}$ 为 x 在第 i 个属性上的取值

朴素贝叶斯公式：

$P(Y|X)=\frac{P(Y)}{P(X)}\prod_{i=1}^{d}P(x_{i}|Y)$

三、拉普拉斯修正

在朴素贝叶斯中，如果某个属性值在训练集中没有与某个类同时出现过，那么在没有修正的情况下，该特征对应的条件概率会变成0，这会导致零概率问题、过拟合、信息损失。

拉普拉斯修正通过在所有计数上添加一个小的平滑项，处理在训练数据中出现的概率为0的情况。

令N表示训练集D中可能的类别数， $N_{i}$ 表示第i个属性可能的取值数，则贝叶斯公式修正为：

$P(C)=\frac{\left |D_{c} \right |+1}{\left | D \right |+N}$

四、应用：垃圾邮件过滤

训练集：

ham为正常邮件信息，spam为垃圾邮件信息。

1. 加载数据集

def createVocabList(dataSet):
    vocabSet = set([])  # set集合元素不重复
    for document in dataSet:
        vocabSet = vocabSet | set(document)  # 取并集
    return list(vocabSet)

2. 数据预处理

def setOfWords2Vec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)  # 创建一个其中所含元素都为0的向量
    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  # 返回文档向量

3. 朴素贝叶斯训练

def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)  
    numWords = len(trainMatrix[0])  
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 文档属于垃圾邮件类的概率
    p0Num = np.ones(numWords)
    p1Num = np.ones(numWords)  # 词条出现数初始为1,拉普拉斯平滑
    p0Denom = 2.0
    p1Denom = 2.0  # 分母初始为2 ,拉普拉斯平滑
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:  # 统计属于侮辱类的条件概率所需的数据
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        else:  # 统计属于非侮辱类的条件概率所需的数据，即P(w0|0),P(w1|0),P(w2|0)···
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = np.log(p1Num / p1Denom)
    p0Vect = np.log(p0Num / p0Denom)  
    return p0Vect, p1Vect, pAbusive  # 返回属于正常邮件类的条件概率数组，属于侮辱垃圾邮件类的条件概率数组，文档属于垃圾邮件类的概率

4. 分类

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)
    p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0

运行结果：

完整代码：

import numpy as np
import re
import random


def createVocabList(dataSet):
    vocabSet = set([])
    for document in dataSet:
        vocabSet = vocabSet | set(document)  # 取并集
    return list(vocabSet)


def setOfWords2Vec(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  # 返回文档向量


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


def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)  # 计算训练的文档数目
    numWords = len(trainMatrix[0])  # 计算每篇文档的词条数
    pAbusive = sum(trainCategory) / float(numTrainDocs)  # 文档属于垃圾邮件类的概率
    p0Num = np.ones(numWords)
    p1Num = np.ones(numWords)  # 创建numpy.ones数组,词条出现数初始化为1,拉普拉斯平滑
    p0Denom = 2.0
    p1Denom = 2.0  # 分母初始化为2 ,拉普拉斯平滑
    for i in range(numTrainDocs):
        if trainCategory[i] == 1:
            p1Num += trainMatrix[i]
            p1Denom += sum(trainMatrix[i])
        else:
            p0Num += trainMatrix[i]
            p0Denom += sum(trainMatrix[i])
    p1Vect = np.log(p1Num / p1Denom)
    p0Vect = np.log(p0Num / p0Denom)
    return p0Vect, p1Vect, pAbusive


def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + np.log(pClass1)
    p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0


def textParse(bigString):  # 将字符串转换为字符列表
    listOfTokens = re.split(r'\W*', bigString)  # 将特殊符号作为切分标志进行字符串切分，即非字母、非数字
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]  # 除了单个字母，例如大写的I，其它单词变成小写


def spamTest():
    docList = []
    classList = []
    fullText = []
    for i in range(1, 21):
        wordList = textParse(open('D:/Tencent/QQ/email/spam/%d.txt' % i, 'r').read())
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(1)  # 标记垃圾邮件，1表示垃圾文件
        wordList = textParse(open('D:/Tencent/QQ/email/ham/%d.txt' % i, 'r').read())
        docList.append(wordList)
        fullText.append(wordList)
        classList.append(0)  # 标记正常邮件，0表示正常文件
    vocabList = createVocabList(docList)
    trainingSet = list(range(40))
    testSet = []
    for i in range(6):  # 从40个邮件中，随机挑选出34个作为训练集,6个做测试集
        randIndex = int(random.uniform(0, len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del (trainingSet[randIndex])
    trainMat = []
    trainClasses = []
    for docIndex in trainingSet:
        trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClasses))
    errorCount = 0  # 错误分类计数
    for docIndex in testSet:  # 遍历测试集
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])  # 测试集的词集模型
        if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:  # 如果分类错误
            errorCount += 1  # 错误计数加1

    print('错误率为：%.2f%%' % (float(errorCount) / len(testSet) * 100))


if __name__ == '__main__':
    spamTest()

五、总结

朴素贝叶斯算法的优缺点

优点：

适用于大规模数据集
对小规模数据表现良好
对缺失数据不敏感，常用于文本分类
能处理多类别问题

缺点：

属性之间相互独立：朴素贝叶斯的核心假设是特征之间相互独立，这在实际问题中往往并不成立，特别是在特征之间存在一定关联性的情况下，算法可能失效。
不适用于连续型特征
需要足够的训练数据：当数据量较小时，可能出现欠拟合问题。
处理类别不平衡的问题较为困难：当类别分布不平衡时，朴素贝叶斯可能会偏向于出现频率较高的类别。

朴素贝叶斯算法是一种简单、高效、易于实现的器学习算法，适用于文本分类等自然语言处理任务。在实际应用中，我们可以使用不同变体的朴素贝叶斯算法来处理不同类型的数据。

Li.879

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
机器学习 | 朴素贝叶斯

朴素贝叶斯分类器是基于贝叶斯定理的概率分类算法。其核心思想是通过计算后验概率来进行分类。对于给定的输入特征，通过计算每个可能类别的后验概率，选择具有最高概率的类别作为输出。朴素贝叶斯分类器的关键在于属性条件独立性假设。朴素贝叶斯算法的优缺点适用于大规模数据集对小规模数据表现良好对缺失数据不敏感，常用于文本分类能处理多类别问题属性之间相互独立：朴素贝叶斯的核心假设是特征之间相互独立，这在实际问题中往往并不成立，特别是在特征之间存在一定关联性的情况下，算法可能失效。不适用于连续型特征。
复制链接

扫一扫