机器学习实战笔记（三）朴素贝叶斯

发表于 | 更新于 | 分类于 | 评论数： | 阅读次数：

朴素贝叶斯

朴素贝叶斯是一种基于贝叶斯决策理论的分类方法。
我们用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。

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

贝叶斯推论

条件概率：
$$ p(A|B) = \frac{p(AB)}{p(B)}$$
对条件概率公式和全概率公式进行变形：
$$ p(A|B) = p(A)\frac{p(B|A)}{p(B)}$$

我们把P(A)称为“先验概率”（Prior probability），即在B事件发生之前，我们对A事件概率的一个判断。
P(A|B)称为“后验概率”（Posterior probability），即在B事件发生之后，我们对A事件概率的重新评估。
P(B|A)/P(B)称为“可能性函数”（Likelyhood），这是一个调整因子，使得预估概率更接近真实概率。

后验概率　＝　先验概率 ｘ 调整因子

这就是贝叶斯推断的含义。我们先预估一个“先验概率”，然后加入实验结果，看这个实验到底是增强还是削弱了“先验概率”，由此得到更接近事实的“后验概率”。
在这里，如果“可能性函数”P(B|A)/P(B)>1，意味着“先验概率”被增强，事件A的发生的可能性变大；如果“可能性函数”=1，意味着B事件无助于判断事件A的可能性；如果“可能性函数”<1，意味着”先验概率”被削弱，事件A的可能性变小。

朴素贝叶斯的特点

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

朴素贝叶斯的一般流程

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

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

以在线社区留言板为例：屏蔽侮辱性的言论，构建一个分类器，过滤侮辱性的言论。

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

1
2
3
4
5
6
7
8
9
def loadDataSet():
    postingList = [['my','dog','has','flea','problem','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

创建一个词表

1
2
3
4
5
def createVocabList(dataSet):
    vocabSet = set()    #创建一个空集
    for document in dataSet:
        vocabSet = vocabSet | set(document)  #创建两个集合的并集
    return  list(vocabSet)

将词表转化为向量

1
2
3
4
5
6
7
8
9
#遍历查看该单词是否出现，出现该单词则将该单词置1
def setOfWordsVec(vocabList, inputSet):
    returnVec = [0] * len(vocabList)   #创建一个其中所含元素都为0的向量
    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

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

利用贝叶斯准则计算概率，伪代码如下所示：

1
2
3
4
5
6
7
8
9
计算每个类别中的文档数目
对每篇训练文档：
    对每个类别：
        如果词条出现在文档中→ 增加该词条的计数值
        增加所有词条的计数值
    对每个类别：
        对每个词条：
            将该词条的数目除以总词条数目得到条件概率
返回每个类别的条件概率

python实现的朴素贝叶斯训练函数如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#朴素贝叶斯分类器训练函数
from numpy import *
def trainNB0(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])       #计算每篇文档的词条数
    #侮辱性文件出现的概率，这个例子只有两个分类，非侮辱性概率 = 1- 侮辱性的概率
    #侮辱性文件的个数除以文件总数 = 侮辱性文件出现的概率
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    #单词出现的次数
    p0Num = zeros(numWords)
    p1Num = zeros(numWords)
    #整个数据集中单词出现的次数
    p0Denom = 0.0
    p1Denom = 0.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 = p1Num/p1Denom
    p0Vect = p0Num/p0Denom
    return p0Vect, p1Vect, pAbusive

使用拉普拉斯平滑优化后的训练函数：使用拉普拉斯平滑，为了解决0概率的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#优化版训练函数
def trainNB1(trainMatrix, trainCategory):
    numTrainDocs = len(trainMatrix)
    numWords = len(trainMatrix[0])
    pAbusive = sum(trainCategory) / float(numTrainDocs)
    p0Num = ones(numWords)
    p1Num = ones(numWords)

    #整个数据集单词出现总数，2.0（主要是为了避免分母为0的情况）
    p0Denom = 2.0  #拉普拉斯平滑
    p1Denom = 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])
    #类别1，侮辱性文档的列表[log(P(F1|C1)...]
    p1Vect = log(p1Num / p1Denom)
    #类别0，正常文档的列表
    p0Vect = log(p0Num / p0Denom)
    return p0Vect, p1Vect, pAbusive

3.测试算法：构建分类函数

1
2
3
4
5
6
7
8
#朴素贝叶斯分类函数
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify * p1Vec) + log(pClass1)     # 对应元素相乘，log中变为相加
    p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
    if p1 > p0:
        return 1
    else:
        return 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 测试函数
