📐 基于概率论的分类方法:朴素贝叶斯
- 🏠 本文收录于Github仓库,欢迎前来 star 呀~ https://github.com/Veal98/CS-Wiki
- 📞 在线阅读地址:https://veal98.gitee.io/cs-wiki/
贝叶斯分类是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类。本章首先介绍贝叶斯分类算法的基础——贝叶斯定理。最后,我们通过实例来讨论贝叶斯分类的中最简单的一种: 朴素贝叶斯分类。
1. 基于贝叶斯决策理论的分类方法
朴素贝叶斯是贝叶斯决策理论的一部分:
我们现在有一个数据集,它由两类数据组成,数据分布如下图所示:
![](https://i-blog.csdnimg.cn/blog_migrate/14587e2f1909c7b5cc347fa7cb65a703.png)
我们现在用 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
也就是说,我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想,即选择具有最高概率的决策。
2. 条件概率 conditional probability
① 条件概率
有一个装了 7 块石头的罐子,其中 3 块是白色的,4 块是黑色的。如果从罐子中随机取出一块石头,那么是白色石头的可能性是多少?
![](https://i-blog.csdnimg.cn/blog_migrate/8d07d093a7c89f81b13c7499ef14f963.png)
显然,取出白色石头的概率为 3/7 ,取到黑色石头的概率是 4/7 。我们使用 P(white) 来表示取到白色石头的概率,其概率值可以通过白色石头数目除以总的石头数目来得到。
❓ 如果这 7 块石头如下图所示,放在两个桶中,那么上述概率应该如何计算?
![](https://i-blog.csdnimg.cn/blog_migrate/88d3c5cf96cac0161534b0deb3dd6e87.png)
要计算 P(white) 或者 P(black) ,显然,石头所在桶的信息是会改变结果的,这就是条件概率 conditional probability。假定计算的是从 B 桶取到白色石头的概率,这个概率可以记作 P(white|bucketB)
,我们称之为 “在已知石头出自 B 桶的条件下,取出白色石头的概率”。很容易得到,P(white|bucketA)
值为 2/4 ,P(white|bucketB)
的值为 1/3 。
条件概率的计算公式如下:
⭐ P(white|bucketB) = P(white and bucketB) / P(bucketB)
公式解读:
-
P(white|bucketB)
:在已知石头出自 B 桶的条件下,取出白色石头的概率 -
P(white and bucketB)
:取出 B 桶中 白色石头的概率 = 1/ 7 -
P(bucketB)
:取出 B 桶中石头的概率 3 / 7
② 贝叶斯准则
另外一种有效计算条件概率的方法称为贝叶斯准则。贝叶斯准则告诉我们如何交换条件概率中的条件与结果,即如果已知 P(x|c)
,要求 P(c|x)
,那么可以使用下面的计算方法:
⭐
OK,我们讨论了条件概率,接下来将其应用到分类器中。👇
3. 使用条件概率来分类
第 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)
并不一样,不过可以使用贝叶斯准则来交换概率中条件与结果。具体地,应用贝叶斯准则得到:
![](https://i-blog.csdnimg.cn/blog_migrate/c50f813304cc3b974151a6dbcc3295c0.png)
⭐ 使用上面这些定义,可以定义贝叶斯分类准则为:
- 如果
P(c1|x, y) > P(c2|x, y)
, 那么属于类别 c1; - 如果
P(c2|x, y) > P(c1|x, y)
, 那么属于类别 c2。
使用贝叶斯准则,可以通过已知的三个概率值来计算未知的概率值。后面会给出利用贝叶斯准则来计算概率并对数据进行分类的代码。
下一节将介绍一个简单但功能强大的贝叶斯分类器的应用案例。
4. 使用朴素(navie)贝叶斯进行文档分类
机器学习的一个重要应用就是文档的自动分类。
在文档分类中,整个文档(如一封电子邮件)是实例,而电子邮件中的某些元素则构成特征。我们可以观察文档中出现的词,并把每个词作为一个特征,而每个词的出现或者不出现作为该特征的值,这样得到的特征数目就会跟词汇表中的词的数目一样多。
朴素贝叶斯是上面介绍的贝叶斯分类器的一个扩展,是用于文档分类的常用算法。
朴素贝叶斯的一般过程:
- 收集数据: 可以使用任何方法。比如 RSS 源
- 准备数据: 需要数值型或者布尔型数据。
- 分析数据: 有大量特征时,绘制特征作用不大,此时使用直方图效果更好。
- 训练算法: 计算不同的独立特征的条件概率。
- 测试算法: 计算错误率。
- 使用算法: 一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器,不一定非要是文本。
假设词汇表有 1000 个单词 ,要得到好的概率分布,就需要足够的数据样本。如果每个特征需要 N 个样本,那么对于 10 个特征将需要 N 10 N^{10} N10 个样本,对于包含 1000 个特征(单词)的词汇表就需要 N 1000 N^{1000} N1000 个样本。可以看到,所需要的样本数会随着特征数目的增大而迅速增长。
-
⚪ 朴素贝叶斯分类器假设特征之间 相互独立 。那么样本数就可以从 N 1000 N^{1000} N1000 减少到 1000 × N 1000 × N 1000×N。 所谓 独立(independence) 指的是统计意义上的独立,即一个特征或者单词出现的可能性与它和其他单词相邻没有关系,比如说,‘我’ 出现在 ‘们’ 的前面的概率和 出现在 ‘们’ 的后面的概率相同(当然,我们知道这种假设并不正确)。这个假设正是朴素贝叶斯分类器中 朴素(naive) 一词的含义。
-
⚪ 朴素贝叶斯分类器中的另一个假设是,每个特征同等重要。
5. 实例 1:使用朴素贝叶斯辨别侮辱性词汇
项目概述:使用朴素贝叶斯构建一个快速过滤器来屏蔽在线社区留言板上的侮辱性言论。如果某条留言使用了负面或者侮辱性的语言,那么就将该留言标识为内容不当。对此问题建立两个类别: 侮辱类和非侮辱类,使用 1 和 0 分别表示。
① 准备工作:从文本中构建词向量
我们将把文本看成单词向量或者此条向量,也就说将句子转换成向量。考虑出现在文档中的所有单词,再决定将哪些词纳入词汇表或者说所要的词汇的集合。
📑 词表到向量的转换函数:
这里的数据集是我们手动输入的,一个列表代表一篇文档
def loadDataSet():
"""
创建数据集
:return: 单词列表postingList, 所属类别 classVec
"""
postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'], # 文档1
['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'], # 文档2
['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'], # 文档3
['stop', 'posting', 'stupid', 'worthless', 'garbage'], # 文档4
['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'], # 文档5
['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']] # 文档6
classVec = [0, 1, 0, 1, 0, 1] # 各篇文档中是否带侮辱性文字:1 代表侮辱性文字,0 代表正常言论
return postingList, classVec
def createVocabList(dataSet):
"""
获取所有单词去重后的集合
:param dataSet: 数据集
:return: 所有单词的集合(即不含重复元素的单词列表)
"""
vocabSet = set([]) # 创建一个空集
for document in dataSet:
vocabSet = vocabSet | set(document) # 操作符 | 用于求两个集合的并集
return list(vocabSet)
def setOfWords2Vec(vocabList, inputSet):
"""
遍历查看该单词是否出现,出现该单词则将该单词置 1
:param vocabList: 所有单词集合列表(词汇表)
:param inputSet: 输入数据集
:return: 匹配列表[0,1,0,1...],其中 1 与 0 表示词汇表中的单词是否出现在输入的数据集中
"""
returnVec = [0]*len(vocabList) # 创建一个和词汇表等长的向量,并将其元素都设置为0
# 遍历文档中的所有单词,如果出现了词汇表中的单词,则将词汇表中该单词的位置设为1(如果不理解下文有详细解释)
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
看看这些函数的效果:
listOPosts,listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts) # 去重后的词汇表
trainMat = []
for postinDoc in listOPosts:
print(postinDoc)
trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
print(trainMat)
解释一下:
② 训练算法:从词向量计算概率
前面介绍了如何将一组单词转换为一组数字,接下来看看如何使用这些数字计算概率。
现在已经知道一个词是否出现在一篇文档中,也知道该文档所属的类别。接下来我们重写贝叶斯准则,将之前的 x, y 替换为 w,表示这是一个向量,即它由多个值组成。在这个例子中,数值个数与词汇表中的词个数相同。
![](https://i-blog.csdnimg.cn/blog_migrate/863eff6ce4e01bfecde90e73b6e0a726.png)
我们使用上述公式,对每个类计算该值,然后比较这两个概率值的大小。
首先可以通过类别 i (侮辱性留言或者非侮辱性留言)中的文档数除以总的文档数来计算概率 p ( c i ) p(c_i) p(ci) 。接下来计算$ p(w | c_i) $,这里就要用到朴素贝叶斯假设。如果将 w 展开为一个个独立特征,那么就可以将上述概率写作 $p(w_0, w_1, w_2…w_n | c_i) 。 这 里 假 设 所 有 词 都 互 相 独 立 , 该 假 设 也 称 作 ∗ ∗ 条 件 独 立 性 假 设 ∗ ∗ , 它 意 味 着 ∗ ∗ 可 以 使 用 。这里假设所有词都互相独立,该假设也称作**条件独立性假设**,它意味着**可以使用 。这里假设所有词都互相独立,该假设也称作∗∗条件独立性假设∗∗,它意味着∗∗可以使用 p(w_0 | c_i) × p(w_1 | c_i) × p(w_2 | c_i) × … × p(w_n | c_i) $来计算上述概率**,这样就极大地简化了计算的过程。
该函数的伪代码如下:
![](https://i-blog.csdnimg.cn/blog_migrate/5b585bde7bc12f662e6984d35c64debe.png)
import numpy as np
def trainNB0(trainMatrix, trainCategory):
"""
训练数据原版
:param trainMatrix: 文件单词矩阵 [[1,0,1,1,1....],[],[]...]
:param trainCategory: 文件对应的类别[0,1,1,0....],列表长度等于单词矩阵数,其中的1代表对应的文件是侮辱性文件,0代表不是侮辱性矩阵
:return:
"""
numTrainDocs = len(trainMatrix) # 文件数
numWords = len(trainMatrix[0]) # 单词数
pAbusive = sum(trainCategory) / float(numTrainDocs) # 侮辱性文件的出现概率,即 trainCategory 中所有的1的个数(0 1 相加即得 1 的个数)
# 单词在每个文件中出现的次数列表
p0Num = np.ones(numWords) # [0,0,0,.....] 非侮辱性单词在每个文件中出现的次数列表
p1Num = np.ones(numWords) # [0,0,0,.....] 侮辱性单词出在每个文件中出现的次数列表
# 单词在整个数据集出现的总数
p0Denom = 2.0 # 0 非侮辱性词汇在整个数据集的出现总数
p1Denom = 2.0 # 1 侮辱性词汇在整个数据集的出现总数
for i in range(numTrainDocs):
# 是否是侮辱性文件
if trainCategory[i] == 1:
# 如果是侮辱性文件,对侮辱性文件的向量进行相加,表示所有文件中各个侮辱性词汇出现的次数
p1Num += trainMatrix[i] # [0,1,1,....] + [0,1,1,....] -> [0,2,2,...]
# 对向量中的所有元素进行求和,表示所有文件中所有侮辱性词汇出现的次数之和
p1Denom += sum(trainMatrix[i])
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
# 类别1,即侮辱性文档的[P(F1|C1),P(F2|C1),P(F3|C1),P(F4|C1),P(F5|C1)....]列表
# 即在1类别下,每个单词出现的概率
p1Vect = p1Num / p1Denom # [1,2,3,5]/90->[1/90,2/90,3/90,5/90]
# 类别0,即正常文档的[P(F1|C0),P(F2|C0),P(F3|C0),P(F4|C0),P(F5|C0)....]列表
# 即在0类别下,每个单词出现的概率
p0Vect = p0Num / p0Denom
return p0Vect, p1Vect, pAbusive
测试一下该函数:
p0V,p1V,pAb = trainNB0(trainMat,listClasses)
pAb 是任意文档属于侮辱性文档的概率。p0V 表示词汇表中的每个单词在非侮辱性文档中出现的概率,p1V 表示词汇表中的每个单词在侮辱性文档中出现的概率。
显然,去重词汇表中第四个位置即 dog 是在侮辱性文档中出现概率最大的单词,这意味着 dog 是最能表征类别 1(侮辱性文档类)的单词。
👇 不过,使用该函数进行分类之前,还需解决函数中的一些缺陷。
③ 测试算法:根据现实情况修改分类器
在利用贝叶斯分类器对文档进行分类时,要计算多个概率的乘积以获得文档属于某个类别的概率,即计算 p ( w 0 ∣ 1 ) ∗ p ( w 1 ∣ 1 ) ∗ p ( w 2 ∣ 1 ) p(w_0|1) * p(w_1|1) * p(w_2|1) p(w0∣1)∗p(w1∣1)∗p(w2∣1)。如果其中一个概率值为 0,那么最后的乘积也为 0。为降低这种影响,可以将所有词的出现数初始化为 1,并将分母初始化为 2 (取1 或 2 的目的主要是为了保证分子和分母不为0,大家可以根据业务需求进行更改)。
# 构造单词出现次数列表
p0Num = np.ones(numWords) # [1,1,1,.....]
p1Num = np.ones(numWords) # [1,1,1,.....]
# 整个数据集单词出现总数
p0Denom = 2.0 # 0 非侮辱性词汇出现总数
p1Denom = 2.0 # 1 侮辱性词汇出现总数
另一个遇到的问题是下溢出,这是由于太多很小的数相乘造成的。当计算乘积
p
(
w
0
∣
c
i
)
∗
p
(
w
1
∣
c
i
)
∗
p
(
w
2
∣
c
i
)
.
.
.
p
(
w
n
∣
c
i
)
p(w_0|c_i) * p(w_1|c_i) * p(w_2|c_i)... p(w_n|c_i)
p(w0∣ci)∗p(w1∣ci)∗p(w2∣ci)...p(wn∣ci) 时,由于大部分因子都非常小,所以程序会下溢出或者得到不正确的答案。(用 Python 尝试相乘许多很小的数,最后四舍五入后会得到 0)。一种解决办法是对乘积取自然对数。在代数中有 ln(a * b) = ln(a) + ln(b)
, 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时,采用自然对数进行处理不会有任何损失。
p1Vect = log(p1Num / p1Denom)
p0Vect = log(p0Num / p0Denom)
下图给出了函数 f(x) 与 ln(f(x)) 的曲线。可以看出,它们在相同区域内同时增加或者减少,并且在相同点上取到极值。它们的取值虽然不同,但不影响最终结果。
![](https://i-blog.csdnimg.cn/blog_migrate/b46b9aca4231078f2a829377b8b9a1ce.png)
训练函数的优化版本如下:
def trainNB0(trainMatrix, trainCategory):
"""
训练数据优化版本
:param trainMatrix: 文件单词矩阵
:param trainCategory: 文件对应的类别
:return:
"""
# 总文件数
numTrainDocs = len(trainMatrix)
# 总单词数
numWords = len(trainMatrix[0])
# 侮辱性文件的出现概率
pAbusive = sum(trainCategory) / float(numTrainDocs)
# 构造单词出现次数列表
# p0Num 正常的统计
# p1Num 侮辱的统计
p0Num = ones(numWords)#[0,0......]->[1,1,1,1,1.....]
p1Num = ones(numWords)
# 整个数据集单词出现总数,2.0根据样本/实际调查结果调整分母的值(2主要是避免分母为0,当然值可以调整)
# p0Denom 正常的统计
# p1Denom 侮辱的统计
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)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
p1Vect = log(p1Num / p1Denom)
# 类别0,即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
p0Vect = log(p0Num / p0Denom)
return p0Vect, p1Vect, pAbusive
Ok,现在我们可以来构建完整的分类器了:
# 朴素贝叶斯分类函数
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
"""
:param vec2Classify: 待测数据[0,1,1,1,1...],即该文档中各个单词是否在词汇表中出现
:param p0Vec: 即词汇表中的每个单词在非侮辱性文档类别0中出现的概率
:param p1Vec: 即词汇表中的每个单词在侮辱性文档类别1中出现的概率
:param pClass1: 该篇文档是侮辱性文件的概率
:return: 类别1 or 0
"""
p1 = sum(vec2Classify * p1Vec) + np.log(pClass1) # P(w|c1) * P(c1) ,即贝叶斯准则的分子
p0 = sum(vec2Classify * p0Vec) + np.log(1.0 - pClass1) # P(w|c0) * P(c0) ,即贝叶斯准则的分子
if p1 > p0:
return 1
else:
return 0
# 测试朴素贝叶斯算法
def testingNB():
# 1. 加载数据集
listOPosts, listClasses = loadDataSet()
# 2. 创建单词集合
myVocabList = createVocabList(listOPosts)
# 3. 计算单词是否出现并创建数据矩阵
trainMat = []
for postinDoc in listOPosts:
# 返回 m*len(myVocabList)的矩阵, 记录的都是0,1信息
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
# 4. 训练数据
p0V, p1V, pAb = trainNB0(np.array(trainMat), np.array(listClasses))
# 5. 测试数据
testEntry = ['love', 'my', 'dalmation'] # 文档
thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry)) # 待测数据,该文档中各个单词是否在词汇表中出现,如果出现,就将词汇表的对应位置置为1
print(testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))
testEntry = ['stupid', 'garbage']
thisDoc = np.array(setOfWords2Vec(myVocabList, testEntry))
print(testEntry, 'classified as: ', classifyNB(thisDoc, p0V, p1V, pAb))
④ 词袋模型 bag-of-words model
目前为止,我们将每个词的出现与否作为一个特征 ,这可以被描述为词集模型 set-of-words model,每个的单词只能出现一次。
而在词袋模型中 bag-of-words model,每个单词可以出现多次。下面给出基于词袋模型的朴素贝叶斯代码,它于 setOfWords2Vec
基本相同,但是每遇到一个单词时,它会增加词汇表对应位置的值,而不只是将对应的数值设为 1
# 朴素贝叶斯词袋模型
def bagOfWords2VecMN(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
✅ OK,至此为止,分类器已经构建好了,接下来我们利用该分类器来过滤垃圾邮件。
6. 实例 2:使用朴素贝叶斯过滤垃圾邮件
项目概述:接下来我们完成朴素贝叶斯的一个最著名的应用: 电子邮件垃圾过滤。
开发流程:
- 收集数据: 提供文本文件
- 准备数据: 将文本文件解析成词条向量
- 分析数据: 检查词条确保解析的正确性
- 训练算法: 使用我们之前建立的
trainNB0()
函数 - 测试算法: 使用朴素贝叶斯进行交叉验证
- 使用算法: 构建一个完整的程序对一组文档进行分类,将错分的文档输出到屏幕上
① 准备数据:切分文本
前一节介绍了如何创建词向量,并基于这些词向量进行朴素贝叶斯分类的过程。前一节中的词向量是预先给定的,下面介绍如何从文本文档中构建词列表。
对于一个文本字符串,可以使用 Python 的 string.split()
方法将其切分:
mySent = 'This book is the best book on Python. I love it!'
mySent.split()
可以看到,标点符号也被当成了词的一部分。可以使用正则表达式来切分句子,其中分割符是除单词、数字外的任意字符串:
import re
listOfTokens = re.split(r'\W+', mySent)
listOfTokens
最后,我们希望所有的单词都是同一形式的,即统一大写或小写:
[tok.lower() for tok in listOfTokens if len(tok) > 0]
现在来看数据集中一封完整的电子邮件的实际处理结果:
emailTest = open('email/ham/6.txt').read()
listOfTokens = re.split(r'\W+', emailTest)
② 测试算法:使用朴素贝叶斯进行交叉验证
下面将文本解析器集成到一个完整分类器中:
def textParse(bigString):
'''
Desc:
接收一个大字符串并将其解析为字符串列表
Args:
bigString -- 大字符串
Returns:
去掉少于 2 个字符的字符串,并将所有字符串转换为小写,返回字符串列表
'''
import re
listOfTokens = re.split(r'\W+', bigString)
return [tok.lower() for tok in listOfTokens if len(tok) > 2]
def spamTest():
'''
Desc:
对贝叶斯垃圾邮件分类器进行自动化处理。
Args:
none
Returns:
对测试集中的每封邮件进行分类,若邮件分类错误,则错误数加 1,最后返回总的错误百分比。
'''
docList = [] # 每封邮件的词汇表,一个一个的列表
classList = [] # 每篇邮件的分类
fullText = [] # 所有邮件的词汇表(一个列表)
# 导入并解析文本文件
for i in range(1, 26):
# 导入文件夹 spam 下的文件,切分,解析数据,并归类为 1 类别
wordList = textParse(open('email/spam/%d.txt' % i, encoding="ISO-8859-1").read())
docList.append(wordList)
fullText.extend(wordList)
classList.append(1)
# 导入文件夹 ham 下的文件切分,解析数据,并归类为 0 类别
wordList = textParse(open('email/ham/%d.txt' % i, encoding="ISO-8859-1").read())
docList.append(wordList)
fullText.extend(wordList)
classList.append(0)
vocabList = createVocabList(docList) # 创建词汇表(去重)
trainingSet = range(50) # 训练集
testSet = [] # 测试集
# 随机构建测试集
for i in range(10):
# random.uniform(x, y) 随机生成一个范围为 x ~ y 的实数
randIndex = int(np.random.uniform(0, len(trainingSet)))
testSet.append(trainingSet[randIndex])
del(list(trainingSet)[randIndex]) # 从训练集中剔除测试集的数据
trainMat = []
trainClasses = []
# 循环遍历训练集的所有文档,构建词向量
for docIndex in trainingSet:
trainMat.append(setOfWords2Vec(vocabList, docList[docIndex])) # 训练集词向量
trainClasses.append(classList[docIndex]) # 训练集每封邮件的分类
p0V, p1V, pSpam = trainNB0(np.array(trainMat), np.array(trainClasses))
errorCount = 0
# 遍历测试集,对每封邮件进行分类
for docIndex in testSet:
wordVector = setOfWords2Vec(vocabList, docList[docIndex])
if classifyNB(np.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
函数 spamTest()
会输出在 10 封随机选择的电子邮件上的分类错误率。既然这些电子邮件是随机选择的,所以要想获得更好的估计错误率,应该将上述过程重复多次取平均值。
7. 实例 3:使用朴素贝叶斯分类器从个人广告中获取区域倾向
项目概述:广告商往往想知道关于一个人的一些特定人口统计信息,以便能更好地定向推销广告。
我们将分别从美国的两个城市中选取一些人,通过分析这些人发布的信息,来比较这两个城市的人们在广告用词上是否不同。如果结论确实不同,那么他们各自常用的词是哪些,从人们的用词当中,我们能否对不同城市的人所关心的内容有所了解。
👉 即查询两个 RSS 源的常用词是否相同。如果不同,他们各自的常用词是哪些 。
😂 这里的 RSS 源我们就随便选了两个国内的网站,可能不是广告网~
开发流程:
- 收集数据: 从 RSS 源收集内容,这里需要对 RSS 源构建一个接口
- 准备数据: 将文本文件解析成词条向量
- 分析数据: 检查词条确保解析的正确性
- 训练算法: 使用我们之前建立的 trainNB0() 函数
- 测试算法: 观察错误率,确保分类器可用。可以修改切分程序,以降低错误率,提高分类结果
- 使用算法: 构建一个完整的程序,封装所有内容。给定两个 RSS 源,该程序会显示最常用的公共词
① 收集数据:导入 RSS 源
首先需要下载一个 RSS 阅读器:FeedParser
-
打开 Anaconda Prompt 输入:
pip install feedparser
-
输入
conda list
检查是否成功安装
使用 FeedParser:
比如说访问人民网国际新闻的 RSS 源:
import feedparser
ny = feedparser.parse('http://www.people.com.cn/rss/world.xml')
可以构建一个类似于 spamTest() 的函数来对测试过程自动化:
# 朴素贝叶斯词袋模型
def bagOfWords2VecMN(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
return returnVec
def calcMostFreq(vocabList, fullText):
"""
Desc:
遍历词汇表中的每个词并统计它在文本中出现的次数
Args:
vocabList:词汇表
fullText:文本(文档)
Return:
返回出现次数最高的30个单词
"""
import operator
freqDict = {}
for token in vocabList:
freqDict[token] = fullText.count(token)
sortedFreq = sorted(freqDict.items(), 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) # 30个高频词
# 去除30个高频词
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(np.random.uniform(0, len(trainingSet)))
testSet.append(trainingSet[randIndex])
del(list(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(np.array(trainMat), np.array(trainClasses))
errorCount = 0
for docIndex in testSet: # classify the remaining items
wordVector = bagOfWords2VecMN(vocabList, docList[docIndex])
if classifyNB(np.array(wordVector), p0V, p1V, pSpam) != classList[docIndex]:
errorCount += 1
print('the error rate is: ', float(errorCount)/len(testSet))
return vocabList, p0V, p1V
🚩 函数 localWords()
使用了两个 RSS 源作为参数,RSS 源要在函数外导入,这样做的原因是 RSS 源会随时间而改变,重新加载 RSS 源就会得到新的数据。该函数的作用就是首先将一个RSS源作为类别 1,将另一个 RSS 源作为类别 2,然后从这两个 RSS 源的词汇表中随机构造测试集和训练集,对训练集中的词汇进行分类(类别 1 还是类别 0),然后对测试集进行分类,返回测试集上的错误率。
如果不移除高频词(注释掉移除高频词的三行代码),分类错误率将会显著上升。这说明词汇表中的一小部分却占据了所有文本用词的一大部分。
可以通过函数 caclMostFreq()
改变要移除的单词数目,然后观察错误率的变化情况。
② 分析数据:显示地域相关的用词
可以先对向量 pSF,pNY 进行排序,然后按照顺序将词打印出来:
# 显示最具表征性的词汇
# 最具表征性的词汇显示函数
def getTopWords(ny, sf):
import operator
vocabList, p0V, p1V = localWords(ny, sf)
topNY = []; topSF = []
for i in range(len(p0V)):
if p0V[i] > -6.0: # 返回大于阈值的所有词
topSF.append((vocabList[i], p0V[i]))
if p1V[i] > -6.0:
topNY.append((vocabList[i], p1V[i]))
sortedSF = sorted(topSF, key=lambda pair: pair[1], reverse=True)
print("SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**")
for item in sortedSF:
print(item[0])
sortedNY = sorted(topNY, key=lambda pair: pair[1], reverse=True)
print("NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**")
for item in sortedNY:
print(item[0])
📚 References
- 《Machine Learning in Action》
- Github - AiLearning
- Anaconda 安装 feedparser