贝叶斯算法

1、目的：求解逆向概率问题
公式 p(A|B) = P(B|A)*P(A)/P(B)
2、例子
一学校男生60% 女生40%
男生总是穿长裤，女生则一半穿长裤一半穿
正向概率：随机选取一个学生，他（她）穿长裤的概率和穿裙子的概率是多大
逆向概率：迎面走来一个穿长裤的学生，你只看得见他（她）穿的是否长裤，
而无法确定他（她）的性别，你能够推断出他（她）是女生的概率是多大吗？

 p(girl | Pants) = p(pants | girl) *p(girl) /p(pants) 
   p(pants)  = p(boy)* p( pants | boy) + p(girl)* p( pants | girl)  = 0.6 + 0.4*0.5
   p(girl | Pants) = 0.5*0.4/0.8

3、可解决的问题
3.1 拼写纠正实例
到用户输入了一个不在字典中的单词，我们需要去猜测：“这个家伙到底真正想输入的单词是什么呢？
用户实际输入的单词记为 D （ D 代表 Data ，即观测数据）
P(我们猜测他想输入的单词 | 他实际输入的单词)
P(h | D) = P(h) * P(D | h) / P(D)
对于不同的具体猜测 h1 h2 h3 … ，P(D) 都是一样的，所以在比较P(h1 | D) 和 P(h2 | D) 的时候我们可以忽略这个常数
P(h | D) ∝ P(h) * P(D | h)
P(h) 是特定猜测的先验概率，h单词的概率大小
比如用户输入tlp ，那到底是 top 还是 tip ？，一般来说 top 出现的程度要高
许多，所以更可能他想打的是 top
奥卡姆剃刀：越是高阶的多项式越是不常见
3.2 垃圾邮件过滤
问题：给定一封邮件，判定它是否属于垃圾邮件，D 来表示这封邮件，注意 D 由 N 个单词组成。我们用 h+ 来表示垃圾邮件，h- 表示正常邮件

P(h+|D) = P(h+) * P(D|h+) / P(D)
P(h- |D) = P(h- ) * P(D|h- ) / P(D)

先验概率：P(h+) 和 P(h-） 统计10000封邮件中，垃圾邮件和正常邮件的概率

P(d1,d2,..,dn|h+) 扩展为： P(d1|h+) * P(d2|d1, h+) * P(d3|d2,d1, h+) *...
#假设 di 与 di-1 是完全条件无关的，各个单词条件无关
P(d1,d2,..,dn|h+) 简化为 P(d1|h+) * P(d2|h+) * P(d3|h+) * 

4、简单的拼写检查器实现

#python3
import re, collections
#返回所有单词并转成小写
def words(text): return re.findall('[a-z]+', text.lower()) 
 #统计每个单词词频（默认为1，防止计算概率的时候0乘以其他都变成0了）
def train(features):
    model = collections.defaultdict(lambda: 1)
    for f in features:
        model[f] += 1
    return model
 #big.txt 为词库  NWORDS 为词频
NWORDS = train(words(open('big.txt').read()))

返回所有与单词 w 编辑距离为 1 的集合

alphabet = 'abcdefghijklmnopqrstuvwxyz'
#对单词增删改一个字母，返回集合
def edits1(word):
    n = len(word)
    return set([word[0:i]+word[i+1:] for i in range(n)] +                     # deletion
               [word[0:i]+word[i+1]+word[i]+word[i+2:] for i in range(n-1)] + # transposition
               [word[0:i]+c+word[i+1:] for i in range(n) for c in alphabet] + # alteration
               [word[0:i]+c+word[i:] for i in range(n+1) for c in alphabet])  # insertion
#返回词库中有的单词
def known(words): return set(w for w in words if w in NWORDS)

检查

#如果known(set)非空, candidate 就会选取这个集合, 而不继续计算后面的
def correct(word):
    candidates = known([word]) or known(edits1(word)) or  [word]
    return max(candidates, key=lambda w: NWORDS[w])