《机器学习实战》——第4章基于概率论的分类方法：朴素贝叶斯

最新推荐文章于 2022-10-03 16:32:07 发布

海鸥丸拉面

最新推荐文章于 2022-10-03 16:32:07 发布

阅读量380

点赞数

本文链接：https://blog.csdn.net/fjyalzl/article/details/126821272

版权

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

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

4.2 条件概率

4.3 使用条件概率来分类

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

4.5 使用Python进行文本分类

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

我们将把文本看成单词向量或者词条向量，也就是说将句子转换为向量。考虑出现在所有文档中的所有单词，再决定将哪些词纳入词汇表或者说所要的词汇集合，然后必须要将每一篇文档转换为词汇表上的向量。新建bayes.py文件，添加代码：


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:
            returnVec[vocabList.index(word)] = 1
        else: print("the word: %s is not in my Vocabulary!" % word)
    return returnVec

函数 loadDataSet（）创建了一些实验样本，返回的第一个变量是进行词条切分后的文档集合，第二个变量是一个类别标签的集合。

下一个函数 createVocabList（）会创建一个包含在所有文档中出现的不重复词的列表，为此使用了Python的set数据类型。将词条列表输给set构造函数，set就会返回一个不重复词表。首先，创建一个空集合，然后将每篇文档返回的新词集合添加到该集合中。操作符 | 用于求两个集合的并集。

获得词汇表后，便可以使用函数 setOfWords2vec（），该函数的输人参数为词汇表及某个文档，输出的是文档向量，向量的每一元素为1或0，分别表示词汇表中的单词在输人文档中是否出现。函数首先创建一个和词汇表等长的向量，并将其元素都设置为0。接着，遍历文档中的所有单词，如果出现了词汇表中的单词，则将输出的文档向量中的对应值设为1。一切都顺利的话，就不需要检查某个词是否还在vooabList中，后边可能会用到这一操作。

import bayes
listOposts,listClasses = bayes.loadDataSet()
myVocabList = bayes.createVocabList(listOposts)
print(myVocabList)

可以看到给出了文档中出现的不重复词的列表。

import bayes
listOposts,listClasses = bayes.loadDataSet()
myVocabList = bayes.createVocabList(listOposts)
print(bayes.setOfWords2Vec(myVocabList,listOposts[0]))
print(bayes.setOfWords2Vec(myVocabList,listOposts[3]))

该函数使用词汇表或者想要检查的所有单词作为输入，然后为其中每一个单词构建一个特征。

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

$p\left(c_{i} \mid \boldsymbol{w}\right)=\frac{p\left(\boldsymbol{w} \mid c_{i}\right) p\left(c_{i}\right)}{p(\boldsymbol{w})}$

函数伪代码如下：

添加下面的代码到bayes.py文件中。

def trainNB0(trainMatrix,trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory)/float(numTrainDocs)
    p0Num = zeros(numWords); p1Num = zeros(numWords)      #change to ones()
    p0Denom = 0.0; p1Denom = 0.0                        #change to 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

代码函数中的输人参数为文档矩阵trainMatrix，以及由每篇文档类别标签所构成的向量traincategory。首先，计算文档属于侮辱性文档(class=1)的概率，即P(1)。因为这是一个二类分类问题，所以可以通过1-P(1)得到P(0)。对于多于两类的分类问题，则需要对代码稍加修改。

计算p(wi l c1 )和p(wi | c0)，需要初始化程序中的分子变量和分母变量。由于w中元素如此众多，因此可以使用NumPy数组快速计算这些值。上述程序中的分母变量是一个元素个数等于词汇表大小的NumPy数组。在for循环中，要遍历训练集trainMatrix中的所有文档。一旦某个词语（侮辱性或正常词语）在某一文档中出现，则该词对应的个数(p1Num或者p0Num)就加1，而且在所有的文档中，该文档的总词数也相应加1。对于两个类别都要进行同样的计算处理。

最后，对每个元素除以该类别中的总词数。利用NymPy可以很好实现，用一个数组除以浮点数即可。最后，函数会返回两个向量和一个概率。

import bayes
from numpy import *
#从预先加载值中调入数据
listOposts,listClasses = bayes.loadDataSet()
#构建一个包含所有词的列表myVocabList
myVocabList = bayes.createVocabList(listOposts)
trainMat = []
#使用词向量填充trainMat列表。
for postinDoc in listOposts:
    trainMat.append(bayes.setOfWords2Vec(myVocabList,postinDoc))
p0V,p1V,pAB = bayes.trainNB0(trainMat,listClasses)
print(pAB)
print(p0V)
print(p1V)

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

为降低概率计算误差，将所有词的出现次数初始化为1，分母初始化为2。修改trainNB0（）函数部分代码。

计算误差外，还有一个问题是下溢出，这是由于太多很小的数相乘造成的。一种解决方法是对乘积取自然对数。观察下面的图像可以知道，虽然它们取值不同，但在相同区域内的增减性相同，不影响最终结果。修改return前的代码，将上述做法进行应用：

添加下面的代码到bayes.py中：

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

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,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))

函数有4个输入：要分类的向量 vec2Classify 以及使用函数 trainNB0() 计算得到的三个概率。使用NumPy的数组计算两向量相乘的结果。相乘是指对应元素相乘，即先将两个向量中的第1个元素相乘，然后将第2个元素相乘，以此类推。接下来将词汇表中所有词的对应值相加，然后将该值加到类别的对数概率上。最后，比较类别的概率返回大概率对应的类别标签。

第二个函数是一个便利函数，该函数封装所有操作，以节省输入时间。

import bayes
bayes.testingNB()

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
regEx = re.compile('\W+')
mySent = 'This book is the best book on Python or M.L.I have ever laid eyes upon.'
listOfTokens = regEx.split(mySent)
print(listOfTokens)

计算每个字符串长度，只返回长度大于0的字符：

print([tok for tok in listOfTokens if len(tok) > 0])

类似的方法，可以将字符串全部转换成小写 (.lower()) 或者大写 (.upper())，借助这些方法可以达到目的。

print([tok.lower() for tok in listOfTokens if len(tok) > 0])

下面是一个对电子邮件进行处理的结果：

import bayes
from numpy import *
import re
regEx = re.compile('\W+')
emailText = open('email/ham/6.txt').read()
listOfTokens = regEx.split(emailText)
print([tok.lower() for tok in listOfTokens if len(tok) > 3])

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，最后给出总的错误百分比。

函数 spamTest() 会输出在10封随机选择的电子邮件上的分类错误率，因此每次输出结果会有所差别。

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

4.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

上述代码类似函数 spamTest ()，不过添加了新的功能。代码中引人了一个辅助函数 calcMostFreq()。该函数遍历词汇表中的每个词并统计它在文本中出现的次数，然后根据出现次数从高到低对词典进行排序，最后返回排序最高的100个单词。
下一个函数 localwords() 使用两个RSS源作为参数。RSS源要在函数外导入，这样做的原因是RSS源会随时间而改变。如果想通过改变代码来比较程序执行的差异，就应该使用相同的输入。重新加载RSS源就会得到新的数据，但很难确定是代码原因还是输入原因导致输出结果的改变。函数localwords() 与 spamTest() 函数几乎相同，区别在于这里访问的是RSS源而不是文件。然后调用函数 calcMostFreq() 来获得排序最高的100个单词并随后将它们移除。函数的剩余部分与 spamTest() 基本类似，不同的是最后一行要返回下面要用到的值。