贝叶斯推断

原文链接：

http://www.ruanyifeng.com/blog/2011/08/bayesian_inference_part_one.html

http://www.ruanyifeng.com/blog/2011/08/bayesian_inference_part_two.html

http://www.ruanyifeng.com/blog/2012/10/spelling_corrector.html

 

以下为笔记：

贝叶斯推断是贝叶斯定理的应用。

 

1.贝叶斯定理：实际上就是条件概率公式。

条件概率(Conditional probability)：就是只事件B发生的情况下，事件A发生的概率，用P(A|B)来表示。

​

P(A|B)=P(A∩B)/P(B) =>P(A∩B)=P(A|B)*P(B), 同理可得=>P(A∩B)=P(B|A)*P(A) , 所以 P(A|B)*P(B)=P(B|A)*P(A)，即  P(A|B)=P(B|A)*P(A)/P(B)。

 

2. 全概率公式

P(B)=P(B∩A)+P(B∩A')=P(B|A)*P(A)+P(B|A')*P(A') 

这就是全概率公式：如果A和A'构成样本空间的一个划分，那么事件B的概率，就等于A和A'的概率分别乘以B对这两个事件的条件概率之和。

因此条件概率公式：P(A|B)=P(B|A)*P(A)/ ( P(B|A)*P(A)+P(B|A')*P(A') )

 

3.贝叶斯推断：

P(A|B)=P(A)*P(B|A)/P(B)：=> 后验概率=先验概率 * 调整因子

P(A)："先验概率" (Prior probability) , 即在B事件发生之前，我们对A事件概率的一个判断；

P(A|B)："后验概率"（Posterior probability），即在B事件发生之后，我们对A事件概率的重新评估；

 

P(B|A)/P(B)："可能性函数"（Likelyhood），这是一个调整因子，使得预估概率更接近真实概率

在这里，如果"可能性函数"P(B|A)/P(B)>1，意味着"先验概率"被增强，事件A的发生的可能性变大；如果"可能性函数"=1，意味着B事件无助于判断事件A的可能性；如果"可能性函数"<1，意味着"先验概率"被削弱，事件A的可能性变小。

 

4.例子：

栗子1：

 

两个一模一样的碗，一号碗有30颗水果糖和10颗巧克力糖，二号碗有水果糖和巧克力糖各20颗。现在随机选择一个碗，从中摸出一颗糖，发现是水果糖。请问这颗水果糖来自一号碗的概率有多大？

我们假定，H1表示一号碗，H2表示二号碗。由于这两个碗是一样的，所以P(H1)=P(H2)，也就是说，在取出水果糖之前，这两个碗被选中的概率相同。因此，P(H1)=0.5，我们把这个概率就叫做"先验概率"，即没有做实验之前，来自一号碗的概率是0.5。

再假定，E表示水果糖，所以问题就变成了在已知E的情况下，来自一号碗的概率有多大，即求P(H1|E)。我们把这个概率叫做"后验概率"，即在E事件发生之后，对P(H1)的修正。

根据条件概率公式，得到 P(H1|E)=P(H1)*P(E|H1)/P(E)

已知，P(H1)等于0.5，P(E|H1)为一号碗中取出水果糖的概率，等于0.75，那么求出P(E)就可以得到答案。根据全概率公式，

P(E)=P(E|H1)*P(H1)+P(E|H2)*P(H2)  ,所以，P(E)=0.75x0.5+0.5x0.5=0.625

将数字代入原方程，得到 P(H1|E)=0.5x0.75/0.625 = 0.6

 

栗子2：

 

已知某种疾病的发病率是0.001，即1000人中会有1个人得病。现有一种试剂可以检验患者是否得病，它的准确率是0.99，即在患者确实得病的情况下，它有99%的可能呈现阳性。它的误报率是5%，即在患者没有得病的情况下，它有5%的可能呈现阳性。现有一个病人的检验结果为阳性，请问他确实得病的可能性有多大？

假定A事件表示得病，那么P(A)为0.001。这就是"先验概率"，即没有做试验之前，我们预计的发病率。再假定B事件表示阳性，那么要计算的就是P(A|B)。这就是"后验概率"，即做了试验以后，对发病率的估计。

根据条件概率公式，P(A|B)=P(B|A)*P(A)/P(B)

用全概率公式改写分母，P(A|B)=P(A)*P(B|A)/ ( P(B|A)*P(A)+P(B|A')*P(A') )

将数字代入，P(A|B)=0.001*0.99 / (0.99*0.001+0.05*0.999)≈ 0.019

我们得到了一个惊人的结果，P(A|B)约等于0.019。也就是说，即使检验呈现阳性，病人得病的概率，也只是从0.1%增加到了2%左右。这就是所谓的"假阳性"，即阳性结果完全不足以说明病人得病。

为什么会这样？为什么这种检验的准确率高达99%，但是可信度却不到2%？答案是与它的误报率太高有关。（【习题】如果误报率从5%降为1%，请问病人得病的概率会变成多少？P≈0.90164）

 

5.应用1—垃圾邮件过滤

传统的垃圾邮件过滤方法：“关键词法”和“校验码法”。前者过滤依据是特定的词语，后者是计算邮件文本的校验码，再与已知的垃圾邮件进行对比。效果不理想且容易规避。

贝叶斯过滤器：具有自我学习功能，收到垃圾邮件越多，准确率越高。原理：贝叶斯推断。

过程如下图：

栗子：

历史资料库：我们假定"sex"这个词，在4000封垃圾邮件中，有200封包含这个词，那么它的出现频率就是5%，P(W|S)=5%；而在4000封正常邮件中，只有2封包含这个词，那么出现频率就是0.05%,P(W|H)=0.05%；

贝叶斯过滤器使用：未分析前，假定是垃圾邮件概率50%，P(H)=P(S)=50%；

对新邮件进行解析: P(S|W)=5%X50% / (5%X50%+0.05%X50%) =99%

 

模型改进：

单凭一个词还无法断定新邮件就是垃圾邮件，需要多个词联合判断，提高准确率。

联合概率的计算：

联合概率：多个事件发生的情况下，另一个事件发生的概率是多大。例如已知W1和W2是两个不同的词语，它们都出现在某封电子邮件之中，那么这封邮件是垃圾邮件的概率，就是联合概率。

 

加上所有事件都是独立事件，P(E1)=P(S|W1)P(S|W2)P(S) , P(E2)=(1-P(S|W1)) (1-P(S|W2)) (1-P(S)) ,又由于在W1和W2已经发生的情况下，垃圾邮件的概率等于下面的式子 P=P(E1)/(P(E1)+P(E2)) = P(S|W1)P(S|W2)P(S) / ( (1-P(S|W1)) (1-P(S|W2)) (1-P(S)) ) ,P(S)=0.5，= > 

P= P1P2/(P1P2+(1-P1)(1-P2)) --联合概率公式

 

更多个词（假定15个词）：最终联合概率公式：P= P1 P2 ...P15 / （P1 P2 ...P15+(1-P1) (1-P2) ... (1-P15)）

 

6.应用2—拼写检查

场景：用户输入一个检索词，拼错，提示正确的拼法。

应用贝叶斯推断有点：快，短时间内可处理大量文本，且有很高的精度。

 

6.1原理：

用户输入了一个单词。这时分成两种情况：拼写正确，或者拼写不正确。我们把拼写正确的情况记做c（代表correct），拼写错误的情况记做w（代表wrong）。

所谓"拼写检查"，就是在发生w的情况下，试图推断出c。从概率论的角度看，就是已知w，然后在若干个备选方案中，找出可能性最大的那个c，也就是求下面这个式子的最大值。P(c|w)

根据贝叶斯定理：P(c|w) = P(w|c) * P(c) / P(w)

对于所有备选的c来说，对应的都是同一个w，所以它们的P(w)是相同的，因此我们求的其实是P(w|c) * P(c) 的最大值。

P(c)的含义是，某个正确的词的出现"概率"，它可以用"频率"代替。如果我们有一个足够大的文本库，那么这个文本库中每个单词的出现频率，就相当于它的发生概率。某个词的出现频率越高，P(c)就越大。

P(w|c)的含义是，在试图拼写c的情况下，出现拼写错误w的概率。这需要统计数据的支持，但是为了简化问题，我们假设两个单词在字形上越接近，就有越可能拼错，P(w|C)就越大。举例来说，相差一个字母的拼法，就比相差两个字母的拼法，发生概率更高。你想拼写单词hello，那么错误拼成hallo（相差一个字母）的可能性，就比拼成haallo高（相差两个字母）。

所以，我们只要找到与输入单词在字形上最相近的那些词，再在其中挑出出现频率最高的一个，就能实现 P(w|c) * P(c) 的最大值。

 

6.2算法：

第一步，建立一个足够大的文本库。

网上有一些免费来源，比如古登堡计划、Wiktionary、英国国家语料库等等。

第二步，取出文本库的每一个单词，统计它们的出现频率。

第三步，根据用户输入的单词，得到其所有可能的拼写相近的形式。

所谓"拼写相近"，指的是两个单词之间的"编辑距离"（edit distance）不超过2。也就是说，两个词只相差1到2个字母，只通过----删除、交换、更改和插入----这四种操作中的一种，就可以让一个词变成另一个词。

第四步，比较所有拼写相近的词在文本库的出现频率。频率最高的那个词，就是正确的拼法。

根据Peter Norvig的验证，这种算法的精确度大约为60%-70%（10个拼写错误能够检查出6个。）虽然不令人满意，但是能够接受。毕竟它足够简单，计算速度极快。（本文的最后部分，将详细讨论这种算法的缺陷在哪里。）

 

6.3 代码：（python）

第一步，把网上下载的文本库保存为big.txt文件。这步不需要编程。

 

第二步，加载Python的正则语言模块（re）和collections模块，后面要用到。

　　import re, collections

第三步，定义words()函数，用来取出文本库的每一个词。

　　def words(text): return re.findall('[a-z]+', text.lower())

lower()将所有词都转成小写，避免因为大小写不同，而被算作两个词。

第四步，定义一个train()函数，用来建立一个"字典"结构。文本库的每一个词，都是这个"字典"的键；它们所对应的值，就是这个词在文本库的出现频率。

　　def train(features):

　　　　model = collections.defaultdict(lambda: 1)

　　　　for f in features:

　　　　　　model[f] += 1

　　　　return model

collections.defaultdict(lambda: 1)的意思是，每一个词的默认出现频率为1。这是针对那些没有出现在文本库的词。如果一个词没有在文本库出现，我们并不能认定它就是一个不存在的词，因此将每个词出现的默认频率设为1。以后每出现一次，频率就增加1。

第五步，使用words()和train()函数，生成上一步的"词频字典"，放入变量NWORDS。

　　NWORDS = train(words(file('big.txt').read()))

第六步，定义edits1()函数，用来生成所有与输入参数word的"编辑距离"为1的词。

　　alphabet = 'abcdefghijklmnopqrstuvwxyz'

　　def edits1(word):

　　　　splits = [(word[:i], word[i:]) for i in range(len(word) + 1)]

　　　　deletes = [a + b[1:] for a, b in splits if b]

　　　　transposes = [a + b[1] + b[0] + b[2:] for a, b in splits if len(b)>1]

　　　　replaces = [a + c + b[1:] for a, b in splits for c in alphabet if b]

　　　　inserts = [a + c + b for a, b in splits for c in alphabet]

　　　　return set(deletes + transposes + replaces + inserts)

edit1()函数中的几个变量的含义如下：

　　（1）splits：将word依次按照每一位分割成前后两半。比如，'abc'会被分割成 [('', 'abc'), ('a', 'bc'), ('ab', 'c'), ('abc', '')] 。

　　（2）beletes：依次删除word的每一位后、所形成的所有新词。比如，'abc'对应的deletes就是 ['bc', 'ac', 'ab'] 。

　　（3）transposes：依次交换word的邻近两位，所形成的所有新词。比如，'abc'对应的transposes就是 ['bac', 'acb'] 。

　　（4）replaces：将word的每一位依次替换成其他25个字母，所形成的所有新词。比如，'abc'对应的replaces就是 ['abc', 'bbc', 'cbc', ... , 'abx', ' aby', 'abz' ] ，一共包含78个词（26 × 3）。

　　（5）inserts：在word的邻近两位之间依次插入一个字母，所形成的所有新词。比如，'abc' 对应的inserts就是['aabc', 'babc', 'cabc', ..., 'abcx', 'abcy', 'abcz']，一共包含104个词（26 × 4）。

最后，edit1()返回deletes、transposes、replaces、inserts的合集，这就是与word"编辑距离"等于1的所有词。对于一个n位的词，会返回54n+25个词。

第七步，定义edit2()函数，用来生成所有与word的"编辑距离"为2的词语。

　　def edits2(word):

　　　　return set(e2 for e1 in edits1(word) for e2 in edits1(e1))

但是这样的话，会返回一个 (54n+25) * (54n+25) 的数组，实在是太大了。因此，我们将edit2()改为known_edits2()函数，将返回的词限定为在文本库中出现过的词。

　　def known_edits2(word):

　　　　return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in NWORDS)

