朴素贝叶斯

最新推荐文章于 2024-10-02 10:53:34 发布

席惜兮兮

最新推荐文章于 2024-10-02 10:53:34 发布

阅读量204

点赞数

文章标签： python

本文链接：https://blog.csdn.net/huanghuali_/article/details/121591706

版权

文章目录

一、基于贝叶斯决策理论的分类方法
二、条件概率
三、使用python进行文本分类
六、示例：使用朴素贝叶斯过滤垃圾邮件
- 1.准备数据：切分文本
- 2.测试算法：使用朴素贝叶斯进行交叉验证
总结

提示：参考书籍图灵程序设计丛书《机器学习实战》

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

贝叶斯决策理论的核心思想是：选择高概率所对应的类别，选择具有最高概率的决策。有时也被总结成“多数占优”的原则。

现在我们有一个数据集，它由两类数据组成，数据分布如图：
在这里插入图片描述
其中，假设两个概率分布的参数已知，并用p1(x,y)表示当前数据点(x,y)属于类别1（图中圆点）的概率；用p2(x,y)表示当前数据点(x,y)属于类别2（图中三角形）的概率。
具体到实例，对于一个数据点(x,y)，可以用如下规则判定它的类别：
若p1(x,y)>p2(x,y)，那么点(x,y)被判定为类别1。
若p1(x,y)<p2(x,y)，那么点(x,y)被判定为类别2。

（使用条件概率分类）
当然，在实际情况中，单单依靠以上的判定无法解决所有的问题，因为p1(x,y),p2(x,y)还不是贝叶斯决策理论的所有内容，使用p1(x,y)和p2(x,y) 只是为了简化描述。更多的，我们使用p(ci|x,y) 来确定给定坐标的点(x,y)，该数据点来自类别ci的概率是多少。具体地，应用贝叶斯准则可得到，该准则可以通过已知的三个概率值来计算未知的概率值：

在这里插入图片描述
则以上判定法则可转化为：
若p(c1|x,y)>p(c2|x,y)，那么点(x,y)被判定为类别c1。
若p(c1|x,y)<p(c2|x,y)，那么点(x,y)被判定为类别c2。
下面看一下什么是条件概率。

二、条件概率

有一个装了 7 块石头的罐子，其中 3 块是白色的，4 块是黑色的。如果从罐子中随机取出一块石头，那么是白色石头的可能性是多少？显然，取出白色石头的概率为 3/7 ，取到黑色石头的概率是 4/7 。我们使用 P(white) 来表示取到白色石头的概率，其概率值可以通过白色石头数目除以总的石头数目来得到。
在这里插入图片描述
如果这 7 块石头如下图所示，放在两个桶中，那么上述概率应该如何计算？

要计算 P(white) 或者 P(black) ，显然，石头所在桶的信息是会改变结果的，这就是条件概率。假定计算的是从 B 桶取到白色石头的概率，这个概率可以记作 P(white|bucketB) ，我们称之为 “在已知石头出自 B 桶的条件下，取出白色石头的概率”。很容易得到，P(white|bucketA) 值为 2/4 ，P(white|bucketB)的值为 1/3 。
条件概率计算公式：
P(white|bucketB) = P(white and bucketB) / P(bucketB)
我们来看看上述公式是否合理。首先，用B桶中灰色石头个数除以两个桶中总的个数，得到P(white|bucketB)=1/7。由于B桶有3块石头，总数为7，于是P(bucketB)等于3/7.所以
P(white|bucketB) = P(white and bucketB) / P(bucketB)=（1/7）/（3/7）=1/3。这个公式
虽然对于这个简单例子来说有点复杂，但存在更多特征时是非常有效的。用代数方法计算条件概率时，该公式也很有用。
另外一种有效计算条件概率的方法称为贝叶斯准则。贝叶斯准则告诉我们如何交换条件概率中的条件与结果，即如果已知 P(x|c)，要求 P(c|x)，那么可以使用下面的计算方法:
在这里插入图片描述

三、使用python进行文本分类

1.准备数据：从文本中构建词向量

词表到向量的转换函数

#朴素贝叶斯
import numpy as np
# 数据可视化
import matplotlib.lines as mlines
import matplotlib.pyplot as plt
import matplotlib as mpl
from numpy import *
import operator
from os import listdir

import numpy as np
from functools import reduce

#词表到向量的转换函数
#创建一些实验样本
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

