机器学习第四章朴素贝叶斯

最新推荐文章于 2024-04-30 09:15:25 发布

m0_50882524

最新推荐文章于 2024-04-30 09:15:25 发布

阅读量594

点赞数

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

本文链接：https://blog.csdn.net/m0_50882524/article/details/126970438

版权

文章目录

引言
4.1基于贝叶斯决策理论的分类方法
4.2条件概率
4.3使用条件概率进行分类
4.4使用朴素贝叶斯进行文档分类
4.5使用Python进行文本分类
4.6示例：使用朴素贝叶斯过滤垃圾邮件
4.6.1准备数据：切分文本
- 4.6.2测试算法：使用贝叶斯进行交叉验证
4.7 示例：朴素贝叶斯分类器从个人广告中获取区域倾向
- 4.7.14.7.1 收集数据：导入RSS源

引言

概率论是许多机器学习算法的基础，所以深刻理解这一主题就显得十分重要。第3章在计算特征值取某个值的概率时涉及一些概率知识，那里我们先统计特征在数据集中取某个特定值的次数，后除以数据集的实例，就得到特征取该值的概率

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

朴素贝叶斯优缺点
优点：在数据较少的情况下仍然有效，可以处理多类别问题。
缺点：对于输入数据的准备方式较为敏感。
适用数据类型：标称型数据

4.2条件概率

这些内容可以直接在开设的概率论与统计这门课中，都有所讲到。

主要就是条件概率这一个公式：
$\mid x)=\frac{p(c \mid x) p(c)}{p(x)}$

4.3使用条件概率进行分类

应用贝叶斯准则得到贝叶斯分类准则为：
1.如果pc1大于pc2，则类别属于c1；
2.如果pc1小于pc2，则类别属于c2；
$p\left(c_{i} \mid x, y\right)=\frac{p\left(x, y \mid c_{i}\right) p\left(c_{i}\right)}{p(x, y)}$

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

朴素贝叶斯的一般过程：
1、收集数据：可以使用任何方法。本章使用RSS源。
2、准备数据：需要数值型或者布尔型数据。
3、分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。
4、训练算法：计算不同的独立特征的条件概率。
5、测试算法：计算错误率。
6、使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任何的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。

4.5使用Python进行文本分类

要从文本中获取特征，需要先拆分文本。
这里的特征是来自文本的词条(token), 一个词条是字符的任意组合。可以把词条想象为单词，也可以使用非单词词条，如URL、IP址或者任意其他字符串。然后将每一个文本片段表示为一个词条向量，其中值为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
    return postingList,classVec

def createVocabList(dataSet):
    vocabSet = set([])  #create empty set
    for document in dataSet:
        vocabSet = vocabSet | set(document) #union of the two sets
    return list(vocabSet)
 