第八步，定义correct()函数，用来从所有备选的词中，选出用户最可能想要拼写的词。

　　def known(words): return set(w for w in words if w in NWORDS)

　　def correct(word):

　　　　candidates = known([word]) or known(edits1(word)) or known_edits2(word) or [word]

　　　　return max(candidates, key=NWORDS.get)

我们采用的规则为：

　　（1）如果word是文本库现有的词，说明该词拼写正确，直接返回这个词；

　　（2）如果word不是现有的词，则返回"编辑距离"为1的词之中，在文本库出现频率最高的那个词；

　　（3）如果"编辑距离"为1的词，都不是文本库现有的词，则返回"编辑距离"为2的词中，出现频率最高的那个词；

　　（4）如果上述三条规则，都无法得到结果，则直接返回word。

至此，代码全部完成，合起来一共21行。

　　import re, collections

　　def words(text): return re.findall('[a-z]+', text.lower())

　　def train(features):

　　　　model = collections.defaultdict(lambda: 1)

　　　　for f in features:

　　　　　　model[f] += 1

　　　　return model

　　NWORDS = train(words(file('big.txt').read()))

　　alphabet = 'abcdefghijklmnopqrstuvwxyz'

　　def edits1(word):

　　　　splits = [(word[:i], word[i:]) for i in range(len(word) + 1)]

