机器学习中的算法-贝叶斯算法

原创文章,如需转载请保留出处
本博客为唐宇迪老师python数据分析与机器学习实战课程学习笔记

一.贝叶斯算法概述
1.1贝叶斯简介：

• 贝叶斯（约1701-1761）Thomas Bayes，英国数学家
• 贝叶斯方法源于他生前为了解决一个“逆概”问题写的一篇文章

1.2贝叶斯要解决的问题

• 正向概率：假设袋子里面有N个白球，M个黑球，你伸手进去摸一把，摸出黑球的概率是多大
• 逆向概率：如果我们事先并不知道袋子里面黑白球的比例，而是闭着眼睛摸出一个（或好几个）球，观察这些取出来的球的颜色之后，那么我们可以就此对袋子里面的黑白球的比例作出什么样的推测

1.3 为什么使用贝叶斯

• 现实世界本身就是不确定的，人类的观察能力是有局限性的
• 我们日常所观察到的只是事物表面上的结果，因此我们需要提供一个猜测

1.4 举个例子
假设男生占60%，女生占40%。男生总是穿长裤，女生则一半穿长裤一半穿裙子

• 正向概率：随机选取一个学生，他（她）穿长裤的概率和穿裙子的概率是多大？
• 逆向概率：迎面走来一个穿长裤的学生，你只能看得见他（她）穿的是否长裤，而无法确定他（她）的性别，你能推断出他（她）是女生的概率是多大吗？

二.贝叶斯推导实例
假设学校里面人的总数是U个
穿长裤的（男生）：U * P(Boy)* P(Pants | Boy)

• P(Boy)：是男生的概率=60%
• P(Pants | Boy)：是条件概率，即在Boy这个条件下穿长裤的概率是多大，这里是100%，因为所有男生都穿长裤
  穿长裤的（女生）：U * P(Girl)* P(Pants | Girl)

求解：穿长裤的人里面有多少女生？

• 穿长裤总数：U * P(Boy) * P(Pants | Boy) + U * P(Girl)* P(Pants | Girl)
• P(Girl | Pants) = U * P(Girl) * P(Pants | Girl) / 穿长裤总数
  U * P(Girl)* P(Pants | Girl) / [ U * P(Boy)* P(Pants | Boy) + U * P(Girl)* P(Pants | Girl)]

化简：
P(Girl | Pants) =P(Girl)* P(Pants | Girl) / [ P(Boy)* P(Pants | Boy) + P(Girl)* P(Pants | Girl)]
分母其实就是P(Pants)
分子其实就是P(Pants，Girl)

贝叶斯公式：
P(A | B) = P(B | A)P(A) / P(B)

三.贝叶斯拼写纠错实例
3.1 拼写纠正实例

• 问题是我们看见用户输入一个不存在字典中的单词，我们需要去猜测：“这家伙到底真正想输入的单词是什么呢？”
• P（我们猜测他想输入的单词 | 他实际输入的单词）

3.2 解决问题
用户实际输入的单词为D（D代表Data，即观测数据）

• 猜测1：P(h1 | D)，猜测2：P(h2 | D)，猜测3：P(h3 | D)…统一为P(h | D)
• P(h | D) = P(h) * P(D | h) / P(D)

3.3 解决问题
用户实际输入的单词记为D（D代表Data，即观测数据）

• 对于不同的具体猜测h1h2h3…，P(D)都是一样的，所以在比较P(h1 | D)和P(h2 | D)的时候我们可以忽略这个常数
• P(h | D) ∝ P(h) * P(D | h) 对于给定观测数据，一个猜测是好是坏，取决于“这个猜测本身独立的可能性大小（先验概率，Prior，P(h)）”和“这个猜测生成我们观测到的数据的可能性大小（P(D | h)）”。

3.4 解决问题

• 贝叶斯方法计算：P(h) * P(D | h) ，P(h)是特定猜测的先验概率
• 比如用户输入tlp，那到底是top还是tip？这个时候，当最大似然不能做出决定性的判断时，先验概率就可以插手进来给出指示–“既然你无法决定，那么我告诉你，一般来说top出现的程度要高许多，所以他更可能想打的是top”

四.垃圾邮件过滤实例
4.1 模型比较理论1

• 最大似然：最符合观测数据的（即P(D | h)最大的）最有优势
• 奥卡姆剃刀：P(h)较大模型有较大的优势
• 投掷一个硬币，观察到的是”正“，根据最大似然估计是精神，我们应该猜测这枚硬币掷出”正“的概率是1，因为这个才是能最大化P(D | h)的那个猜测

