【基于概率论的分类方法：朴素贝叶斯】

Bravo٩

于 2021-11-28 18:37:38 发布

阅读量682

点赞数

分类专栏：机器学习

本文链接：https://blog.csdn.net/bravoe/article/details/121593027

版权

贝叶斯决策理论条件概率词袋模型垃圾邮件过滤 Python实现

关键词由CSDN通过智能技术生成

机器学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

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

4.5.4 准备数据：文档词袋模型

4.6 使用朴素贝叶斯过滤垃圾邮件

4.6.1 准备数据：切分文本

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

朴素贝叶斯

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

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

适用数据类型：标称型数据。

朴素贝叶斯是贝叶斯决策理论的一部分。先简单了解一下贝叶斯决策理论，假设有两类数据的统计参数，p1(x,y)表示数据点(x,y)属于类别1的概率，p2(x,y)表示数据点(x,y)属于类别2的概率。那么对于一个新的数据点(x,y)，可以用下面的规则来判断它的类别：

如果 p1(x,y) > p2(x,y) ，那么类别为1。

如果 p2(x,y) > p1(x,y) ，那么类别为2。

也就是说，我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

4.2 条件概率

另一种有效计算条件概率的方法称为贝叶斯准则。贝叶斯准则告诉我们如何交换概率中的条件与结果，即如果已知p(x|c)，要求p(c|x)，则可使用：

4.3 使用条件概率来分类

前面4.1提到的贝叶斯决策理论要求计算两个概率p1(x,y)和p2(x,y)，且：

如果 p1(x,y) > p2(x,y) ，那么类别为1。

如果 p2(x,y) > p1(x,y) ，那么类别为2。

但以上两个准则并不是贝叶斯决策理论的所有内容。使用p1( )和p2( )只是为了尽可能简化描述，而真正需要计算和比较的是p(c1|x,y)和p(c2|x,y)。其表示的是：给定某个x、y表示的数据点，那么该数据点来自类别c1和来自类别c2的概率为多少？注意这些概率与刚才给出的概率p(x,y|c1)并不一样，不过可以使用贝叶斯准则来交换概率中的条件和结果。具体地，应用贝叶斯准则可以得到：

$p(ci|x,y) = \frac{p(x,y|ci)p(ci)}{p(x,y)}$

则贝叶斯准则可以定义为：

如果p(c1|x,y) > p(c2|x,y)，那么属于类别c1。

如果p(c2|x,y) > p(c1|x,y)，那么属于类别c2。

使用贝叶斯准则，可以通过已知的三个概率值来计算未知的概率值。

4.4 使用朴素贝叶斯进行文档分类

朴素贝叶斯的一般过程

（1）收集数据：可以使用任何方法。

（2）准备数据：需要数值型或者布尔型数据。

（3）分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。

（4）训练算法：计算不同的独立性特征的条件概率。

（5）测试算法：计算错误率。

（6）使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。

由统计学知，如果每个特征需要N个样本，那么对于10个特征将需要 $N^1^0$ 个样本，对于包含1000个特征则需要 $N^{1000}$ 个样本。可以看到，所需要的样本数会随着特征数目增大而迅速增长。

如果特征之间相互独立，那么样本数就可以从 $N^{1000}$ 减少到1000*N。所谓独立指的是统计意义上的独立，即一个特征或者单词出现的可能性与它的其他单词相邻没有关系。朴素贝叶斯分类器中假设每个特征同等重要。

4.5 使用Python进行文本分类

要从文本中获取特征，需要先拆分文本。特征是来自文本的词条，一个词条是字符的任意组合。可将其想象为单词，也可使用非单词词条。然后将每一个文本片段表示为一个词条向量，其中值为1表示词条出现在文档中，0表示词条未出现。

4.5.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 is abusive, 0 not   即1代表侮辱性文字，0代表正常言论
    return postingList,classVec  #第一个变量进行词条切分后的文档集合，第二个变量是一个类别标签的集合（有两类：侮辱性 1 和非侮辱性 0 ）
                 
def createVocabList(dataSet): #创建一个包含在所有文档中出现的不重复词的列表
    vocabSet = set([])  #create empty set  创建空集合
    for document in dataSet:   #将每篇文档返回的新词集合添加到该集合中
        vocabSet = vocabSet | set(document) #union of the two sets  操作符|用于求两个集合的并集，也为一个按位或（OR）操作符
    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

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

即利用上述得到的数字计算概率。

#朴素贝叶斯分类器训练函数
def trainNB0(trainMatrix,trainCategory): #输入为文档矩阵及每篇文档类别标签所构成的向量
    numTrainDocs = len(trainMatrix)  #训练集的数量
    numWords = len(trainMatrix[0])   #词条的长度
    pAbusive = sum(trainCategory)/float(numTrainDocs)  #统计侮辱类文档的概率
    p0Num = ones(numWords); p1Num = ones(numWords)      #change to ones()
    p0Denom = 2.0; p1Denom = 2.0                        #分母初始化为 2.0
    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 = log(p1Num/p1Denom)          #change to log()
    p0Vect = log(p0Num/p0Denom)          #change to log()
    return p0Vect,p1Vect,pAbusive

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

