mirror of
https://github.com/apachecn/ailearning.git
synced 2026-11-02 21:44:55 +08:00
修改朴素贝叶斯代码和文档，添加一些数据集
This commit is contained in:
chenyyx
@@ -2,7 +2,7 @@
|
||||
# 第3章 决策树
|
||||
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
|
||||
|
||||
|
||||
|
||||
|
||||
## 决策树 概述
|
||||
|
||||
|
||||
483
docs/4.朴素贝叶斯.md
483
docs/4.朴素贝叶斯.md
@@ -4,91 +4,446 @@
|
||||
|
||||
|
||||
|
||||
## 使用概率分布进行分类
|
||||
## 朴素贝叶斯 概述
|
||||
|
||||
> 朴素贝叶斯简介
|
||||
`贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。本章首先介绍贝叶斯分类算法的基础——贝叶斯定理。最后，我们通过实例来讨论贝叶斯分类的中最简单的一种: 朴素贝叶斯分类。`
|
||||
|
||||
```
|
||||
前两章我们要求分类器做出艰难决策，给出“该数据实例属于哪一类”这类问题的明确答案。不过，分类器有时候会产生错误的结果，
|
||||
这时可以要求分类器给出一个最优的类别猜测结果，同时给出这个猜测的概率估计值。
|
||||
在这里我们先统计特征在数据集中取某个特定值的次数，然后除以数据集的实例总数，就得到了特征取该值的概率。
|
||||
下面我们会给出一些使用概率论进行分类的方法。首先从一个最简单的概率分类器开始，然后给出一些假设来学习朴素贝叶斯分类器。
|
||||
我们称之为“朴素”，是因为整个形式化过程只做最原始、最简答的假设。
|
||||
```
|
||||
## 贝叶斯理论 & 条件概率
|
||||
|
||||
> 贝叶斯决策理论
|
||||
|
||||
```
|
||||
朴素贝叶斯是贝叶斯决策理论的一部分，所以讲述朴素贝叶斯之前有必要快速了解一下贝叶斯决策理论。
|
||||
假设我们有一个数据集，它由两类数据组成，数据分布如下图所示：
|
||||
```
|
||||
### 贝叶斯理论
|
||||
|
||||
我们现在有一个数据集，它由两类数据组成，数据分布如下图所示：
|
||||
|
||||
|
||||
```
|
||||
我们现在用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
|
||||
也就是说，我们会选择高概率对应的类别。这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。
|
||||
```
|
||||
我们现在用 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(x,y|c1) 符号很熟悉，那么可以跳过本小节。
|
||||
|
||||
有一个装了 7 块石头的罐子，其中 3 块是灰色的，4 块是黑色的。如果从罐子中随机去除一块石头，那么是灰色石头的可能性是多少？由于取石头有 7 中可能，其中 3 种为灰色，所以取出灰色石头的概率为 3/7 。那么取到黑色石头的概率又是多少呢？很显然，是 4/7 。我们使用 P(gray) 来表示取到灰色石头的概率，其概率值可以通过灰色石头数目除以总的石头数目来得到。
|
||||
|
||||
|
||||
|
||||
如果这 7 块石头如下图所示，放在两个桶中，那么上述概率应该如何计算？
|
||||
|
||||
|
||||
|
||||
计算 P(gray) 或者 P(black) ，如果事先我们知道石头所在桶的信息是会改变结果的。这就是所谓的条件概率（conditional probablity）。假定计算的是从 B 桶取到灰色石头的概率，这个概率可以记作 P(gray|bucketB) ，我们称之为“在已知石头出自 B 桶的条件下，取出灰色石头的概率”。不难得到，P(gray|bucketA) 值为 2/4 ，P(gray|bucketB) 的值为 1/3 。
|
||||
|
||||
条件概率的计算公式如下：
|
||||
|
||||
P(gray|bucketB) = P(gray and bucketB) / P(bucketB)
|
||||
|
||||
首先，我们用 B 桶中灰色石头的个数除以两个桶中总的石头数，得到 P(gray and bucketB) = 1/7 .其次，由于 B 桶中有 3 块石头，而总石头数为 7 ，于是 P(bucketB) 就等于 3/7 。于是又 P(gray|bucketB) = P(gray and bucketB) / P(bucketB) = (1/7) / (3/7) = 1/3 。
|
||||
|
||||
另外一种有效计算条件概率的方法称为贝叶斯准则。贝叶斯准则告诉我们如何交换条件概率中的条件与结果，即如果已知 P(x|c)，要求 P(c|x)，那么可以使用下面的计算方法：
|
||||
|
||||
|
||||
|
||||
### 使用条件概率来分类
|
||||
|
||||
上面我们提到贝叶斯决策理论要求计算两个概率 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(c1|x, y) > P(c2|x, y), 那么属于类别 c2.
|
||||
|
||||
在文档分类中，整个文档（如一封电子邮件）是实例，而电子邮件中的某些元素则构成特征。我们可以观察文档中出现的词，并把每个词的出现或者不出现作为一个特征，这样得到的特征数目就会跟词汇表中的数目一样多。
|
||||
|
||||
我们假设特征之间<b>相互独立</b>。所谓 <b>独立(independence)</b> 指的是统计意义上的独立，即一个特征或者单词出现的可能性与它和其他单词相邻没有关系。这个假设正是朴素贝叶斯分类器中 朴素(naive) 一词的含义。朴素贝叶斯分类器中的另一个假设是，<b>每个特征同等重要</b>。
|
||||
|
||||
<b>Note:</b> 朴素贝叶斯分类器通常有两种实现方式: 一种基于伯努利模型实现，一种基于多项式模型实现。这里采用前一种实现方式。该实现方式中并不考虑词在文档中出现的次数，只考虑出不出现，因此在这个意义上相当于假设词是等权重的。
|
||||
|
||||
## 朴素贝叶斯 场景
|
||||
|
||||
机器学习的一个重要应用就是文档的自动分类。
|
||||
|
||||
在文档分类中，整个文档（如一封电子邮件）是实例，而电子邮件中的某些元素则构成特征。例如，我们可以观察文档中出现的词，并把每个词的出现或者不出现作为一个特征，这样得到的特征数目就会跟词汇表中的词目一样多。
|
||||
|
||||
朴素贝叶斯是上面介绍的贝叶斯分类器的一个扩展，是用于文档分类的常用算法。下面我们会进行一些朴素贝叶斯分类的实践项目。
|
||||
|
||||
## 朴素贝叶斯 原理
|
||||
|
||||
### 朴素贝叶斯 工作原理
|
||||
|
||||
```
|
||||
优点：在数据较少的情况下仍然有效，可以处理多类别问题。
|
||||
缺点：对于输入数据的准备方式较为敏感。
|
||||
适用于数据类型：标称型数据。
|
||||
计算每个类别中的文档数目
|
||||
对每篇训练文档:
|
||||
对每个类别:
|
||||
如果词条出现在文档中-->增加该词条的计数值
|
||||
增加所有词条的计数值
|
||||
对每个类别:
|
||||
对每个词条:
|
||||
将该词条的数目除以总词条数目得到的条件概率
|
||||
返回每个类别的条件概率
|
||||
```
|
||||
|
||||
> 朴素贝叶斯的一般过程
|
||||
### 朴素贝叶斯 开发流程
|
||||
|
||||
```
|
||||
(1)收集数据：可以使用任何方法。本章使用RSS源。
|
||||
(2)准备数据：需要数值型或者布尔型数据。
|
||||
(3)分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好。
|
||||
(4)训练算法：计算不同的独立特征的条件概率。
|
||||
(5)测试算法：计算错误率。
|
||||
(6)使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。
|
||||
收集数据: 可以使用任何方法。
|
||||
准备数据: 需要数值型或者布尔型数据。
|
||||
分析数据: 有大量特征时，绘制特征作用不大，此时使用直方图效果更好。
|
||||
训练算法: 计算不同的独立特征的条件概率。
|
||||
测试算法: 计算错误率。
|
||||
使用算法: 一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯分类器，不一定非要是文本。
|
||||
```
|
||||
|
||||
## 学习朴素贝叶斯分类器
|
||||
|
||||
> 条件概率
|
||||
|
||||
|
||||
|
||||
> 计算上述概率
|
||||
### 朴素贝叶斯 算法特点
|
||||
|
||||
```
|
||||
要计算 P(gray) 或者 P(black) ，事先得知道石头所在桶的信息会不会改变结果？你有可能已经想到计算从 B 桶中取到灰色石头的概率的办法，
|
||||
这就是所谓的条件概率 (conditional probability)。假定计算的是从 B 桶取到灰色石头的概率，这个概率可以记作 P(gray|bucketB)，
|
||||
我们称之为“在已知石头出自B桶的条件下，取出灰色石头的概率”。不难得到，P(gray|bucketA)值为2/4，P(gray|bucketB)的值为1/3。
|
||||
条件概率的计算公式如下所示：
|
||||
P(gray|bucketB) = P(gray and bucketB) / P(bucketB)
|
||||
```
|
||||
> 贝叶斯准则
|
||||
|
||||
```
|
||||
贝叶斯准则告诉我们如何交换条件概率中的条件和结果，即如果已知 P(x|c) ，要求 P(c|x) ，那么可以使用下面的计算方法：
|
||||
p(c|x) = p(x|c)·p(c)/p(x)
|
||||
优点: 在数据较少的情况下仍然有效，可以处理多类别问题。
|
||||
缺点: 对于输入数据的准备方式较为敏感。
|
||||
适用数据类型: 标称型数据。
|
||||
```
|
||||
|
||||
> 使用条件概率来分类
|
||||
## 朴素贝叶斯 项目案例
|
||||
|
||||
上面提到的贝叶斯决策理论要求计算两个概率 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(ci|x,y) = p(x,y|ci)·p(ci)/p(x,y)
|
||||
### 项目案例1: 屏蔽社区留言板的侮辱性言论
|
||||
|
||||
#### 项目概述
|
||||
|
||||
构建一个快读过滤器来屏蔽在线社区留言板上的侮辱性言论。如果某条留言使用了负面或者侮辱性的语言，那么就将该留言标识为内容不当。对此问题建立两个类别: 侮辱类和非侮辱类，使用 1 和 0 分别表示。
|
||||
|
||||
#### 开发流程
|
||||
|
||||
```
|
||||
收集数据: 可以使用任何方法
|
||||
准备数据: 从文本中构建词向量
|
||||
分析数据: 检查词条确保解析的正确性
|
||||
训练算法: 从词向量计算概率
|
||||
测试算法: 根据现实情况修改分类器
|
||||
使用算法: 对社区留言板言论进行分类
|
||||
```
|
||||
|
||||
> 收集数据: 可以使用任何方法
|
||||
|
||||
本例是我们自己构造的词表:
|
||||
|
||||
```python
|
||||
def loadDataSet():
|
||||
"""
|
||||
创建数据集
|
||||
:return: 单词列表postingList, 所属类别classVec
|
||||
"""
|
||||
postingList = [['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'], #[0,0,1,1,1......]
|
||||
['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
|
||||
```
|
||||
|
||||
> 准备数据: 从文本中构建词向量
|
||||
|
||||
```python
|
||||
def createVocabList(dataSet):
|
||||
"""
|
||||
获取所有单词的集合
|
||||
:param dataSet: 数据集
|
||||
:return: 所有单词的集合(即不含重复元素的单词列表)
|
||||
"""
|
||||
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):
|
||||
"""
|
||||
遍历查看该单词是否出现，出现该单词则将该单词置1
|
||||
:param vocabList: 所有单词集合列表
|
||||
:param inputSet: 输入数据集
|
||||
:return: 匹配列表[0,1,0,1...]，其中 1与0 表示词汇表中的单词是否出现在输入的数据集中
|
||||
"""
|
||||
# 创建一个和词汇表等长的向量，并将其元素都设置为0
|
||||
returnVec = [0] * len(vocabList)# [0,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
|
||||
```
|
||||
|
||||
> 分析数据: 检查词条确保解析的正确性
|
||||
|
||||
检查函数执行情况，检查词表，不出现重复单词，需要的话，可以对其进行排序。
|
||||
|
||||
```python
|
||||
>>> listOPosts, listClasses = bayes.loadDataSet()
|
||||
>>> myVocabList = bayes.createVocabList(listOPosts)
|
||||
>>> myVocabList
|
||||
['cute', 'love', 'help', 'garbage', 'quit', 'I', 'problems', 'is', 'park',
|
||||
'stop', 'flea', 'dalmation', 'licks', 'food', 'not', 'him', 'buying', 'posting', 'has', 'worthless', 'ate', 'to', 'maybe', 'please', 'dog', 'how',
|
||||
'stupid', 'so', 'take', 'mr', 'steak', 'my']
|
||||
```
|
||||
|
||||
检查函数有效性。例如：myVocabList 中索引为 2 的元素是什么单词？应该是是 help 。该单词在第一篇文档中出现了，现在检查一下看看它是否出现在第四篇文档中。
|
||||
|
||||
```python
|
||||
>>> bayes.setOfWords2Vec(myVocabList, listOPosts[0])
|
||||
[0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1]
|
||||
|
||||
>>> bayes.setOfWords2Vec(myVocabList, listOPosts[3])
|
||||
[0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
|
||||
```
|
||||
|
||||
> 训练算法: 从词向量计算概率
|
||||
|
||||
现在已经知道了一个词是否出现在一篇文档中，也知道该文档所属的类别。接下来我们重写贝叶斯准则，将之前的 x, y 替换为 <b>w</b>. 粗体的 <b>w</b> 表示这是一个向量，即它由多个值组成。在这个例子中，数值个数与词汇表中的词个数相同。
|
||||
|
||||
|
||||
|
||||
我们使用上述公式，对每个类计算该值，然后比较这两个概率值的大小。
|
||||
|
||||
首先可以通过类别 i (侮辱性留言或者非侮辱性留言)中文档数除以总的文档数来计算概率 p(ci) 。接下来计算 p(<b>w</b> | ci) ，这里就要用到朴素贝叶斯假设。如果将 w 展开为一个个独立特征，那么就可以将上述概率写作 p(w0, w1, w2...wn | ci) 。这里假设所有词都互相独立，该假设也称作条件独立性假设，它意味着可以使用 p(w0 | ci)p(w1 | ci)p(w2 | ci)...p(wn | ci) 来计算上述概率，这样就极大地简化了计算的过程。
|
||||
|
||||
朴素贝叶斯分类器训练函数
|
||||
|
||||
```python
|
||||
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
|
||||
```
|
||||
|
||||
> 测试算法: 根据现实情况修改分类器
|
||||
|
||||
在利用贝叶斯分类器对文档进行分类时，要计算多个概率的乘积以获得文档属于某个类别的概率，即计算 p(w0 | 1)p(w1 | 1)p(w2 | 1)。如果其中一个概率值为 0，那么最后的乘积也为 0。为降低这种影响，可以将所有词的出现数初始化为 1，并将分母初始化为 2 。
|
||||
|
||||
另一个遇到的问题是下溢出，这是由于太多很小的数相乘造成的。当计算乘积 p(w0 | ci)p(w1 | ci)p(w2 | ci)...p(wn | ci) 时，由于大部分因子都非常小，所以程序会下溢出或者得到不正确的答案。（用 Python 尝试相乘许多很小的数，最后四舍五入后会得到 0）。一种解决办法是对乘积取自然对数。在代数中有 ln(a * b) = ln(a) + ln(b), 于是通过求对数可以避免下溢出或者浮点数舍入导致的错误。同时，采用自然对数进行处理不会有任何损失。
|
||||
|
||||
下图给出了函数 f(x) 与 ln(f(x)) 的曲线。可以看出，它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。通过修改 return 前的两行代码，将上述做法用到分类器中:
|
||||
|
||||
```python
|
||||
p1Vect = log(p1Num /p1Denom)
|
||||
p0Vect = log(p0Num / p0Denom)
|
||||
```
|
||||
|
||||
|
||||
|
||||
> 使用算法: 对社区留言板言论进行分类
|
||||
|
||||
朴素贝叶斯分类函数
|
||||
|
||||
```python
|
||||
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
|
||||
"""
|
||||
使用算法：
|
||||
# 将乘法转换为加法
|
||||
乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
|
||||
加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
:param vec2Classify: 待测数据[0,1,1,1,1...]，即要分类的向量
|
||||
:param p0Vec: 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
|
||||
:param p1Vec: 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
|
||||
:param pClass1: 类别1，侮辱性文件的出现概率
|
||||
:return: 类别1 or 0
|
||||
"""
|
||||
# 计算公式 log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
# 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。
|
||||
# 我的理解是：这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
|
||||
p1 = sum(vec2Classify * p1Vec) + log(pClass1)
|
||||
p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
|
||||
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(array(trainMat), array(listClasses))
|
||||
# 5. 测试数据
|
||||
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)
|
||||
```
|
||||
|
||||
### 项目案例2: 使用朴素贝叶斯过滤垃圾邮件
|
||||
|
||||
#### 项目概述
|
||||
|
||||
完成朴素贝叶斯的一个最著名的应用: 电子邮件垃圾过滤。
|
||||
|
||||
#### 开发流程
|
||||
|
||||
使用朴素贝叶斯对电子邮件进行分类
|
||||
|
||||
```
|
||||
收集数据: 提供文本文件
|
||||
准备数据: 将文本文件解析成词条向量
|
||||
分析数据: 检查词条确保解析的正确性
|
||||
训练算法: 使用我们之前建立的 trainNB() 函数
|
||||
测试算法: 使用朴素贝叶斯进行交叉验证
|
||||
使用算法: 构建一个完整的程序对一组文档进行分类，将错分的文档输出到屏幕上
|
||||
```
|
||||
|
||||
> 收集数据: 提供文本文件
|
||||
|
||||
文本文件内容如下:
|
||||
|
||||
```
|
||||
Hi Peter,
|
||||
|
||||
With Jose out of town, do you want to
|
||||
meet once in a while to keep things
|
||||
going and do some interesting stuff?
|
||||
|
||||
Let me know
|
||||
Eugene
|
||||
```
|
||||
|
||||
> 准备数据: 将文本文件解析成词条向量
|
||||
|
||||
文档词袋模型
|
||||
|
||||
我们将每个词的出现与否作为一个特征，这可以被描述为 <b>词集模型(set-of-words model)</b>。如果一个词在文档中出现不止一次，这可能意味着包含该词是否出现在文档中所不能表达的某种信息，这种方法被称为 <b>词袋模型(bag-of-words model)</b>。在词袋中，每个单词可以出现多次，而在词集中，每个词只能出现一次。为适应词袋模型，需要对函数 setOfWords2Vec() 稍加修改，修改后的函数为 bagOfWords2Vec() 。
|
||||
|
||||
如下给出了基于词袋模型的朴素贝叶斯代码。它与函数 setOfWords2Vec() 几乎完全相同，唯一不同的是每当遇到一个单词时，它会增加词向量中的对应值，而不只是将对应的数值设为 1 。
|
||||
|
||||
```python
|
||||
def bagOfWords2VecMN(vocaList, inputSet):
|
||||
returnVec = [0] * len(vocabList)
|
||||
for word in inputSet:
|
||||
if word in inputSet:
|
||||
returnVec[vocabList.index(word)] += 1
|
||||
return returnVec
|
||||
```
|
||||
|
||||
使用正则表达式来切分文本
|
||||
|
||||
```python
|
||||
>>> mySent = 'This book is the best book on Python or M.L. I have ever laid eyes upon.'
|
||||
>>> import re
|
||||
>>> regEx = re.compile('\\W*')
|
||||
>>> listOfTokens = regEx.split(mySent)
|
||||
>>> listOfTokens
|
||||
['This', 'book', 'is', 'the', 'best', 'book', 'on', 'Python', 'or', 'M.L.', 'I', 'have', 'ever', 'laid', 'eyes', 'upon', '']
|
||||
```
|
||||
|
||||
> 分析数据: 检查词条确保解析的正确性
|
||||
|
||||
> 训练算法: 使用我们之前建立的 trainNB() 函数
|
||||
|
||||
```python
|
||||
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
|
||||
```
|
||||
|
||||
> 测试算法: 使用朴素贝叶斯进行交叉验证
|
||||
|
||||
```python
|
||||
|
||||
```
|
||||
|
||||
> 使用算法: 构建一个完整的程序对一组文档进行分类，将错分的文档输出到屏幕上
|
||||
|
||||
|
||||
### 项目案例3: 使用朴素贝叶斯分类器从个人广告中获取区域倾向
|
||||
|
||||
#### 项目概述
|
||||
|
||||
使用这些定义，可以定义贝叶斯分类准则为：
|
||||
* 如果 P(c1|x,y) > P(c2|x,y) ，那么属于类别c1;
|
||||
* 如果 P(c1|x,y) < P(c2|x,y) ，那么属于类别c2;
|
||||
使用贝叶斯准则，可以通过已知的三个概率值来计算未知的概率值。后面就会给出利用贝叶斯准则来计算概率并对数据进行分类的代码。现在介绍了一些概率理论，
|
||||
你也了解了基于这些理论构建分类器的方法，接下来就要将它们付诸实践。
|
||||
|
||||
## 解析RSS源数据
|
||||
|
||||
|
||||
Reference in New Issue
Block a user