(这个系列的第一部分介绍了贝叶斯定理,第二部分介绍了如何过滤垃圾邮件,今天是第三部分。)
使用谷歌的时候,如果你拼错一个单词,它会提醒你正确的拼法。
比如,你不小心输入了 seperate。
谷歌告诉你,这个词是不存在的,正确的拼法是 separate。
这就叫做"拼写检查"(spelling corrector)。有好几种方法可以实现这个功能,谷歌使用的是基于贝叶斯推断的统计学方法。这种方法的特点就是快,很短的时间内处理大量文本,并且有很高的精确度(90%以上)。谷歌的研发总监 Peter Norvig,写过一篇著名的文章,解释这种方法的原理。
下面我们就来看看,怎么利用贝叶斯推断,实现"拼写检查"。其实很简单,一小段代码就够了。
一、原理
用户输入了一个单词。这时分成两种情况:拼写正确,或者拼写不正确。我们把拼写正确的情况记做 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) 的最大值。
二、算法
最简单的算法,只需要四步就够了。
第一步,建立一个足够大的文本库。
网上有一些免费来源,比如古登堡计划、Wiktionary、英国国家语料库等等。
第二步,取出文本库的每一个单词,统计它们的出现频率。
第三步,根据用户输入的单词,得到其所有可能的拼写相近的形式。
所谓"拼写相近",指的是两个单词之间的"编辑距离"(edit distance)不超过2。也就是说,两个词只相差1到2个字母,只通过----删除、交换、更改和插入----这四种操作中的一种,就可以让一个词变成另一个词。
第四步,比较所有拼写相近的词在文本库的出现频率。频率最高的那个词,就是正确的拼法。
根据 Peter Norvig 的验证,这种算法的精确度大约为60%-70%(10个拼写错误能够检查出6个。)虽然不令人满意,但是能够接受。毕竟它足够简单,计算速度极快。(本文的最后部分,将详细讨论这种算法的缺陷在哪里。)
三、代码
我们使用 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'
四、缺陷
我们使用的这种算法,有一些缺陷,如果投入生产环境,必须在这些方面加入改进。
(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'。
(完)
reverland 说:
考研正复习到贝叶斯公式,看上去挺有意思,晚上回来试试。
2012年10月16日 18:59 | # | 引用
Frank 说:
big.txt 是怎么样的,可否放出下载呢?
2012年10月16日 19:00 | # | 引用
w 说:
第一个图片下面的seperate应该是separate
2012年10月16日 19:22 | # | 引用
邓安良 说:
我现在正在学习机器学习,你给的这个程序很有意思,我现在就来实现下!!!!
2012年10月16日 21:21 | # | 引用
90 说:
贝叶斯公式在概率论里早学过了,可是从来没用到过实际中,理论学习与实际运用确实差的很远。
2012年10月16日 22:09 | # | 引用
胡戎航 说:
这确实是模式识别与机器学习里面很生动的一个例子。谢谢你
2012年10月16日 22:34 | # | 引用
阮一峰 说:
谢谢指出,已经改正了。
我已经加上链接了。其实,随便找几本英文版的长篇小说就可以运行了。
2012年10月17日 00:03 | # | 引用
ham 说:
呵呵~终于有一次能看懂您的算法方面的文章,谢谢
2012年10月17日 01:26 | # | 引用
Magic 说:
如果要推断的是中文呢?
2012年10月17日 10:07 | # | 引用
muxueqz 说:
s/beletes/deletes/g
呵呵,应该是小手误
2012年10月17日 10:59 | # | 引用
arkodatta 说:
深入浅出,学习了~
2012年10月17日 11:52 | # | 引用
happy15 说:
为什么对所有的c,p(w)都是相同的呢?
2012年10月18日 09:36 | # | 引用
thx 说:
就比如说,你想输入happy 但是误写成 happb(用W表示) 最有可能的正确的词
文本库的所有拼写相近的形式的值:
happy 用C1表示
hapb 用C2表示
根据贝叶斯定理:
happy是正确的词的概率 P(c1|w) = P(w|c1) * P(c1) / P(w)
happ是正确的词的概率 P(c2|w) = P(w|c2) * P(c2) / P(w)
比较 happy 和 happ 哪个概率大, 分母是相同的,就没必要比较了
我自己有个疑问:
@阮兄
请问下 P(w|c1) 和 P(w|c2) 怎么取呢?
2012年10月19日 12:53 | # | 引用
gaobaba 说:
所有与 w 距离一步的 c,P(w|c) 都认为相同,因此简单比较 c 的先验概率就行了。所有与 w 距离两步的 c之间,P(w|c) 也认为相同。但任意一个距离一步的 c1,与任意一个距离两步的 c2相比,认为 P(w|c1) 远远大于 P(w|c2)。
所以是先在距离一步的 c 中选择先验概率最大的。如果这个集合为空,再在两步的集合中选。
2012年10月19日 18:27 | # | 引用
dee 说:
看了你翻译 , 正好也想用用贝叶斯来实现相关应用 . 写得很简单易懂, 自己也实现了一遍 ..谢谢分享.
2012年10月19日 23:26 | # | 引用
混沌 说:
这篇文章看不懂,且不说它,浏览你的主页大半天了,挺有意思的。经济学博士,本来猜测你是台湾旅美留学路线派的,像李开复那样,不过又没从你的文字表达里面感觉到台湾的味道。挺佩服你的,你的主页收藏了。让我这乡间野人多看看世界,多知道点外面怎么样了。
2012年10月21日 10:39 | # | 引用
袁源 说:
看了这篇文章,理解了我以前一直想知道的“编辑距离”。还有具体实现,收藏了。
想付费结果发现快捷支付额度超了……
2012年10月21日 21:53 | # | 引用
futuredo 说:
edits2()返回的数组太大,把edit2()改为known_edits2()函数,将返回的词限定为在文本库中出现过的词。那可不可以把edits1()返回的词也限定在文本库中出现过的词?这一点不是很理解。。。
2012年10月22日 11:37 | # | 引用
Qbye 说:
这篇文章非常棒,学到很多,谢谢
2012年10月22日 16:56 | # | 引用
海纳百川 说:
有关算法的文章我还是要多学学哦,谢谢博主的分享。
2012年10月26日 16:23 | # | 引用
silence214 说:
这个方法简单易行,但是取决于推荐效果的我觉得还是文本库的构成。这个需要真的是真正把人们的习惯常用的给总结出来,提醒的时候可以满足大部分的正确需求。如果单纯的一个字典(也就是每个词的频率都一样的时候),推荐出来的方案就相当多了,当推荐方案相当多的时候意味着没有推荐。。
2012年10月30日 09:12 | # | 引用
Liang 说:
如果用“字形的接近程度“来表示P(w|c) ,不如用其直接表示P(w|c) * P(c),这样一来,这篇文章其实跟“贝叶斯”没有任何关系。
2012年11月 4日 15:12 | # | 引用
fisheuler 说:
我觉的您最好把作者一栏去掉,称自己为翻译者比较好。因为没有看出您所写的和peter novig的有什么不同。最好还是不要当抄袭者吧。
2012年11月13日 21:12 | # | 引用
travis 说:
我觉得你这句写错了吧
candidates = known([word]) or known(edits1(word)) or known_edits2(word) or [word]
known 函数返回的set,你用or来向表示什么呢?我觉得应该用“|”集合联合操作。
candidates = known([word]) | known(edits1(word)) | known_edits2(word)
2012年11月19日 16:31 | # | 引用
thx 说:
一个有趣的例子“recursion”
我以为是 拼音检查 功能,呵呵 蛮有趣的
2013年1月17日 18:01 | # | 引用
demo 说:
2013年3月25日 11:17 | # | 引用
P什么狗P 说:
(2)beletes:依次删除word的每一位后、所形成的所有新词
beletes ? deletes吧
2013年5月28日 19:33 | # | 引用
Cando 说:
我也想知道中文的拼写检查怎么做的。
2013年5月29日 17:39 | # | 引用
Noah 说:
还有一个缺陷,基于语义上下文的识别,这个没法弄。
2013年6月 4日 16:38 | # | 引用
宋小北 说:
很实用的东西,学习了
2014年5月30日 16:58 | # | 引用
yichu 说:
你的edit1中有操作splits,见下。
splits:将word依次按照每一位分割成前后两半。比如,'abc'会被分割成 [('', 'abc'), ('a', 'bc'), ('ab', 'c'), ('abc', '')] 。
对于长度为4的字符串,比如"abcd",会得到(ab,cd)的拆分结果,而它们与"abcd"的编辑距离显然不为1.
2015年8月11日 10:51 | # | 引用
jizhou 说:
您好,有一个问题请教一下,您提到:
P(w|c)的含义是,在试图拼写c的情况下,出现拼写错误w的概率。这需要统计数据的支持,但是为了简化问题,我们假设两个单词在字形上越接近,就有越可能拼错,P(w|C)就越大。举例来说,相差一个字母的拼法,就比相差两个字母的拼法,发生概率更高。你想拼写单词hello,那么错误拼成hallo(相差一个字母)的可能性,就比拼成haallo高(相差两个字母)。
既然可以直接用这种思路推出P(w|c),为什么不能用这种思路推出P(c|w)。虽然我可以想象得到直接用这种思路推出P(c|w)肯定不对,但是有没有理论支持。
2016年8月26日 14:04 | # | 引用
festone 说:
不得不说 文章真有水平
2016年9月21日 15:40 | # | 引用
dreamxun1213 说:
P(w|c) 没有体现在某一步中,只管了P(c)。
2016年10月 9日 17:24 | # | 引用
边宏飞 说:
这篇文章中,有很多不太懂的地方,
为什么:
对于所有备选的c来说,对应的都是同一个w,所以它们的P(w)是相同的,因此我们求的其实是
P(w|c) * P(c)
2017年4月14日 14:28 | # | 引用
阳丶疯 说:
是否可更新现在的Google拼写检查算法咧?
2019年6月24日 10:27 | # | 引用
汪荣顶 说:
对您的算法系列文章很感兴趣,感觉都写的很通俗易懂.
2021年4月10日 10:17 | # | 引用