　　　　deletes = [a + b[1:] for a, b in splits if b]

　　　　transposes = [a + b[1] + b[0] + b[2:] for a, b in splits if len(b)>1]

　　　　replaces = [a + c + b[1:] for a, b in splits for c in alphabet if b]

　　　　inserts = [a + c + b for a, b in splits for c in alphabet]

　　　　return set(deletes + transposes + replaces + inserts)

　　def known_edits2(word):

　　　　return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in NWORDS)

　　def known(words): return set(w for w in words if w in NWORDS)

　　def correct(word):

　　　　candidates = known([word]) or known(edits1(word)) or known_edits2(word) or [word]

　　　　return max(candidates, key=NWORDS.get)

使用方法如下：

　　>>> correct('speling')

　　'spelling'

　　>>> correct('korrecter')

　　'corrector'

6.4 缺陷

我们使用的这种算法，有一些缺陷，如果投入生产环境，必须在这些方面加入改进。

（1）文本库必须有很高的精确性，不能包含拼写错误的词。

如果用户输入一个错误的拼法，文本库恰好包含了这种拼法，它就会被当成正确的拼法。

（2）对于不包含在文本库中的新词，没有提出解决办法。

如果用户输入一个新词，这个词不在文本库之中，就会被当作错误的拼写进行纠正。

