朴素贝叶斯Machine Learning In Action学习笔记

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

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

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

 

条件概率：p(x,y|c₁) 需要先验知识和逻辑推理

频数概率：从数据本身获得结论，并不考虑逻辑推理及先验知识

 

贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

 

朴素贝叶斯的一般过程：

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

2. 准备数据：需要数值型或者布尔型数据

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

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

5. 测试算法：计算错误率。

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

 

如果每个特征需要N个样本，那么对于10个特征将需要N^10个样本。

如果特征之间相互独立，那么样本数就可以从N^1000减少到1000×N。

 

朴素贝叶斯分类器中朴素（naive）一词：假设每个特征同等重要。

朴素贝叶斯分类器通常有两种实现方式：一种基于贝努利模型实现，一种基于多项式模型实现。这里采用前一种实现方式。该实现方式中并不考虑词在文档中出现的次数，只考虑出不出现，因此在这个意义上相当于假设词是等权重的（独立）。

 

粗体w表示这是一个向量，即它由多个数值组成。

 

伪代码：

计算每个类别中的文档数目

对每篇训练文档：

    对每个类别：

        如果词条出现在文档中→ 增加该词条的计数值

        增加所有词条的计数值

    对每个类别：

        对每个词条：

            将该词条的数目除以总词条数目得到条件概率

    返回每个类别的条件概率

 

注意：

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

1. p0Num, p1Num = zeros(numWords), zeros(numWords)
2. p0Denom, p1Denom =0.0,0.0

 

更改为：

1. p0Num, p1Num = ones(numWords), ones(numWords)
2. p0Denom, p1Denom =2.0,2.0

2.另一个遇到的问题是下溢出，这是由于太多很小的数相乘造成的。当计算乘积p(w0|ci)p(w1|ci)p(w2|ci)...p(wN|ci)时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。（用Python尝试相乘许多很小的数，最后四舍五入后会得到0。）

一种解决办法是对乘积取自然对数。通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失 。

1. p1Vect = p1Num / p1Denom
2. p0Vect = p0Num / p0Denom

改为：

1. p1Vect = log(p1Num / p1Denom)
2. p0Vect = log(p0Num / p0Denom)

 

词集模型：每个词的出现与否作为一个特征（每个词只能出现一次）

词袋模型：每个单词可以出现多次。

setOfWords2Vec函数仅考虑词集模型，bagOfWords2VecMN函数则是基于文档词袋模型改进后的函数。

 

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

收集数据：提供文本文件。

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

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

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

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

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

 

留存交叉验证：随机选择数据的一部分作为训练集，而剩余部分作为测试集。

 

所有代码：