def testingNB():
    listOPosts,listClasses = loadDataSet()
    #创建一个包含在所有文档中出现的不重复词的列表
    myVocabList = createVocabList(listOPosts)
    trainMat=[]
    for postinDoc in listOPosts:
        trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
    p0V,p1V,pAb = trainNB0(array(trainMat),array(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))
 
#文件解析函数
def textParse(bigString):           #input is big string, #output is word list
    import re                       #正则表达式工具
    #分割数据，其分隔符是除单词、数字外任意的字符串
    listOfTokens = re.split(r'\W*', bigString)
    #单词全部转小写，过滤没用的短字符串
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]
#垃圾邮件测试函数
def spamTest():
    docList = []           #存放每个邮件的单词向量
    classList = []         #存放邮件对应的标签
    fullText = []
    for i in range(1, 26):
        #读取侮辱类（spam中存储）邮件，并生成单词向量
        wordList = textParse(open('./email/spam/%d.txt' % i).read())
        docList.append(wordList)               #将单词向量存放到docList中
        fullText.extend(wordList)
        classList.append(1)                    #存放对应的类标签,侮辱类为1
        # 读取非侮辱类（ham中存储）邮件，并生成单词向量
        wordList = textParse(open('./email/ham/%d.txt' % i).read())
        docList.append(wordList)               #将单词向量存放到docList中
        fullText.extend(wordList)
        classList.append(0)                    #存放对应的类标签,非侮辱类为0
    #由所有的单词向量生成词库
    # xx = len(docList)
    # yy = list(range(xx))
    # print(xx,yy)
    vocabList = createVocabList(docList)
    trainSet = list(range(50))                      #产生0-49的50个数字
    testIndex = []                                  #存放测试数据的下标
    for i in range(10):
        #从0-49之间随机生成一个下标
        randIndex = int(random.uniform(0, len(trainSet)))
        testIndex.append(trainSet[randIndex])  #提取对应的数据作为测试数据
        del(trainSet[randIndex])              #删除对应的数据，避免下次再选中
    trainDataSet = []                          #存放训练数据（用于词集方法）
    trainClasses = []                          #存放训练数据标签（用于词集方法）
    trainDataSet1 = []                        #存放训练数据（用于词袋方法）
    trainClasses1 = []                        #存放训练数据标签（用于词袋方法）
    for docIndex in trainSet:
        #提取训练数据(词集方法)
        trainDataSet.append(setOfWords2Vec(vocabList, docList[docIndex]))
        #提取训练数据标签
        trainClasses.append(classList[docIndex])
 
        #提取训练数据(词袋方法)
        trainDataSet1.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses1.append(classList[docIndex])
    #开始训练
    p0V, p1V, pSpam = trainNB0(array(trainDataSet), array(trainClasses))
    errorCount = 0                     #统计测试时分类错误的数据个数
    p0V_1, p1V_1, pSpam1 = trainNB0(array(trainDataSet1), array(trainClasses1))
    errorCount1 = 0
    #开始测试分类器
    for Index in testIndex:  # classify the remaining items
        #print("classification:", Index)
        wordVector = setOfWords2Vec(vocabList, docList[Index])   #数据预处理
        # 测试分类器,如果分类不正确，错误个数加1
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[Index]:
            errorCount += 1
        wordVector1 = bagOfWords2VecMN(vocabList, docList[Index])  #数据预处理
        if classifyNB(array(wordVector1), p0V_1, p1V_1, pSpam1) != classList[Index]:
            errorCount1 += 1
    #输出分类错误率
    print('(set)的错误率: ', float(errorCount) / len(testIndex))
    print('(bag)的错误率: ', float(errorCount1) / len(testIndex))

4.5.4 准备数据：文档词袋模型

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

#朴素贝叶斯词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            #每个词在词袋中可以出现多次，出现则进行累加
            returnVec[vocabList.index(word)] += 1
    return returnVec

4.6 使用朴素贝叶斯过滤垃圾邮件

使用朴素贝叶斯解决问题时，需要先从文本内容得到字符串列表，然后生成词向量。

使用朴素贝叶斯对电子邮件进行分类

（1）收集数据：提供文本文件。

（2）准备数据：将文本文件解析成词条向量。

（3）分析数据：检查词条确保解析的正确性。

（4）训练算法：使用我们之前建立的trainNB0()函数。

（5）测试算法：使用classifyNB()，并且构建一个新的测试函数来计算文档集的错误率。

（6）使用算法：构建一个完整的程序对一组文档进行分类，将错分的文档输出到屏幕上。

4.6.1 准备数据：切分文本

！！！！！！！！！！环境出现了点问题，29日内会进行完善！！！！！！！！！

Bravo٩

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【基于概率论的分类方法：朴素贝叶斯】

4.1 基于贝叶斯决策理论的分类方法朴素贝叶斯优4点：在数据较少的情况下仍然有效，可以处理多类别问题。缺点：对于输入数据的准备方式较为敏感。适用数据类型：标称型数据。朴素贝叶斯是贝叶斯决策理论的一部分。先简单了解一下贝叶斯决策理论，假设有两类数据的统计参数，p1(x,y)表示数据点(x,y)属于类别1的概率，p2(x,y)表示数据点(x,y)属于类别2的概率。那么对于一个新的数据点(x,y)，可以用下面的规则来判断它的类别：如果p1(x,y) >p2(x,y) ，..
复制链接

扫一扫

专栏目录