（3）程序返回的是"编辑距离"为1的词，但某些情况下，正确的词的"编辑距离"为2。

比如，用户输入reciet，会被纠正为recite（编辑距离为1）,但用户真正想要输入的词是receipt（编辑距离为2）。也就是说，"编辑距离"越短越正确的规则，并非所有情况下都成立。

（4）有些常见拼写错误的"编辑距离"大于2。

这样的错误，程序无法发现。下面就是一些例子，每一行前面那个词是正确的拼法，后面那个则是常见的错误拼法。

purple perpul

curtains courtens

minutes muinets

successful sucssuful

inefficient ineffiect

availability avaiblity

dissension desention

unnecessarily unessasarily

necessary nessasary

unnecessary unessessay

night nite

assessing accesing

necessitates nessisitates

（5）用户输入的词的拼写正确，但是其实想输入的是另一个词。

比如，用户输入是where，这个词拼写正确，程序不会纠正。但是，用户真正想输入的其实是were，不小心多打了一个h。

（6）程序返回的是出现频率最高的词，但用户真正想输入的是另一个词。

比如，用户输入ther，程序会返回the，因为它的出现频率最高。但是，用户真正想输入的其实是their，少打了一个i。也就是说，出现频率最高的词，不一定就是用户想输入的词。

（7）某些词有不同的拼法，程序无法辨别。

比如，英国英语和美国英语的拼法不一致。英国用户输入'humur'，应该被纠正为'humour'；美国用户输入'humur'，应该被纠正为'humor'。但是，我们的程序会统一纠正为'humor'。