#创建一个包含在所有文档中出现的不重复词的列表
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:#遍历文档中所有单词，如果出现词汇表中的单词，则将输出文档向量中对应的值设置为1
        if word in vocabList:
            returnVec[vocabList.index(word)] = 1
        else:
            print("the word: %s is not in my Vocabulary!" % word)
    #输出的是向量文档，向量的每个元素为1或0，分别表示词汇表中的单词在输入文档中是否出现
    return returnVec

if __name__ == '__main__':
    # 词表到向量的转换函数
    # 创建一些实验样本
    listOPosts, listClasses =loadDataSet()
    # 创建一个包含在所有文档中出现的不重复词的列表
    myVocabList =createVocabList(listOPosts)
    print(myVocabList)
    returnVec=setOfWords2Vec(myVocabList,listOPosts[0])
    print(returnVec)

测试结果
在这里插入图片描述

2.训练算法：从词向量计算概率

前面介绍了如何将一组单词转换为一组数字，接下来看看如何使用这些数字计算概率。

现在已经知道一个词是否出现在一篇文档中，也知道该文档所属的类别。接下来我们重写贝叶斯准则，将之前的 x, y 替换为 w，表示这是一个向量，即它由多个值组成。在这个例子中，数值个数与词汇表中的词个数相同。
在这里插入图片描述
我们使用上述公式，对每个类计算该值，然后比较这两个概率值的大小。首先可以通过类别 i (侮辱性留言或者非侮辱性留言)中的文档数除以总的文档数来计算概率 p ( c i ) 。接下来计算p(w/ci)，这里就要用到朴素贝叶斯的假设。如果将w展开为一个个独立特征，那么将上述概率写作p（w0,w1,w2…wn/ci）。这里的假设所有词相互独立，该假设也称作条件独立性假设，它意味着可以使用p(w0/ci)p(w1/ci)p(w2/ci)…p(wn/ci)来计算上述概率，这就极大地简化了计算的过程。

#朴素贝叶斯分类器训练函数
def trainNB0(trainMtrix,trainCategory):
    numTrainDocs=len(trainMtrix)                    #计算训练的文档数目
    numWords=len(trainMtrix[0])                     #计算每篇文章的词条数
    pAbusive=sum(trainCategory)/float(numTrainDocs) #文档属于侮辱类的概率
    p0Num=np.zeros(numWords);p1Num=np.zeros(numWords)#创建numpy.zeros数组
    p0Denom=0.0;p1Denom=0.0                          #分母初始化为0.0
    for i in range(numTrainDocs):
        if trainCategory[i]==1:                       #统计属于侮辱类的条件概率
            p1Num+=trainMtrix[i]                        #向量相加
            p1Denom+=sum(trainMtrix[i])               #统计属于非侮辱类的条件概率
        else:
            p0Num+=trainMtrix[i]
            p0Denom+=sum(trainMtrix[i])
    p1Vect=p1Num/p1Denom                            #对每个元素做除法
    p0Vect=p0Num/p1Denom
    #返回属于侮辱类的条件概率
    return p0Vect,p1Vect,pAbusive

if __name__ == '__main__':
    #朴素贝叶斯分类器训练函数
    listOPosts, listClasses = loadDataSet()
    myVocabList = createVocabList(listOPosts)
    trainMat = []
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB0(trainMat, listClasses)
    print(pAb)
    print(p0V)
    print(p1V)

测试结果
在这里插入图片描述

3.测试算法：根据现实情况修改分类器

在利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算
在这里插入图片描述
如果其中一个概率值为 0，那么最后的乘积也为 0。为降低这种影响，可以将所有词的出现数初始化为 1，并将分母初始化为 2
可以将trainNB0()的

p0Num=np.zeros(numWords);
p1Num=np.zeros(numWords)
p0Denom=0.0;
p1Denom=0.0

改成

p0Num = np.ones(numWords) 
p1Num = np.ones(numWords) 
p0Denom = 2.0 # 0 非侮辱性词汇出现总数
p1Denom = 2.0 # 1 侮辱性词汇出现总数

另一个遇到的问题是下溢出，这是由于太多很小的数相乘造成的。当计算乘积
在这里插入图片描述
时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。一种解决办法是对乘积取自然对数。在代数中有 ln(a * b) = ln(a) + ln(b), 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。
在这里插入图片描述
如图给出了函数 f(x) 与 ln(f(x)) 的曲线。可以看出，它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。我们将上述方法添加到分类器中