1. # -*- coding:utf-8 -*-
2. from numpy import*
5. def loadDataSet():
6. postingList =[['my','dog','has','flea','problems','help','please'],
7. ['maybe','not','take','him','to','dog','park','stupid'],
8. ['my','dalmation','is','so','cute','I','love','him'],
9. ['stop','posting','stupid','worthless','garbage'],
10. ['mr','licks','ate','my','steak','how','to','stop','him'],
11. ['quit','buying','worthless','dog','food','stupid']]
12. classVec =[0,1,0,1,0,1]# 1 is abusive, 0 not
13. return postingList, classVec
16. # 创建一个在所有文档中出现的不重复词的列表
17. def createVocabList(dataSet):
18. vocabSet = set([])
19. for document in dataSet:
20. vocabSet = vocabSet | set(document)
21. return list(vocabSet)
24. # 输入词汇列表和某个文档，输出文档向量，向量的每一元素为1或0，分别表示词汇表中的单词在输入文档中是否出现。
25. def setOfWords2Vec(vocabList, inputSet):
26. returnVec =[0]* len(vocabList)
27. for word in inputSet:
28. if word in vocabList:
29. returnVec[vocabList.index(word)]=1
30. else:
31. print"the word: %s is not in my Vocabulary!"% word
32. return returnVec
35. # 基于文档词袋模型改进后的模型
36. def bagOfWords2VecMN(vocabList, inputSet):
37. returnVec =[0]* len(vocabList)
38. for word in inputSet:
39. if word in vocabList:
40. returnVec[vocabList.index(word)]+=1
41. return returnVec
44. # 输入参数为文档矩阵trainMatrix，以及由每篇文档类别标签所构成的向量trainCategory
45. def trainNB0(trainMatrix, trainCategory):
46. numTrainDocs = len(trainMatrix)
47. numWords = len(trainMatrix[0])
48. pAbusive = sum(trainCategory)/ float(numTrainDocs)# 2分类问题，仅0,1构成向量，此处计算1
49. p0Num, p1Num = ones(numWords), ones(numWords)
50. p0Denom, p1Denom =2.0,2.0
52. for i in range(numTrainDocs):
53. if trainCategory[i]==1:
54. p1Num += trainMatrix[i]
55. p1Denom += sum(trainMatrix[i])
56. else:
57. p0Num += trainMatrix[i]
58. p0Denom += sum(trainMatrix[i])
59. p1Vect = log(p1Num / p1Denom)
60. p0Vect = log(p0Num / p0Denom)
62. return p0Vect, p1Vect, pAbusive
65. # 要分类的向量vec2Classify
66. def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
67. p1 = sum(vec2Classify * p1Vec)+ log(pClass1)
68. p0 = sum(vec2Classify * p0Vec)+ log(1.0- pClass1)
69. if p1 > p0:
70. return1
71. else:
72. return0
75. def testingNB():
76. listOPosts, listClasses = loadDataSet()
77. myVocabList = createVocabList(listOPosts)
79. trainMat =[]
80. for postinDoc in listOPosts:
81. trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
82. p0V, p1V, pAb = trainNB0(array(trainMat), array(listClasses))
84. testEntry =['love','my','dalmation']
85. thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
86. print testEntry,'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
88. testEntry =['stupid','garbage']
89. thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
90. print testEntry,'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb)
93. # 文件解析及完整的垃圾邮件测试函数
94. def textParse(bigString):
95. import re
96. listOfTokens = re.split(r'\W*', bigString)
97. return[tok.lower()for tok in listOfTokens if len(tok)>2]
100. def spamTest():
101. import random
102. # 导入并解析文本文件
103. docList, classList, fullText =[],[],[]
104. for i in range(1,26):
105. wordList = textParse(open('email/spam/%d.txt'% i,'r').read())
106. docList.append(wordList)
107. fullText.extend(wordList)
108. classList.append(1)
110. wordList = textParse(open('email/ham/%d.txt'% i,'r').read())
111. docList.append(wordList)
112. fullText.extend(wordList)
113. classList.append(0)
115. vocabList = createVocabList(docList)
116. trainingSet = range(50)
117. testSet =[]
118. # 随机构建训练集(训练集40个，测试集10个)
119. for i in range(10):
120. randIndex = int(random.uniform(0, len(trainingSet)))
121. testSet.append(trainingSet[randIndex])
122. del(trainingSet[randIndex])
124. trainMat, trainClasses =[],[]
125. for docIndex in trainingSet:
126. trainMat.append(setOfWords2Vec(vocabList, docList[docIndex]))
127. trainClasses.append(classList[docIndex])
129. p0V, p1V, pSpam = trainNB0(array(trainMat), array(trainClasses))
131. # 对测试集分类
132. errorCount =0
133. for docIndex in testSet:
134. wordVector = setOfWords2Vec(vocabList, docList[docIndex])
135. if classifyNB(array(wordVector), p0V, p1V, pSpam)!= classList[docIndex]:
136. errorCount +=1
137. print'the error rate is: ', float(errorCount)/ len(testSet)

 

参考资料：

1. Peter Harrington《机器学习实战》第四章

 

来自为知笔记(Wiz)