def setOfWords2Vec(vocabList, inputSet):
    #创建列表值全为零
    returnVec = [0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            #index()在列表中查找某个元素并输出对应的索引值(位置)，
            #这里是在现有列表中找到了，则对应位置值置去
            returnVec[vocabList.index(word)] = 1
        else: print( "the word: %s is not in my Vocabulary!" %word)
    return returnVec

listOPosts,listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
print(myVocabList)
#第一句
print(setOfWords2Vec(myVocabList,listOPosts[0] ))

实验结果如下
在这里插入图片描述
创建一个字典，然后我们的句子中用到的字，将字典对应位置标记为1 ，没用到的位置标记为0.

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

函数伪代码如下：
在这里插入图片描述
实现代码如下所示

def trainNB0(trainMatrix,trainCategory):
    #计算训练的文档数目
    numTrainDocs = len(trainMatrix)
    #计算每篇文档的词条数
    numWords = len(trainMatrix[0])
    #文档属于侮辱类的概率，算的是侮辱类样本占总样本的个数
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    
    #ones()以创建任意维度和元素个数的数组，其元素值均为1
    #这里是进行了优化，避免原代码设置为零时，计算出现某一个条件概率为零时，计算结果为零。
    #这个改进被称为拉普拉斯平滑
    #另外一个改进是取了对数，防止计算时出现下溢出。
    #p0Num为非侮辱类情况下的条件概率，（所有的）
    p0Num = ones(numWords); p1Num = ones(numWords)      #change to ones() 
    p0Denom = 2.0; p1Denom = 2.0                        #change to 2.0
    
    for i in range(numTrainDocs):
        #如果是侮辱类
        if trainCategory[i] == 1:
            #p1Num是向量，所有成员一起算
            p1Num += trainMatrix[i]
            #sum(iterable[, start])，sum()最后求得的值 = 可迭代对象里面的数加起来的总和(字典:key值相加)+ start的值
            #统计侮辱类样本单词的个数
            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
    #生成数据列表
postingList,classVec = loadDataSet()
#生成词汇表
myVocabList = createVocabList(postingList)
#存储样本产生的词向量
trainMat = []
#将样本转为词向量，并存储到tarinMat中
for postinDoc in postingList:
    #append(object) 是将一个对象作为一个整体添加到列表中，添加后的列表比原列表多一个元素，
    # 该函数的参数可以是任何类型的对象
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V,p1V,pAb = trainNB0(trainMat, classVec) 

print("p0V"+ str(p0V),end='\n')
print("p1V"+ str(p1V),end='\n')
print("pAb"+ str(pAb),end='\n')

实验输出结果如下所示
在这里插入图片描述

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

在利用贝叶斯分类器对文档进行分类时，会遇到两个问题：
1、需要计算多个概率的乘积，即计算 $p (w 1 ∣ c 1) p (w 2 ∣ c 1)$ 如果其中一个概率为0，则结果为0，为了降低这种影响，我们需要对概率值进行“平滑”处理，即分子加1，分母增加Ni表示第i个属性可能的取值数，这种方法称为拉普拉斯平滑，在本例中每个词可能取值数为2，即所有分母加2，分子加1。
2、许多小数相乘会造成下溢，为了解决这个问题通常采取乘积取对数。
在这里我们对上面的分类器进行修改:

#要分类的向量vec2Classify以及使用函数trainNB0计算的到的三个概率
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):

    #贝叶斯公式的分母
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #element-wise mult
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else: 
        return 0


#生成数据列表
postingList,classVec = loadDataSet()
#生成词汇表
myVocabList = createVocabList(postingList)
#存储样本产生的词向量
trainMat = []
#将样本转为词向量，并存储到tarinMat中
for postinDoc in postingList:
    #append(object) 是将一个对象作为一个整体添加到列表中，添加后的列表比原列表多一个元素，
    # 该函数的参数可以是任何类型的对象
    trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V,p1V,pAb = trainNB0(trainMat, classVec) 

# print("p0V\n"+ str(p0V),end='\n')
# print("p1V\n"+ str(p1V),end='\n')
# print("pAb\n"+ str(pAb),end='\n')

#测试样本1
testEntry = ['love', 'my', 'dalmation']	
#测试样本向量化								
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))				
if classifyNB(thisDoc,p0V,p1V,pAb):
    #执行分类并打印分类结果
    print(testEntry,'属于侮辱类')										
else:
    print(testEntry,'属于非侮辱类')										

#测试样本2
testEntry = ['stupid', 'garbage']							
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))	
if classifyNB(thisDoc,p0V,p1V,pAb):
    print(testEntry,'属于侮辱类')							
else:
    print(testEntry,'属于非侮辱类')

得到的结果如下所示
在这里插入图片描述

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

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

下面代码给出了基于词袋模型的朴素贝叶斯代码。与 setOfWords2Vec() 不同之处是每当遇到一个单词时，它会增加词向量中的对应值，而不只是将对应的数值设为1。

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示例：使用朴素贝叶斯过滤垃圾邮件

4.6.1准备数据：切分文本

对于一个文本字符串，可以使用 string.split() 方法将其切分。

import bayes
mySent = 'This book is the best book on Python or M.L.I have ever laid eyes upon.'
print(mySent.split())

在这里插入图片描述

大部分单词都切分成功，但是与字母连在一起的标点符号也被当成了词的一部分。可以使用正则表达式来切分句子，其中分隔符是除单词、数字外的任意字符串。

import re

mySent='This book is the best book on Python or M.L. I have ever laid eyes upon.'
regEx=re.compile('\\W+')  #除单词数字外的任意字符串
print(regEx.split(mySent))