4.2 模型比较理论2

• 如果平面上有N个点，近视构成一条直线，但绝不精准地位于一条直线上。这时我们既可以用直线来拟合（模型1），也可以用二阶多项式（模型2）拟合，也可以用三阶多项式（模型3），特别地，用N-1阶多项式便能够保证肯定能完美通过N个数据点。那么，这些可能的模型之中到底哪个是最靠谱的呢？
• 奥卡姆剃刀：越是高阶的多项式越是不常见

4.3 问题

• 给定一封邮件，判定它是否属于垃圾邮件。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- ) 这两个先验概率都是很容易求出来的，只需要计算一个邮件库里面垃圾邮件和正常邮件的比例就好啦。
• D里面含有N个单词d1，d2，d3，P(D | h+)=P(d1，d2，…dn | h+)
  P(d1，d2，…dn | h+)就是说在垃圾邮件当中出现跟我们目前这封邮件一模一样的一封邮件的概率是多大。
  {P(d1，d2，…dn | h+)扩展为：P(d1 | h+)*P(d2|d1| h+)P(d3|d2，d1 | h+)…}
• P(d1 | h+)*P(d2|d1| h+)P(d3|d2，d1 | h+)… ：假设di与di-1是完全条件无关的（朴素贝叶斯假设特征之间是独立，互不影响），简化为P(d1 | h+)*P(d2| h+)P(d3 | h+)…
• 对于P(d1 | h+)*P(d2| h+)P(d3 | h+)…只要统计di这个单词在垃圾邮件中出现的频率即可

五.贝叶斯实现拼写检查器
5.1 实现一个简单的拼写检查器

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(open('big.txt').read()))

alphabet = 'abcdefghijklmnopqrstuvwxyz'

def edits1(word):
    n = len(word)
    return set([word[0:i]+word[i+1:] for i in range(n)] +
              [word[0:i]+word[i+1]+word[i]+word[i+2:] for i in range(n-1)] +
              [word[0:i]+c+word[i+1:] for i in range(n) for c in alphabet] +
              [word[0:i]+c+word[i:] for i in range(n+1) for c in alphabet] )

def know_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=lambda w: NWORDS[w])

测试：

correct('morw')

‘more’

correct('appl')

‘apply’

5.2 求解
argmaxc P(c|w) ->argmaxc P(w|c)P©/P(w)

• P©：文章中出现一个正确拼写词c的概率，也就是说，在英语文章中，c出现的概率有多大
• P(w|c)：在用户想键入c的情况下敲成w的概率，因为这个是代表用户会以多大的概率把c敲成w
• argmaxc：用来枚举所有可能的c并且选取概率最大的

#把语料中的单词全部抽取出来，转成小写，并且去除单词中间的特殊符号
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(open('big.txt').read()))

要是遇到我们从来没有见过的新词怎么办，假如说一个词拼写完全正确，但是语料库中没有包含这个词，从而这个词也永远不会出现在训练集中，于是，我们就要返回出现这个词的概率是0。这个情况不太妙，因为概率为0这个代表了这个事件绝对不可能发生，而在我们的概率模型中，我们期望用一个很小的概率来代表这种情况。lambda：1

5.3 编辑距离
两个词之间的编辑距离定义为使用了几次插入(在词中插入一个单字母)，删除(删除一个单字母)，交换(交换相邻两个字母)，替换(把一个字母换成另外一个)的操作从一个词变成另一个词。

#返回所有与单词w编辑距离为1的集合
def edits1(word):
    n = len(word)
    return set([word[0:i]+word[i+1:] for i in range(n)] +
              [word[0:i]+word[i+1]+word[i]+word[i+2:] for i in range(n-1)] +
              [word[0:i]+c+word[i+1:] for i in range(n) for c in alphabet] +
              [word[0:i]+c+word[i:] for i in range(n+1) for c in alphabet] )

与something编辑距离为2的单词居然达到了114324个
优化：在这些编辑距离小于2的词中间，只把那些正确的词作为候选词，只能返回3个单词：‘smoothing’，‘something’，‘soothing’

#返回所有与单词w编辑距离为2的集合
#在这些编辑距离小于2的词中间，只把那些正确的词作为候选词
def know_edits2(word):
    return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in NWORDS)

正常来说把一个元音拼成另一个的概率要大于辅音(因为人常常把hello打成hallo这样)；把单词的第一个字母拼错的概率会相对小，等等，但是为了简单起见，选择了一个简单的方法：编辑距离为1的正确单词比编辑距离为2的优先级高，而编辑距离为0的正确单词优先级比编辑距离为1的高。

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

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