def testingNB():
    listOposts, listClasses = loadDataSet()
    myVocabList = createVocabList(listOposts)
    trainMat = []
    for postinDoc in listOposts:
        trainMat.append(setOfWordsVec(myVocabList, postinDoc))
    p0V, p1V, pAb = trainNB1(array(trainMat),array(listClasses))
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = array(setOfWordsVec(myVocabList, testEntry))
    print(testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = array(setOfWordsVec(myVocabList, testEntry))
    print(testEntry, 'classified as: ',classifyNB(thisDoc, p0V, p1V, pAb))

测试结果如下图所示：
testNB

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

1.准备数据：切分文本

使用正则表达式来切分句子，其中分隔符是除单词、数字外的任意字符串。

1
2
3
4
5
6
7
#文本解析，分词，解析为一共字符串列表
def textParse(bigString):
    import re
    #r表示raw String,自动将反斜杠转义
    listOfTokens = re.split(r'\W+', bigString)  #匹配除单词、数字外的任意字符串
    # 将字符串转化为小写，并返回长度大于2的字符串
    return [tok.lower() for tok in listOfTokens if len(tok) > 2]

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

留存交叉验证（hold-out cross validation）：随机选择一部分数据作为训练集，而剩余的数据用于测试集。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#垃圾邮件测试函数
import random
def spamTest():
    docList =[]
    classList = []
    fullText = []
    for i in range(1,26):
        #切分解析文本数据
        try:
            wordList = textParse(open('H:/python/email/spam/{}.txt'.format(i)).read())
        except:
            wordList = textParse(open('H:/python/email/spam/{}.txt'.format(i),encoding = 'Windows 1252').read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        try:
            wordList = textParse(open('H:/python/email/ham/{}.txt'.format(i)).read())
        except:
            wordList = textParse(open('H:/python/email/ham/{}.txt'.format(i), encoding='Windows 1252').read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    # 创建词汇表
    vocabList = createVocabList(docList)
    # 训练数据集，总共50封邮件
    trainingSet = list(range(50))  #range返回的是range对象，不返回数组对象,不用list后面删除会出错
    testSet = []
    #随机取10封邮件用来进行测试
    for i in range(10):
        # random.uniform(x, y) 随机生成一个范围为 x - y 的实数
        randIndex = int(random.uniform(0,len(trainingSet)))
        #留存交叉验证
        testSet.append(trainingSet[randIndex])   #添加到测试集
        del(trainingSet[randIndex])    #在训练集删除添加到测试集中的数据
    trainMat = []
    trainClasses = []
    #用训练集训练
    for docIndex in trainingSet:
        trainMat.append(setOfWordsVec(vocabList,docList[docIndex]))  #构建词向量
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB1(array(trainMat), array(trainClasses))
    errorCount = 0    #错误个数
    #进行测试
    for docIndex in testSet:
        wordVector = setOfWordsVec(vocabList, docList[docIndex])
        if classifyNB(array(wordVector), p0V,p1V,pSpam) != classList[docIndex]:
            errorCount += 1  #分类错误数+1
    print('the errorCount is: ', errorCount)
    print('the testSet length is: ', len(testSet))
    print('the error rate is:', float(errorCount)/len(testSet))

测试结果如下：
spamTest

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

1.收集数据：导入 RSS 源

RSS源分类器及高频词去除函数

1
2
3
4
5
6
7
8
9
# 高频词去除函数
def calcMostFreq(vocabList, fullText):
    #遍历词汇表中的每个词并统计它在文本中出现的次数
    freqDict = {}
    for token in vocabList:
        freqDict[token] = fullText.count(token) #统计每个词在文本中出现的次数
    #根据出现次数从高到低对词典进行排序，最后返回排序最高的30个单词
    sortedFreq = sorted(freqDict.items(), key = operator.itemgetter(1), reverse = True) #True表示降序排列
    return sortedFreq[0:30]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# RSS源分类器
def localWords(feed1, feed0):
    docList = []
    classList = []
    fullText = []
    minLen = min(len(feed1['entries']), len(feed0['entries']))
    for i in range(minLen):
        wordList = textParse(feed1['entries'][i]['summary']) #每次访问一条RSS源
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList = textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    vocabList = createVocabList(docList)
    top30Words = calcMostFreq(vocabList, fullText)
    for pairW in top30Words:
        if pairW[0] in vocabList:
            vocabList.remove(pairW[0])   #去除出现次数最高的那些词
    trainingSet = list(range(2 * minLen))
    testSet = []
    import random
    for i in range(20):
        rangeIndex = int(random.uniform(0, len(trainingSet)))
        testSet.append(trainingSet[rangeIndex])
        del(trainingSet[rangeIndex])
    #testSet = [int(num) for num in random.sample(range(2 * minLen),20)]
    #trainingSet = list(set(range(2 * minLen)) - set(testSet))
    trainMat = []
    trainClasses = []
    for docIndex in trainingSet:
        trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))
        trainClasses.append(classList[docIndex])
    p0V, p1V, pSpam = trainNB1(array(trainMat), array(trainClasses))
    errorCount = 0
    for docIndex in testSet:
        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

词袋模型：它与函数setOfWords2Vec()几乎完全相同，唯一不同的是每当遇到一个单词时，它会增加词向量中的对应值，而不只是将对应的数值设为1。

1
2
3
4
5
6
7
#朴素贝叶斯词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
    returnVec = [0] * len(vocabList)   #创建一个其中所含元素都为0的向量
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)] += 1
    return returnVec

这个案例由于RSS源数据进行了更新，测试的数据得不到我们想要的结果。

小结

对于分类而言，使用概率有时要比使用硬规则更为有效。贝叶斯概率及贝叶斯准则提供了一种利用已知值来估计未知概率的有效方法。

参考文章

https://blog.csdn.net/c406495762/article/details/77500679
https://blog.csdn.net/c406495762/article/details/77341116
https://github.com/apachecn/MachineLearning/blob/master/docs/4.%E6%9C%B4%E7%B4%A0%E8%B4%9D%E5%8F%B6%E6%96%AF.md

Error: Comments Not Initialized
Styling with Markdown is supported
Powered by Gitment