3-朴素贝叶斯
📐 基于概率论的分类方法：朴素贝叶斯
贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。本章首先介绍贝叶斯分类算法的基础——贝叶斯定理。最后，我们通过实例来讨论贝叶斯分类的中最简单的一种: 朴素贝叶斯分类。
1. 基于贝叶斯决策理论的分类方法
朴素贝叶斯是贝叶斯决策理论的一部分：
我们现在有一个数据集，它由两类数据组成，数据分布如下图所示:
我们现在用 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 块是黑色的。如果从罐子中随机取出一块石头，那么是白色石头的可能性是多少？
显然，取出白色石头的概率为 3/7 ，取到黑色石头的概率是 4/7 。我们使用 P(white) 来表示取到白色石头的概率，其概率值可以通过白色石头数目除以总的石头数目来得到。
❓ 如果这 7 块石头如下图所示，放在两个桶中，那么上述概率应该如何计算？
要计算 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) 并不一样，不过可以使用贝叶斯准则来交换概率中条件与结果。具体地，应用贝叶斯准则得到:
⭐ 使用上面这些定义，可以定义贝叶斯分类准则为:
- 如果
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}$ 个样本，对于包含 1000 个特征（单词）的词汇表就需要 $N^{1000}$ 个样本。可以看到，所需要的样本数会随着特征数目的增大而迅速增长。
-
⚪ 朴素贝叶斯分类器假设特征之间 相互独立 。那么样本数就可以从 $N^{1000}$ 减少到 $1000 × N$。 所谓 独立(independence) 指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其他单词相邻没有关系，比如说，‘我’ 出现在 ‘们’ 的前面的概率和 出现在 ‘们’ 的后面的概率相同（当然，我们知道这种假设并不正确）。这个假设正是朴素贝叶斯分类器中 朴素(naive) 一词的含义。
-
⚪ 朴素贝叶斯分类器中的另一个假设是，每个特征同等重要。
5. 实例 1：使用朴素贝叶斯辨别侮辱性词汇
项目概述：使用朴素贝叶斯构建一个快速过滤器来屏蔽侮辱性文档。如果某篇文档使用了负面或者侮辱性的语言，那么就将该文档标识为侮辱性文档。对此问题建立两个类别: 侮辱类和非侮辱类，使用 1 和 0 分别表示。
① 准备工作：将文本转换成 0-1 序列
目的：我们需要把文档中的每个单词利用 0 和 1 来表示，这样方便我们进行处理。
📑 词表到向量的转换函数：
这里的数据集是我们手动输入的，一个列表代表一篇文档
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):
"""
Desc:
遍历去重后的词汇表 vocabList，将某篇文档 inputSet 中出现的单词位置置 1
比如说去重后的词汇表 i love you
某篇文档 i love my love
那么该篇文档对应的词汇表序列就是 1 1 1;
如果某篇文档为 i love
那么该篇文档对应的词汇表序列是 1 1
其实就是将文档转换成 0-1 序列
Params:
vocabList: 去重后的词汇表
inputSet: 需要进行转换的文档
Return:
returnVec: 该篇文档对应的 0-1 序列
"""
returnVec = [0] * len(vocabList) # 创建一个和去重词汇表等长的向量，并将其初始化。用来表示文档的 0-1 序列
for word in inputSet: # 对文档中的每个单词
if word in vocabList: # 如果该单词在去重词汇表中出现
returnVec[vocabList.index(word)] = 1 # 将该单词对应的位置置为 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)
解释一下：
② 训练算法：从 0-1 序列计算概率
前面介绍了如何将一组单词转换为一组数字，接下来看看如何使用这些数字计算概率。
现在已经知道一个词是否出现在一篇文档中，也知道该文档所属的类别。接下来我们重写贝叶斯准则，将之前的 x, y 替换为 w，表示这是一个向量，即它由多个值组成。在这个例子中，数值个数与词汇表中的词个数相同。
我们使用上述公式，对每个类计算该值，然后比较这两个概率值的大小。
首先可以通过类别 i (侮辱性留言或者非侮辱性留言)中的文档数除以总的文档数来计算概率 $p(c_i)$ 。接下来计算$ 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) $来计算上述概率，这样就极大地简化了计算的过程。
💡 其实上式中的分母对于所有类别来说都是一样的，对计算结果不会产生影响，我们只需要计算分子即可。
该函数的伪代码如下：
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.zeros(numWords) # [0,0,0,.....] 非侮辱性单词在每个文件中出现的次数列表
p1Num = np.zeros(numWords) # [0,0,0,.....] 侮辱性单词出在每个文件中出现的次数列表
# (非)侮辱性单词在(非)侮辱性文档出现的总数
p0Denom = 0.0 # 0 非侮辱性词汇在所有非侮辱的文档的出现总数
p1Denom = 0.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类别下，每个单词出现的概率（条件概率）
p1Vect = p1Num / p1Denom # [1,2,3,5]/90->[1/90,2/90,3/90,5/90]
# 在0类别下，每个单词出现的概率
p0Vect = p0Num / p0Denom
return p0Vect, p1Vect, pAbusive
测试一下该函数：
p0V,p1V,pAb = trainNB0(trainMat,listClasses)
- pAb 是类别 1 即侮辱性文档的出现概率；
- p0V 表示在已知文档是类别 0 即非侮辱性文档的条件下，去重词汇表中各个单词的出现概率；
- p1V 表示在已知文档是类别 1 即侮辱性文档的条件下，去重词汇表中各个单词的出现概率。
显然，去重词汇表中第四个位置即 dog 是在侮辱性文档中出现概率最大的单词，这意味着 dog 是最能表征类别 1（侮辱性文档类）的单词。
👇 不过，使用该函数进行分类之前，还需解决函数中的一些缺陷。
③ 测试算法：根据现实情况修改分类器
在利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算 $p(w_0|1) * p(w_1|1) * p(w_2|1)$。如果其中一个概率值为 0，那么最后的乘积也为 0。为降低这种影响，可以将所有词的出现数初始化为 1，并将分母初始化为 2 （此处其实是采用了拉普拉斯平滑，即在条件概率和先验 概率的计算公式的分子和分母上分别添加一个 λ 和 $S_jλ$，λ = 1，$S_j$ 表示分类的个数，此处只有两个分类，所以 $S_j = 2$。具体详细可见本网站统计学习方法 - 朴素贝叶斯部分）
# 构造单词出现次数列表
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)$ 时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。（用 Python 尝试相乘许多很小的数，最后四舍五入后会得到 0）。一种解决办法是对乘积取自然对数。在代数中有 ln(a * b) = ln(a) + ln(b), 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。
p1Vect = log(p1Num / p1Denom)
p0Vect = log(p0Num / p0Denom)
下图给出了函数 f(x) 与 ln(f(x)) 的曲线。可以看出，它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。
训练函数的优化版本如下：
def trainNB0(trainMatrix, trainCategory):
"""
训练数据优化版本
:param trainMatrix: 文件单词矩阵
:param trainCategory: 文件对应的类别
:return:
"""
# 总文件数
numTrainDocs = len(trainMatrix)
# 总单词数
numWords = len(trainMatrix[0])
# 侮辱性文件的出现概率
pAbusive = sum(trainCategory) / float(numTrainDocs)
# 构造单词出现次数列表
# p0Num 正常的统计
# p1Num 侮辱的统计
p0Num = np.ones(numWords)#[0,0......]->[1,1,1,1,1.....]
p1Num = np.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])
p1Vect = log(p1Num / p1Denom)
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
"""
# 公式：p(c/w) = p(w/c)*p(c) / p(w)
# vec2Classify * p1Vec得到的是p(w/ci)
# 由于贝叶斯p(w/c)=p(w1，w2,w3..../c1)=p(w1)/p(c1) * p(w2)/p(c1) * .....
# 在上文中，为了解决下溢出问题，我们将 p0Vec 和 p1Vec 都使用了对数来表示
# 所以这里的每一项p(w1)/p(c1)是一个对数，所以对应公式中的实数乘法就转换成对数加法
# 最后还需要乘以p(c) 同样将 p(c) 转成对数，将实数乘法转换成对数加法
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. 创建每篇文档对应的 0-1 序列
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》
