0x00 摘要
朴素贝叶斯模型是机器学习中经常提到的概念. 但是相信很多朋友都是知其然而不知其所以然. 本文将尽量使用易懂的方式介绍朴素贝叶斯模型原理, 并且通过具体应用场景和源码来帮助大家深入理解这个概念.
0x01 IT 相关概念
1. 分类问题
已知 m 个样本 (x1,y1), ...... (xm,ym),x 是特征变量, y 是对应的类别. 要求得一个模型函数或者映射规则 h, 对于新的样本 xt, 能够尽量准确的预测出 yt = h(xt).
我们也可以从概率的角度来考虑一下上述问题. 假设 y 有 m 个类别, 即 y1,......yn ∈ {C1,......Cm}, 对于样本 xt, 如果能计算出每个类别的条件概率 P(C1|xt),......P(Cm|xt), 那么可以认为概率最大的那个类别就是 xt 所属的类别.
h 叫做分类器. 分类算法的任务就是构造分类器 h.
分类器一个直观理解就是在通过计算出的后验概率得到每个类别的概率, 并输出最高类别的概率为分类结果.
分类算法的内容是要求给定特征, 让我们得出类别, 这也是所有分类问题的关键. 每一个不同的分类算法, 对应着不同的核心思想.
2. 朴素贝叶斯
朴素贝叶斯 (Naive Bayes) 算法理论基础是基于贝叶斯定理和条件独立性假设的一种分类方法. 朴素的意思是假设各个特征之间相互条件独立的.
贝叶斯分类器的基本方法: 在统计资料的基础上, 依据找到的一些特征属性, 来计算各个类别的概率, 找到概率最大的类, 从而实现分类. 即贝叶斯分类器通过预测一个对象属于某个类别的概率, 再预测其类别.
找到一个已知分类的待分类项集合, 这个集合叫做训练样本集.
统计得到在各类别下各个特征属性的条件概率估计.
找出最大概率的那个类.
3. 公式解说
3.1 贝叶斯定理
前文呼延灼的方法是:
求解问题(A): 呼延灼想知道自己是否是公明哥哥的心腹, 用 A 来代表 "你是大哥的心腹".
已知结果(B): 大哥对你下拜. 记作事件 B.
推理结果 P(A|B): 想通过大哥对你下拜这个事件, 来判断大哥视你为心腹的概率.
于是有:
P(A|B) = P(B|A)P(A)/P(B)
P(A|B) 也就是在 B 事件 "大哥下拜" 发生之后, 对 A 事件 "大哥视你为心腹" 概率的重新评估.
其实上述公式也隐含着: 通过贝叶斯公式能够把人分成两类: 大哥的心腹 / 普通下属.
3.2 用类别的思路重新解读
所以贝叶斯公式可以用类别的思路重新解读.
我们把 B 理解成 "具有某特征", 把 A 理解成 "类别标签". 在最简单的二分类问题 (是与否判定) 下, 我们将 A 理解成 "属于某类" 的标签.
P(类别 | 特征)=P(特征 | 类别)P(类别)/P(特征)
P(A)是先验概率, 表示每种类别分布的概率;
P(B|A)是条件概率, 表示在某种类别前提下, 某事发生的概率; 该条件概率可通过统计而得出, 这里需要引入极大似然估计概念.
P(A|B)是后验概率, 表示某事发生了, 并且它属于某一类别的概率, 有了这个后验概率, 便可对样本进行分类. 后验概率越大, 说明某事物属于这个类别的可能性越大, 便越有理由把它归到这个类别下.
3.3 扩展到多个条件(特征)
之前只假设 A 只有 B 一个条件, 但在实际应用中, 很少有一件事只受一个特征影响的情况, 往往影响一件事的因素有多个. 假设, 影响 B 的因素有 n 个, 分别是 b1,b2,...,bn.
则 P(A|B) 可以写为:
P(A|b1,b2,...,bn) = P(A) P(b1,b2,...,bn|A) / P(b1,b2,...,bn)
因为假设从 b1 到 bn 这些特征之间, 在概率分布上是条件独立的, 也就是说每个特征 bi 与其他特征都不相关. 所以可以做如下转换
P(b1,b2,...,bn|A) = P(b1|A)P(b2|A)...P(bn|A)
这个转换其实就是 独立变量的联合分布 = 各变量先验分布的乘积. 只不过这里是条件概率, 但是因为变换前后都有同样的条件 A, 从样本空间 A 的角度看, 其实就是联合分布转换成先验分布的乘积.
所以贝叶斯定理可以做如下推导
P(A|b1,b2,...,bn) = P(A) [P(b1|A)P(b2|A)...P(bn|A)] / P(b1,b2,...,bn)
0x02 呼延灼如何应用朴素贝叶斯模型来分类:
话说在前文[白话解析] 深入浅出贝叶斯定理中, 呼延灼通过贝叶斯定理, 推出了自己不是公明哥哥心腹的结论. 虽然有些气闷, 但是也好奇于贝叶斯定理的威力, 于是他就决定用朴素贝叶斯模型对马军头领和步军头领进行分类.
1. 极简版朴素贝叶斯分类模型
目前有一个极简版朴素贝叶斯分类模型, 能区分出两个类(A1, A2), 用来分类的特征也有两个(B1, B2).
所以公式为:
P(A|B1,B2) = P(A) [P(B1|A)P(B2|A)] / P(B1,B2)
这个就是分类器:
P(A|B1,B2) = P(A) [P(B1|A)P(B2|A)] / P(B1,B2) = P(A) [P(B1|A)P(B2|A)] / [P(B1) P(B2)]
b1,b2 表示特征变量, Ai 表示分类, p(Ai|b1,b2)表示在特征为 b1,b2 的情况下分入类别 Ai 的概率
再重温下朴素贝叶斯分类器, 通过预测一个对象属于某个类别的概率, 再预测其类别.
找到一个已知分类的待分类项集合, 这个集合叫做训练样本集.
统计得到在各类别下各个特征属性的条件概率估计.
找出最大概率的那个类.
2. 已知条件
样本是 10 位马军头领, 10 位步兵头领, 现在设定如下:
已知有两个分类:
A1 = 马军头领
A2 = 步军头领
两个用来分类的特征:
F1 = 纹身
F2 = 闹事
特征可以如下取值:
f11 = 有纹身
f12 = 无纹身
f21 = 爱闹事
f22 = 不爱闹事
有了分类器模型和预制条件, 下面就看如何推导出分类器模型参数了.
3. 训练过程和数据
以下是根据已知数据统计得来. 就是由实际数值训练出来的 分类器参数.
假定 马军头领中, 2 位有纹身, 1 位爱闹事, 步兵头领中, 7 位有纹身, 6 位爱闹事. 所以得到统计数据如下:
- P(有纹身) = P(f11) = (7+2)/20 = 9/20 = 0.45
- P(无纹身) = P(f12) = 11/20 = 0.55
- P(爱闹事) = P(f21) = 7/20 = 0.35
- P(不爱闹事) = P(f22) = 13/20 = 0.65
- P(F1=f11|A=A1) = P(有纹身 | 马军头领) = 2/20 = 0.1
- P(F1=f12|A=A1) = P(无纹身 | 马军头领) = 8/20 = 0.4
- P(F1=f11|A=A2) = P(有纹身 | 步兵头领) = 7/20 = 0.35
- P(F1=f12|A=A2) = P(无纹身 | 步兵头领) = 3/20 = 0.15
- P(F2=f21|A=A1) = P(爱闹事 | 马军头领) = 1/20 = 0.05
- P(F2=f22|A=A1) = P(不爱闹事 | 马军头领) = 9/20 = 0.45
- P(F2=f21|A=A2) = P(爱闹事 | 步兵头领) = 6/20 = 0.3
- P(F2=f22|A=A2) = P(不爱闹事 | 步兵头领) = 4/20 = 0.2
这样就训练 (统计) 出来了一个分类器模型的参数.
可以结合之前的分类器
P(A|F1,F2) = P(A) [P(F1|A)P(F2|A)] / P(F1,F2) = P(A) [P(F1|A)P(F2|A)] / [P(F1) P(F2)]
来对 "待分类数据" 做处理了.
4. 如何分类
如果有某位头领 x: 不纹身, 不闹事. 进行针对两个分类 (马军头领, 步兵头领) 进行两次运算, 得出两个数值.
(不纹身, 不闹事)是马军头领的可能性
- P(马军头领 | 不纹身, 不闹事) = P(马军头领) [P(无纹身 | 马军头领) P(不闹事 | 马军头领) ] / [P(无纹身)P(不闹事)]
- P(A=A1|x) = p(A=A1) P(F1=f12|A=A1)p(F2=f22|A=A1) / [P(f12)P(f22)] = 0.5 * 0.4 * 0.45 / [0.55 * 0.65] = 0.18 / [0.55 * 0.65] = 0.25
(不纹身, 不闹事)是步兵头领的可能性
- P(步兵头领 | 不纹身, 不闹事) = P(步兵头领) [P(无纹身 | 步兵头领) P(不闹事 | 步兵头领) ] / [P(无纹身)P(不闹事)]
- P(A=A2|x) = p(A=A2) P(F1=f12|A=A2)p(F2=f22|A=A2) / [P(f12)P(f22)] = 0.5 * 0.15 * 0.2 / [0.55 * 0.65] = 0.03 / [0.55 * 0.65] = 0.04
所以 x 是马军的可能性更大.
贝叶斯定理最大的好处是可以用已知的频率去计算未知的概率, 我们 简单地将频率当成了概率.
0X03 参考 snowNLP 的源码
我们可以通过 snowNLP 的源码来对朴素贝叶斯模型再进一步理解.
在 bayes 对象中, 有两个属性 d 和 total,d 是一个数据字典, total 存储所有分类的总词数, 经过 train 方法训练数据集后, d 中存储的是每个分类标签的数据 key 为分类标签, value 是一个 AddOneProb 对象.
这里的代码就是简单地将频率当成了概率. 训练就是统计各个分类标签 (key) 所对应的个数.
1. 源码
- # 训练数据集
- def train(self, data):
- #遍历数据集, data 中既包含正样本, 也包含负样本
- for d in data: # data 中是 list
- # d[0]: 分词的结果, list
- # d[1]: 标签 -->分类类别, 正 / 负样本的标记
- c = d[1]
- #判断数据字典中是否有当前的标签
- if c not in self.d:
- #如果没有该标签, 加入标签, 值是一个 AddOneProb 对象
- self.d[c] = AddOneProb() # 类的初始化
- #d[0]是评论的分词 list, 遍历分词 list
- for Word in d[0]:
- #调用 AddOneProb 中的 add 方法, 添加单词
- self.d[c].add(Word, 1)
- #计算总词数, 是正类和负类之和
- self.total = sum(map(lambda x: self.d[x].getsum(), self.d.keys())) # # 取得所有的 d 中的 sum 之和
- class AddOneProb(BaseProb):
- def __init__(self):
- self.d = {}
- self.total = 0.0
- self.none = 1
- # 添加单词
- def add(self, key, value):
- #更新该类别下的单词总数
- self.total += value
- #如果单词未出现过, 需新建 key
- if not self.exists(key):
- #将单词加入对应标签的数据字典中, value 设为 1
- self.d[key] = 1
- #更新总词数
- self.total += 1
- #如果单词出现过, 对该单词的 value 值加 1
- self.d[key] += value
具体分类则是计算各个分类标签的概率
- # 贝叶斯分类
- def classify(self, x):
- tmp = {}
- #遍历每个分类标签
- for k in self.d: # 正类和负类
- #获取每个分类标签下的总词数和所有标签总词数, 求对数差相当于 log(某标签下的总词数 / 所有标签总词数)
- tmp[k] = log(self.d[k].getsum()) - log(self.total) # 正类 / 负类的和的 log 函数 - 所有之和的 log 函数
- for Word in x:
- #获取每个单词出现的频率, log[(某标签下的总词数 / 所有标签总词数)* 单词出现频率]
- tmp[k] += log(self.d[k].freq(Word))
- #计算概率
- ret, prob = 0, 0
- for k in self.d:
- now = 0
- try:
- for otherk in self.d:
- now += exp(tmp[otherk]-tmp[k])
- now = 1/now
- except OverflowError:
- now = 0
- if now> prob:
- ret, prob = k, now
- return (ret, prob)
2. 源码推导公式
对于有两个类别 c1,c1 的分类问题来说, 其特征为 w1,,wn, 特征之间是相互独立的, 属于类别 c1 的贝叶斯模型的基本过程为:
P(c1∣w1,,wn)=P(w1,,wn∣c1)P(c1) / P(w1,,wn)
如果做句子分类, 可以认为是出现了 w1, w2, ..., wn 这些词之后, 该句子被归纳到 c1 类的概率.
其中:
P(w1,,wn)=P(w1,,wn∣c1)P(c1) + P(w1,,wn∣c2)P(c2)
预测的过程使用到了上述的公式, 即:
\[ P(c1∣w1,,wn)=\frac{P(w1,,wn∣c1)P(c1)}{P(w1,,wn∣c1)P(c1)+P(w1,,wn∣c2)P(c2)} \]
对上述的公式简化:
- \[ P(c1∣w1,,wn)=\frac{
- P(w1,,wn∣c1)P(c1)
- }{
- P(w1,,wn∣c1)P(c1)+P(w1,,wn∣c2)P(c2)
- } \]
- \[ =\frac{
- 1
- }{
- 1+\frac{
- P(w1,,wn∣c2)P(c2)
- }{
- P(w1,,wn∣c1)P(c1)
- }
- } \]
- \[ =\frac{
- 1
- }{
- 1+exp[log(\frac{
- P(w1,,wn∣c2)P(c2)
- }{
- P(w1,,wn∣c1)P(c1)
- })]
- } \]
\[ =\frac{1}{1+exp[log(P(w1,,wn∣c2)P(c2))−log(P(w1,,wn∣c1)P(c1))]} \]
其中, 分母中的 1 可以改写为:
\[ 1=exp[log(P(w1,,wn∣c1)P(c1))−log(P(w1,,wn∣c1)P(c1))] \]
3. 结合公式再详解代码
根据上面的公式, 针对 c1, c2, 我们需要
a. 先求
\[ P(w1,,wn∣c1)P(c1) \]
b. 再求
\[ P(c1) \]
结合代码
p(Ck) = k 这类词出现的概率 = self.d[k].getsum() / self.total
p(w1|Ck) = w1 这个词在 Ck 类出现的概率 = self.d[k].freq(Word)
k = 1,2
c. 再计算
\[ log(P(w1,,wn∣c1)P(c1)) \]
这个公式就是
\[ log(P(w1|c1)...p(wn∣c1)P(c1)) \]
这个公式的结果就是:
\[ log(sum_{p(w1|C1)...p(wn|C1)}) + log(P(c1)) \]
最后展开:
\[ log(sum_{p(w1|C1)...p(wn|C1)}) + log(self.d[1].getsum()) - log(self.total)) \]
这个就是下面的 tmp[k]. 其中, 第一个 for 循环中的 tmp[k]对应了公式中的 log(P(ck)), 第二个 for 循环中的 tmp[k]对应了公式中的 log(P(w1,,wn∣ck)P(ck)). 两个 for 循环的结果就是最终的 tmp[k].
- def classify(self, x):
- tmp = {}
- for k in self.d: # 正类和负类
- tmp[k] = log(self.d[k].getsum()) - log(self.total) # 正类 / 负类的和的 log 函数 - 所有之和的 log 函数
- for Word in x:
- tmp[k] += log(self.d[k].freq(Word)) # 词频, 不存在就为 0
- ret, prob = 0, 0
- for k in self.d:
- now = 0
- try:
- for otherk in self.d:
- now += exp(tmp[otherk]-tmp[k]) # for 循环中有一个结果是 0, exp(0)就是 1. 就是上面分母中的 1
- now = 1/now
- except OverflowError:
- now = 0
- if now> prob:
- ret, prob = k, now
- return (ret, prob)
0x04 参考
朴素贝叶斯分类模型(一)
朴素贝叶斯分类 -- 大道至简 https://www.jianshu.com/p/96c334191852
带你搞懂朴素贝叶斯分类算法
snownlp 情感分析源码解析
朴素贝叶斯详解及中文舆情分析
[数据挖掘]朴素贝叶斯分类
NLP 系列(2)_用朴素贝叶斯进行文本分类(上)
情感分析 -- 深入 snownlp 原理和实践
来源: https://www.cnblogs.com/rossiXYZ/p/12148809.html