p1Vect = log(p1Num / p1Denom)
p0Vect = log(p0Num / p0Denom)

代码如下（示例）：

#朴素贝叶斯分类函数
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    p1=sum(vec2Classify*p1Vec)+log(pClass1)
    p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
    if p1>p0:
        return 1
    else:
        return 0

def testingNB():
    listOPosts, listClasses = loadDataSet()
    myVocabList = createVocabList(listOPosts)
    trainMat = []
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
    pv0, pv1, pAb = trainNB0(trainMat, listClasses)
    testEntry=['love','my','dalmation']
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    print(testEntry,'classified as:',classifyNB(thisDoc,pv0,pv1,pAb))
    testEntry=['stupid','garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry, 'classified as:', classifyNB(thisDoc, pv0, pv1, pAb))

if __name__ == '__main__':
    # 朴素贝叶斯分类函数
    testingNB()

测试结果
在这里插入图片描述

4.准备数据：文档词袋模型

目前为止，我们将每个词的出现与否作为一个特征，这可以被描述为词集模型，如果一个词在文档中出现不止一次，这可能意味着包含该词是否出现在文档中所不能表达的某种信息，这种方法被称为词袋模型。在词袋中，每个单词可以出现多次，而在词集中，每个单词只能出现一次。

#朴素贝叶斯词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
    # 创建一个其中所含元素都为0的向量
    returnVec = [0] * len(vocabList)
    # 遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值加1
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

六、示例：使用朴素贝叶斯过滤垃圾邮件

1.准备数据：切分文本

if __name__ == '__main__':
    mysent = "This book is the best book on Python or M.L. I have ever laid eyes upon."
    testSplit = mysent.split()
    print(testSplit)
     #去掉里面除单词，数字外的任意空字符串，可以计算字符串的长度
    import re
    regEx = re.compile('\\W+')
    listOfSent = regEx.split(mysent)
    print(listOfSent)
    #将字符串转换成小写
    result = [tok.lower() for tok in listOfSent if len(tok) > 0]
    print(result)
    
    emailText = open('email/ham/6.txt').read()
    listOfTokens=regEx.split(emailText)

测试结果：
在这里插入图片描述

2.测试算法：使用朴素贝叶斯进行交叉验证

#文件解析及完整的垃圾邮件测试函数
def textParse(bigSreing):
    import re
    listOfTokens = re.split(r'\w*', bigSreing)
    return (tok.lower() for tok in listOfTokens if len(tok) > 2)

def spamTest():
    docList = [];classList = [];fullText = []       # 每封邮件的词汇表 # 每篇邮件的分类 # 所有邮件的词汇表(一个列表)
    for i in range(1, 26):
        # 导入文件夹 spam 下的文件，切分，解析数据，并归类为 1 类别
        wordList = textParse(open('email/spam/%d.txt' % i).read())              #导入解析文本文件
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        # 导入文件夹 ham 下的文件切分，解析数据，并归类为 0 类别
        wordList = textParse(open('email/ham/%d.txt' % i,'r',encoding='UTF-8',errors='ignore').read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList = createVocabList(docList) # 创建词汇表（去重）
    trainingSet = list(range(50));testSet = []#训练集 测试集
    for i in range(10):                                                         #随机构建训练集
        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(array(trainMat), array(trainClasses))
    errorCount = 0
    for docIndex in testSet:                                                    ## 遍历测试集，对每封邮件进行分类
        wordVector = setOfWords2Vec(vocabList, docList[docIndex])
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != \
                classList[docIndex]:
            errorCount += 1
    print("the error rate is : ", float(errorCount) / len(testSet))

if __name__ == '__main__':
     spamTest()

测试结果：
在这里插入图片描述
spamTest()输出10封随机选择的电子邮件上的分类错误率。既然这些电子邮件是随机选择的，所以每次输出都会有差别。这边会把错误邮件误判为正常邮件。但不会把正常邮件判断为垃圾邮件,这个不错。

总结

遇到了一个问题：提示直接打开文件错误
在这里插入图片描述
把
wordList = textParse(open(‘email/ham/%d.txt’ % i).read())
改成
wordList = textParse(open(‘email/ham/%d.txt’ % i,‘r’,encoding=‘UTF-8’,errors=‘ignore’).read())