在这里插入图片描述
现在得到了一系列词组成的词表，但是里面的空字符串需要去除掉。可以计算每个字符串的长度，只返回长度大于零的字符串。并且可以采用python内嵌的字符串全部转换大小写的方法(.lower() or .upper())

import re

mySent='This book is the best book on Python or M.L. I have ever laid eyes upon.'
listOfTokens = re.split(r'\W+',mySent)
print([tok.lower() for tok in listOfTokens if len(tok) > 0])

在这里插入图片描述

4.6.2测试算法：使用贝叶斯进行交叉验证

将文本解析器集成到一个完整的分类器中。将下面的代码添加到bayes.py文件中：

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):
        wordList = textParse(open('email/spam/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList = textParse(open('email/ham/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)  # create vocabulary
    trainingSet = range(50);
    testSet = []  # create test set
    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:  # train the classifier (get probs) trainNB0
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
    errorCount = 0
    for docIndex in testSet:  # classify the remaining items
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        if classifyNB(array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
            errorCount += 1
            print("classification error", docList[docIndex])
    print('the error rate is: ', float(errorCount) / len(testSet))
    # return vocabList,fullText

第一个函数 textParse() 接受一个大字符串并将其解析为字符串列表。该函数去掉少于两个字符的字符串，并将所有字符串转换为小写。
第二个函数 spamTest() 对贝叶斯垃圾邮件分类器进行自动化处理。导人文件夹spam与ham下的文本文件，并将它们解析为词列表。接下来构建一个测试集与一个训练集，两个集合中的邮件都是随机选出的。本例共有50封电子邮件，其中的10封电子邮件被随机选择为测试集。分类器所需要的概率计算只利用训练集中的文档来完成。Python变量 trainingSet 是一个整数列表，其中的值从0到49。接下来，随机选择其中10个文件。选择出的数字所对应的文档被添加到测试集，同时也将其从训练集中剔除。这种随机选择数据的一部分作为训练集，而剩余部分作为测试集的过程称为留存交叉验证( hold-out cross validation )。假定现在只完成了一次迭代，那么为了更精确地估计分类器的错误率，就应该进行多次迭代后求出平均错误率。
接下来的for循环遍历训练集的所有文档，对每封邮件基于词汇表并使用 setOfWords2Vec() 函数来构建词向量。这些词在 traindNB0() 函数中用于计算分类所需的概率。然后遍历测试集，对其中每封电子邮件进行分类。如果邮件分类错误，则错误数加1，最后给出总的错误百分比。

下面是测试代码，产生的结果如下所示
在这里插入图片描述

4.7 示例：朴素贝叶斯分类器从个人广告中获取区域倾向

4.7.14.7.1 收集数据：导入RSS源

安装feedparse包后，尝试打开RSS源：

import bayes
import feedparser
ny = feedparser.parse('http://www.nasa.gov/rss/dyn/image_of_the_day.rss')
print(ny['entries'])
print(len(ny['entries']))

输出了访问条目的信息。

可以构建一个类似于 spamTest() 的函数来对测试过程自动化。

def calcMostFreq(vocabList,fullText):
    import operator
    freqDict = {}
    for token in vocabList:
        freqDict[token]=fullText.count(token)
    sortedFreq = sorted(freqDict.iteritems(), key=operator.itemgetter(1), reverse=True) 
    return sortedFreq[:30]       
 
def localWords(feed1,feed0):
    import feedparser
    docList=[]; classList = []; fullText =[]
    minLen = min(len(feed1['entries']),len(feed0['entries']))
    for i in range(minLen):
        wordList = textParse(feed1['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1) #NY is class 1
        wordList = textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)#create vocabulary
    top30Words = calcMostFreq(vocabList,fullText)   #remove top 30 words
    for pairW in top30Words:
        if pairW[0] in vocabList: vocabList.remove(pairW[0])
    trainingSet = range(2*minLen); testSet=[]           #create test set
    for i in range(20):
        randIndex = int(random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])  
    trainMat=[]; trainClasses = []
    for docIndex in trainingSet:#train the classifier (get probs) trainNB0
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))
    errorCount = 0
    for docIndex in testSet:        #classify the remaining items
        wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
        if classifyNB(array(wordVector),p0V,p1V,pSpam) != classList[docIndex]:
            errorCount += 1
    print('the error rate is: ',float(errorCount)/len(testSet))
    return vocabList,p0V,p1V