我爱自然语言处理 » 语言模型

微软：Web N-gram Services

52nlp — Wed, 12 May 2010 18:07:12 +0000

　　微软研究院的官方网站上近期发布了一篇文章：“Microsoft Web N-gram Services“，大意是邀请整个社区使用其提供的”Web N-gram services”,这个服务旨在通过基于云的存储平台，推动网络搜索，自然语言处理，语音技术等相关领域，在研究现实世界的大规模网络数据时，利用该服务所提供动态数据对项目中的常规数据进行补充更新，进而有所发现和创新。
　　有意思的是它的副标题：“Access petabytes of data via the Web N-gram services (Public Beta)”，注意微软这个服务提供的是PB(petabytes)级别的数据:
　　1PB = 1PeraByte = 1024 TB = 1024 * 1024 * 1024 MB
　　如果说Google的1T n-gram语言模型还可以压缩到大硬盘里使用的话，那么PB级别的n-gram语言模型目前来说最好的存储平台就是“云端”了。
　　微软的这项”Web N-gram Services”包括如下服务内容：
　　* Content types: Document Body, Document Title, Anchor Texts
　　* Model types: Smoothed models
　　* N-gram availability: unigram, bigram, trigram, N-gram with N=4, 5.（最大也是5元）
　　* Training size (Body): All documents indexed by Bing
　　* Access: Hosted Services by Microsoft
　　* Updates: Periodical updates
　　查了一下微软的这个“Web N-gram Services”，大致是在4月下旬WWW2010会议上公开的，之前一年属于”private beta”，目前是“public beta”，不过这篇文章最后说得是：“We are now expanding access in the Public Beta Web N-gram Services to include professors and students at accredited colleges and universities worldwide.” 似乎只针对授权的大学教授和学生开放。
　　不过网上目前可以查到如何使用该服务的文章：How to use Microsoft Web N-gram service，微软自己也有一个“Quick Start”，需要你”read the terms of use”并点击“I agree”之后就能看到，或者，可以试一下下面这个网页：

http://web-ngram.research.microsoft.com/info/quickstart.htm

　　这两份文档都比较详细，有兴趣和条件的读者可以试一下。

注：转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/微软-web-n-gram-services

Beautiful Data-统计语言模型的应用三：分词8

52nlp — Mon, 19 Apr 2010 16:19:17 +0000

　　对于一个包含n个字符的单词来说，利用语言模型进行分词的前提是首先枚举出所有的候选切分，而segment函数中：
　　candidates = ( [first] + segment( rem ) for first, rem in splits( text ) )
的作用正是如此，它包含了递归调用，因此能枚举出所有的候选切分。那么，这个函数的时间复杂度是多少呢？一个包含n个字符的字符串有2^(n-1)种不同的分词方案（在字符之间有n-1个位置，每一个位置既可以作为单词边界也可以不作为边界）,因此segment函数的时间复杂度为O（2^n),难怪之前的测试当字符串比较长时就跑不出结果了！
　　那么，我们应该如何来改进这个递归的分词程序呢？如果你了解一些算法知识，大概会想到动态规划算法：

　　动态规划是一种在数学和计算机科学中使用的，用于求解包含重叠子问题的最优化问题的方法。其基本思想是，将原问题分解为相似的子问题，在求解的过程中通过子问题的解求出原问题的解。
　　动态规划在查找有很多重叠子问题的情况的最优解时有效。它将问题重新组合成子问题。为了避免多次解决这些子问题，它们的结果都逐渐被计算并被保存，从简单的问题直到整个问题都被解决。因此，动态规划保存递归时的结果，因而不会在解决同样的问题时花费时间。（注：引自维基百科）

　　在segment.py中，segment函数的确是将问题划归成[first] + segment( rem )的子问题进行处理了，因此利用动态规划算法优化来改进segment函数应该成为首选了！不过， Peter Norvig大牛利用了Decorator。事实上，我也是python新手，当我读Beautiful Data中的这段源程序时，Decorator是最让我丈二和尚摸不着头脑的，所以找了一些关于Python Decorator的资料来学习，觉得对于本例，最需要注意的两点是：
　　第一，在Python中，一个函数可以将另一个函数作为参数，对另一个函数进行“包装“以加入新的相关操作，并最终返回一个新的函数。这话说得不太清楚，我们来看一个例子，例子来源于”The Quick Python Book, 2nd”中9.8节的例子，基于Python3.0，这里稍作调整：
　　首先定义一个myfunction:
　　>>> def myfunction( parameter ):
　　… 　　print( parameter )
　　…
　　测试myfunciton:
　　>>> myfunction( “Hello, Python Decorator!” )
　　Hello, Python Decorator!
　　然后定义一个decorate:
　　>>> def decorate( func ):
　　… 　　print ( “in decorate function, decroating”, func.__name__ )
　　… 　　def wrapper_func( *args ):
　　… 　　　　print( “Executing”, func.__name__ )
　　… 　　　　return func( *args )
　　… 　　return wrapper_func
　　用decorate“包装”myfunction:
　　>>> myfunction = decorate( myfunction )
　　(‘in decorate function, decroating’, ‘myfunction’)
　　再执行：
　　>>> myfunction( “Hello, Python Decorator!” )
　　(‘Executing’, ‘myfunction’)
　　Hello, Python Decorator!
　　看看输出结果，myfunction的确已经被“包装”了，事实上这一过程中没有什么新东西，不过就是重新返回了一个 wrapper_func函数给myfunction了，其实Python Decorator做得是同一样的事，只不过它的code更简洁和易读，所以被称之为Syntax sugar(语法糖），关于为何名为Syntax sugar, Bruce Eckel的“Python Decorators入门“介绍中译者给了如下的解释：

　　意指那些没有给计算机语言添加新功能，而只是对人类来说更“甜蜜“的语法。语法糖往往给程序员提供了更实用的编码方式，有益于更好的编码风格，更易读。不过其并没有给语言添加什么新东西。

　　解释的真是贴切，我们继续这个例子，为了区别对待myfunction，我们重新定义一个ourfunciton，不过在定义ourfunction之前先加上这块儿语法糖“＠”，表明其是Python Decorator程序:
　　>>> @decorate
　　… def ourfunction( parameter ):
　　… 　　print( parameter )
　　…
　　(‘in decorate function, decroating’, ‘ourfunction’)
　　以上的输出以表明ourfunction被decorate”包装“，继续测试ourfunction，
　　>>> ourfunction( “Hello, Python Decorator!” )
　　(‘Executing’, ‘ourfunction’)
　　Hello, Python Decorator!
　　效果确实与上同，只不过这一次的代码要简洁很多。

未完待续…

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/beautiful-data-统计语言模型的应用三分词8

安装Srilm的一点新变化

52nlp — Sat, 10 Apr 2010 12:44:58 +0000

　　读者Fanlc昨天在《Ubuntu 64位系统下SRILM的配置详解》下留言：“为什么我下载到的1.5.10版本，没有test文件夹呢?编译之后也没有……这怎么测试”。我手头没有Srilm的1.5.10版本，于是下载了一个看看，发现主目录下的确没有test文件夹，对比了一下1.5.9版本的Srilm目录，发现这是一点新变化。
　　对比了一下Srilm 1.5.10和1.5.9里自带的INSTALL文件,以下是diff后的结果：

103c103
< 7 – To test the compiled tools, change into the $SRILM/test directory and run
—
> 7 – To test the compiled tools, run
105c105,107
< gnumake all
—
> gnumake test
>
> from the top-level directory.
109,110c111,113
< reported, examine the output files in $SRILM/test/output and compare them
reported, examine the output files in $SRILM//test/output and
> compare them to the corresponding files in $SRILM//test/reference,
> where is a subdirectory name (lm, flm, lattice).
157c160
157c160
< $Date: 2009/06/28 09:12:45 $
—
> $Date: 2009/12/02 19:39:04 $

　　主要是第7步test时有变化，以前是：

cd test
make all

　　现在改为了：

make test

　　而1.5.10里test文件已不在主目录下，而是分别位于：$SRILM/lm & flm & lattice下。
　　晚上我在一台新机器上试着编译了一下1.5.10版本的Srilm，依然是检查安装依赖软件，修改Makefile，以及make World编译，而在测试时改变为“make test”，同样一大堆的IDENTICAL及少量DIFFERS出现。
　　写在这里，做个备忘，同时提醒将来可能会遇到此问题的读者，最后感谢Fanlc读者的提示！

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/安装Srilm的一点新变化

Beautiful Data-统计语言模型的应用三：分词7

52nlp — Wed, 07 Apr 2010 12:36:36 +0000

　　走到这一步，我们利用Google的一元语言模型进行分词的程序基本上已经完成了，先看一下已完成的segment.py程序吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

import operator

def segment( text ):
"""Return a list of words that is the best segmentation of text."""
if not text : return []
candidates = ( [first] + segment( rem ) for first, rem in splits( text ) )
return max( candidates, key = Pwords )

def splits( text, L = 20 ):
"""Return a list of all possible ( first, rem ) pairs, len( first ) <=L"""
return [ ( text[:i+1], text[i+1:] ) for i in range( min(len(text), L ) ) ]

def Pwords( words ):
"""The Naive Bayes probability of a sequence of words."""
return product( Pw(w) for w in words )

def product( nums ):
"""Return the product of a sequence of numbers."""
return reduce( operator.mul, nums, 1 )

class Pdist( dict ):
"""A probability distribution estimated from counts in datafile."""
def __init__( self, data, N = None, missingfn = None ):
for key, count in data:
self[key] = self.get( key, 0 ) + int( count )
self.N = float( N or sum( self.itervalues() ) )
self.missingfn = missingfn or ( lambda k, N: 1./N )

def __call__( self, key ):
if key in self: return self[key] / self.N
else: return self.missingfn( key, self.N )

def datafile( name, sep = '\t' ):
"""Read key, value pairs from file."""
for line in file( name ):
yield line.split( sep )

def avoid_long_words( word, N ):
　　"""Estimate the probability of an unknown word."""
return 10./( N * 10**len( word ) )

N = 1024908267229 ## Number of tokens in corpus

Pw = Pdist( datafile( 'count_1w.txt' ), N, avoid_long_words )

　　其中Pwords和segment两个函数还没有测试，先利用Python解释器测一下。先测count_1w.txt里前三个单词the,of,and，其中：
　　Count(the) = 23135851162
　　Count(of) = 13151942776
　　Count(and) = 12997637966

　　>>> segment.N
　　1024908267229L
　　>>> segment.Pw( “the” )
　　0.022573582340740989
　　>>> 23135851162. / segment.N
　　0.022573582340740989
　　>>> segment.Pw( “of” )
　　0.012832312116632971
　　>>> 13151942776. / segment.N
　　0.012832312116632971
　　>>> segment.Pw( “and” )
　　0.012681757364628494
　　>>> 12997637966. / segment.N
　　0.012681757364628494
　　测一个造出来的未登录词“theofand”:
　　>>> segment.Pw( “theofand” )
　　9.7569707648437317e-20
　　>>> 10. / ( segment.N * 10 ** len( “theofand” ) )
　　9.7569707648437317e-20

　　再来看Pwords函数，它返回“product( Pw(w) for w in words )”:
　　>>> segment.Pwords( ["the", "of", "and"] )
　　3.6735405611059254e-06
　　也就是等于：
　　>>> segment.Pw( “the” ) * segment.Pw( “of” ) * segment.Pw( “and” )
　　3.6735405611059254e-06

　　最后我们来看segment函数了，先测一下分词第一节所举的两个例子：
　　>>> segment.segment( “choosespain” )
　　['choose', 'spain']
　　>>> segment.segment( “insufficientnumbers” )
　　['insufficient', 'numbers']
　　不错，全分正确了，再试一下“自然语言处理”的英文单词：
　　>>> segment.segment( “naturallanguageprocessing” )
　　…
　　陷入了长时间的停顿，看看你机器的CPU，总有一个在100％的全力运行，但不管怎么说，还是等到了正确的分词结果：
　　['natural', 'language', 'processing']
　　如果读者愿意，可以继续试一下，譬如“我爱自然语言处理”：
　　>>> segment.segment( “Ilovenaturallanguageprocessing” )
　　…
　　这一次，我实在等不下去了。问题出在了什么地方？再回顾一下segment函数的代码吧：

1
2
3
4
5

def segment( text ):
"""Return a list of words that is the best segmentation of text."""
if not text : return []
candidates = ( [first] + segment( rem ) for first, rem in splits( text ) )
return max( candidates, key = Pwords )

　　关于“max(candidates,key=Pwords)”这里引用前一节评论中热心读者navygong的解释:

candidates实际上是个generator(生成器)，你提到的这两行代码就是计算每种候选分词方式的概率，并从中取概率最大的那种。如”wheninthecourse”可能的分词方式有
['w', 'henin', 'the', 'course']
['wh', 'en', 'in', 'the', 'course']
['whe', 'n', 'in', 'the', 'course']
…
['wheninthecour', 'se']
['wheninthecours', 'e']
['wheninthecourse']。
以['wh', 'en', 'in', 'the', 'course']为例，Pwords函数作用到这个列表上后得到的是各个词出现的概率的乘积。然后用max函数取出最大乘积的那种候选分词方式。

未完待续：分词8

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/beautiful-data-统计语言模型的应用三分词7

Beautiful Data-统计语言模型的应用三：分词6

52nlp — Wed, 31 Mar 2010 13:58:42 +0000

　　说完了Python中的__call__函数，我们继续来完善segment.py，首先将Pw函数删除：
　　def Pw( word ):
　　　　pass

　　然后，在程序中添加Pdist类的Pw对象：
　　Pw = Pdist( datafile( ‘count_1w.txt’ ), N, avoid_long_words )

　　Pdist类中分别调用了datafile和avoid_long_words函数，以及变量N，所以需要在此句之前添加：

1
2
3
4
5
6
7
8
9
10

　　def datafile( name, sep = '\t' ):
　　"""Read key, value pairs from file."""
　　　　for line in file( name ):
　　　　　　yield line.split( sep )

　　def avoid_long_words( word, N ):
　　　　"""Estimate the probability of an unknown word."""
　　　　return 10./( N * 10**len( word ) )

　　N = 1024908267229 ## Number of tokens in corpus

　　datafile函数中调用了yield生成器，网上的解释很多，看得有点晕，不过我觉得下面这句话最形象或者和我们这个例子最相关：

yield就相当于往一个list中塞东西而已，只不过写法很奇怪罢了。

　　还记得我们的测试例子吗？
　　>>> data_pair = [("A", 1), ("B", 2), ("C", 3), ("D", 4)]
　　data_pair就是一个list，而 datafile函数说白了，就是利用yield生成器来生成一个类似的list。多说无意，我们还是来看一个例子，首先在segment.py所在的目录下建立一个test_data的文件，内容如下：

A　　　　1
B　　　　2
C　　　　3
D　　　　4

　　在python解释器中：
　　>>> reload( segment )
　　在datafile函数读入test_data文件：
　　>>> test = segment.datafile( “test_data” )
　　观察一下test，是一个generator:
　　>>> test
　　
　　利用next()，遍历test:
　　>>> test.next()
　　['A', '1\n']
　　>>> test.next()
　　['B', '2\n']
　　>>> test.next()
　　['C', '3\n']
　　>>> test.next()
　　['D', '4\n']
　　>>> test.next()
　　Traceback (most recent call last):
　　File ““, line 1, in
　　StopIteration
　　重新试一次：
　　>>> test = segment.datafile( “test_data” )
　　并且：
　　>>> for data in test:
　　… print data,
　　…
　　['A', '1\n'] ['B', '2\n'] ['C', '3\n'] ['D', '4\n']
　　读者现在大概可以弄明白datafile函数的作用了吧！继续：
　　>>> Pw = segment.Pdist( segment.datafile( ‘test_data’) )
　　>>> Pw.N
　　10.0
　　>>> Pw(“A”)
　　0.10000000000000001
　　>>> Pw(“D”)
　　0.40000000000000002
　　>>> Pw(“E”)
　　0.10000000000000001
　　和我们之前定义的data_pair结果完全一样，只不过这一次我们把它们写在文件里了。
　　至于avoid_long_words函数，就是重载的未登录词处理函数，即为了避免过长的单词拥有过高的概率，我们从概率10/N出发，对于候选单词的每增加一个字母就除以10：
　　10. / ( N * 10**len( word ) )

　　可以在python解释器中测试一下：
　　>>> segment.avoid_long_words(“e”, Pw.N)
　　0.10000000000000001
　　>>> segment.avoid_long_words(“we”, Pw.N)
　　0.01
　　>>> segment.avoid_long_words(“the”, Pw.N)
　　0.001

未完待续：分词7

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/beautiful-data-统计语言模型的应用三分词6

Beautiful Data-统计语言模型的应用三：分词5

52nlp — Fri, 26 Mar 2010 16:36:33 +0000

　　上一节我们已经解读了Pdist类中的__init__函数，这一节重点关注一下Python类中的__call__函数。首先简单的回顾一下上一节提到的一段话：缺省的情况，对于未知的单词，其概率均为1/N，但是对于每一个实例，Pdist均提供一个函数重载这个缺省值。为了避免过长的单词拥有过高的概率，我们从概率10/N出发，对于候选单词的每一个字母都除以10。
　　要实现这个功能，Peter Norvig大牛利用了Python中的__call__函数,在Pdist类中加入:
　　class Pdist( dict ):
　　　　”"”A probability distribution estimated from counts in datafile.”"”
　　　　def __init__( self, data, N = None, missingfn = None ):
　　　　　　…
　　　　def _ _call_ _(self, key):
　　　　　　if key in self: return self[key]/self.N
　　　　　　else: return self.missingfn(key, self.N)
　　这个函数本身的意思比较清楚，通俗点讲，如果在语料库中找到了该单词及其计数，那么返回的概率就是 count(word)/N，否则就采用处理未登录词的函数，目前的缺省采用lambda函数: lambda k, N: 1./N，也就是返回1/N的概率值。
　　但是为什么要采用__call_函数呢？首先看一下Pythont中关于__call__的标准解释：
　　object.__call__(self[, args...])
　　　　Called when the instance is “called” as a function; if this method is defined, x(arg1, arg2, …) is a shorthand for x.__call__(arg1, arg2, …).
　　这个我一开始还没看明白，后来找了一段中文资料才算弄明白：

　　Python中有一个有趣的语法，只要定义类型的时候，实现__call__函数，这个类型就成为可调用的。
　　换句话说，我们可以把这个类型的对象当作函数来使用，相当于重载了括号运算符。

　　重点是第二句话，“可以把这个类型的对象当作函数来使用”。如果读者还记着我们在第三节时定义了一个辅助函数Pw:
　　def Pw( word ):
　　　　pass
　　当时的主要目的是为了能顺利的reload( segment )，事实上，在《Beautiful Data》的源代码中，这个函数是不存在的，确切的说，Pw是Pdist类的一个对象：
　　Pw = Pdist(datafile(‘vocab_common’), N, avoid_long_words)
　　再回顾一下Python中__call__的作用：“可以把这个类型的对象当作函数来使用”，所以Pdist类中有了__call__函数的定义之后，其对象Pw就可以当作函数使用了。
　　我们在Python解释器中测试一下：
　　>>> reload( segment )
　　重新定义一个数据集data_pair
　　>>> data_pair = [("A", 1), ("B", 2), ("C", 3), ("D", 4)]
　　初始化Pdist类的一个对象Pw,这里N和missgfun都采用缺省值:
　　>>> Pw = segment.Pdist( data_pair )
　　>>> Pw.N
　　10.0
　　以下开始调用__call__函数，A,B,C,D均在data_pair中存在，因此其概率为1/10, 2/10, 3/10, 4/10：
　　>>> Pw( “A” )
　　0.10000000000000001
　　>>> Pw( “B” )
　　0.20000000000000001
　　>>> Pw( “C” )
　　0.29999999999999999
　　>>> Pw( “D” )
　　0.40000000000000002
　　而对于E和UNK，在data_pair中不存在，因此调用未登录词处理函数，这里默认的概率为1/N，也就是1/10:
　　>>> Pw( “E” )
　　0.10000000000000001
　　>>> Pw( “UNK” )
　　0.10000000000000001

未完待续：分词6

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/beautiful-data-统计语言模型的应用三分词5

Beautiful Data-统计语言模型的应用三：分词4

52nlp — Sun, 14 Mar 2010 15:13:42 +0000

　　对于Pw函数，这里稍微多做一点说。首先我们从一元语言模型的文件里读取单词及其计数，如果一个单词在语料库中出现，它的概率就是Count(word)/N，这里N是语料库的单词数目的规模。事实上，相对于使用完整的1千3百万单词（词型）的一元语言模型，Peter Norvig大牛对这个一元语言模型进行了简化：（a) 创建了一个更通用的词汇表，并且其中的单词是大小写不敏感（不区分）的，故“the”,”The”以及“THE”的计数是加在一起作为“the”的计数的；(b)只有由字母(letter)组合的单词才被计入其中，而对于其他包含数字或者标点的“单词”则被过滤，故“+170.002”以及“can’t”都不会被计入；(c)只列出其中最常用的1百万单词中的前1/3，也就是333333个单词。
　　即使是一个trillion-word的语料库，某些单词也不一定能被其单词列表包括，这对于Pw来说也是一个问题，因为我们不能让它返回一个0概率，事实上，这就是统计语言模型中非常重要的平滑问题。
　　对于一个语料库中未出现的单词来说，如果不能返回0概率，那应该返回多少？Google语料库中的词例(token)数目N大约有1万亿个(a trillion)，在简化了的一元语言模型中，最小的常见单词的计数是12,711个。所以，一个未知单词的概率应该介于0到12,710/N之间。所有的未知词概率都一样也不大可能：一个20个字母组成的随机序列（单词）的概率就很可能比6个字母组成的随机序列（单词）的概率要小。
　　我们将定义一个概率分布的类Pdist，它将加载类似(key, count)形式数据文件。缺省的情况，对于未知的单词，其概率均为1/N，但是对于每一个实例，Pdist均提供一个函数重载这个缺省值。为了避免过长的单词拥有过高的概率，我们从概率10/N出发，对于候选单词的每一个字母都除以10。
　　好了，现在我们在segment.py中加入Pdist类：
　　class Pdist( dict ):
　　　　”"”A probability distribution estimated from counts in datafile.”"”
　　　　def __init__( self, data, N = None, missingfn = None ):
　　　　　　for key, count in data:
　　　　　　　　self[key] = self.get( key, 0 ) + int( count )
　　　　　　self.N = float( N or sum( self.inervalues() ) )
　　　　　　self.missingfn = missingfn or ( lambda k, N: 1./N )
　　在python中 __init__ 方法的作用与C++中的构造函数功能类似但不完全相同，具体解释如下：

__init__ 在类的实例创建后被立即调用。它可能会引诱你称之为类的构造函数，但这种说法并不正确。说它引诱，是因为它看上去像 (按照习惯，__init__ 是类中第一个定义的方法)，行为也像 (在一个新创建的类实例中，它是首先被执行的代码)，并且叫起来也像 (“init”当然意味着构造的本性)。说它不正确，是因为对象在调用 __init__ 时已经被构造出来了，你已经有了一个对类的新实例的有效引用。但 __init__ 是在 Python 中你可以得到的最接近构造函数的东西，并且它也扮演着非常相似的角色。
每个类方法的第一个参数，包括 __init__，都是指向类的当前实例的引用。按照习惯这个参数总是被称为 self。在 __init__ 方法中，self 指向新创建的对象；在其它的类方法中，它指向方法被调用的类实例。尽管当定义方法时你需要明确指定 self，但在调用方法时，你不用指定它，Python 会替你自动加上的。
__init__ 方法可以接受任意数目的参数，就像函数一样，参数可以用缺省值定义，即可以设置成对于调用者可选。

　　在本例中，N和missingfn都有一个缺省值 None，即 Python的空值，这两个参数稍后再定义。我们具体来看看 Pdist类中 __init__ 方法的作用：

for key, count in data:
　　self[key] = self.get( key, 0 ) + int( count )

　　由于要读取的一元语言模型文件形式如下：

the 23135851162
of 13151942776
…

　　这里利用了python中dictionary的get()函数，其作用是返回dict中指定键(key)的相应值(value)，如果没有找到key,则采用默认值： dict.get(key, default=None)。对于本例，key就是词型如the, count就是其计数，而对于未出现的单词，默认的初始化值为0。

self.N = float( N or sum( self.itervalues() ) )

　　这个表达式的作用是初始化参数N，即一元语言模型中总的词例数，可以由用户指定，如果用户没有指定，就利用dic.itervalues()方法遍历dic中的所有value，本例中也就是所有单词的计数，并求和：
　　dic.itervalues(): return an iterator over the mapping’s values

self.missingfn = missingfn or ( lambda k, N: 1./N )

　　missingfun参数的作用是调用一个处理未登录词的函数，如果用户没有指定，则调用lambda表达式：
　　lambda k, N: 1./N
　　lambda表达式是Python支持一种有趣的语法，它允许你快速定义单行的最小函数，这些也可以称之为 lambda函数，是从 Lisp 借用来的，可以用在任何需要函数的地方。可以利用python解释器来测试一下上面的lambda函数：
　　>>> ( lambda k, N : 1. / N )( 1, 2 )
　　0.5
　　>>> ( lambda k, N : 1. / N )( 2, 2 )
　　0.5
　　>>> ( lambda k, N : 1. / N )( 2, 5 )
　　0.20000000000000001
　　>>> ( lambda k, N : 1. / N )( 2, 10 )
　　0.10000000000000001
　　第一个参数k在这里似乎还没有任何作用，而该lambda函数的作用就是：缺省的情况，对于未知的单词其返回概率均为1/N。
　　现在我们可以利用python解释器来测试一下Pdist类中的__init__函数：
　　首先定义一组测试数据：
　　>>> data_pair = [ ("A", 1), ("B", 2), ("C", 3) ]
　　然后reload:
　　>>> reload( segment )
　　
　　最后生成一个Pdist类的对象test:
　　>>> test = segment.Pdist( data_pair )
　　>>> test.N
　　6.0
　　>>> test.missingfn
　　 at 0xb7d4cd84>
　　注意其中的参数N和missingfun都采用缺省值,因此test.N返回的是data_pair中的value和，而test.missingfn返回的是__init__中定义的lambda函数: lambda k, N: 1./N,可以继续测试一下：
　　>>> test.missingfn( 1, 5 )
　　0.20000000000000001
　　>>> test.missingfn( 2, 5 )
　　0.20000000000000001
　　>>> test.missingfn( 2, test.N )
　　0.16666666666666666
　　>>> test.missingfn( 2, 6 )
　　0.16666666666666666

未完待续：分词5

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/beautiful-data-统计语言模型的应用三分词4

Beautiful Data-统计语言模型的应用三：分词3

52nlp — Tue, 09 Mar 2010 16:47:49 +0000

　　本节我们进入《Beautiful Data》中分词的编码阶段，完整的程序及数据大家可以在“Natural Language Corpus Data: Beautiful Data”上下载ngrams.zip，我这里主要做一些解读。程序由python实现，无论在Linux或者Windows平台下，只要安装了相应的python版本，程序均可以通过测试，不过我所使用的是python2.6，注意，在python3.0上会有一些问题。
　　首先新建一个segment.py文件，依据上一节的思路，我们定义一个segment函数：
　　
　　def segment( text ):

　　　　”"”Return a list of words that is the best segmentation of text.”"”

　　　　if not text : return []

　　　　candidates = ( [first] + segment( rem ) for first, rem in splits( text ) )

　　　　return max( candidates, key = Pwords )

　　segment函数的目标就是“ 对于所有的候选切分，选择P(first) × P(remaining) 乘积最高的那一个作为最佳切分”，事实上它里面包括了递归调用，最终返回的是最佳的分词短语，这个我们暂且不说，且看看它另外调用的两个函数splits和Pwords，在segment.py中加入如下的代码：

　　def splits( text, L = 20 ):

　　　　”"”Return a list of all possible ( first, rem ) pairs, len( first ) <=L"""

　　　　return [ ( text[:i+1], text[i+1:] ) for i in range( min(len(text), L ) ) ]

　　def Pwords( words ):

　　　　pass

　　splits函数的作用是返回所有可能的将字符串切分成首词和剩余字符串切分结果，Pwords稍后再论，暂且”pass”，我们利用python解释器来测试一下splits函数：
　　nlp@52nlp:~/python/beautiful$ python

　　Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)

　　[GCC 4.3.3] on linux2

　　Type "help", "copyright", "credits" or "license" for more information.

　　>>> import segment

　　>>> split = segment.splits( “12345″ )

　　>>> print split

　　[('1', '2345'), ('12', '345'), ('123', '45'), ('1234', '5'), ('12345', '')]

　　>>> split = segment.splits( “wheninthecourse” )

　　>>> print split

　　[('w', 'heninthecourse'), ('wh', 'eninthecourse'), ('whe', 'ninthecourse'), ('when', 'inthecourse'), ('wheni', 'nthecourse'), ('whenin', 'thecourse'), ('whenint', 'hecourse'), ('wheninth', 'ecourse'), ('wheninthe', 'course'), ('wheninthec', 'ourse'), ('whenintheco', 'urse'), ('wheninthecou', 'rse'), ('wheninthecour', 'se'), ('wheninthecours', 'e'), ('wheninthecourse', '')]

　　当然，你也可以测试一下:
　　>>> split = segment.splits
( “wheninthecourseofhumaneventsitbecomesnecessary” )
　　print之后的结果会比较长。

　　再来看Pwords函数，在segment.py中将其修改为：
　　def Pwords( words ):

　　　　”"”The Naive Bayes probability of a sequence of words.”"”

　　　　return product( Pw(w) for w in words )

　　《Beautiful Data》中的标准解释是“The Naive Bayes probability of a sequence of words”，既“单词序列的朴素贝叶斯（Naive Bayes，简称NB）概率“，朴素贝叶斯概率的核心在于它假设向量的所有分量之间是独立的，这里的向量是单词序列，故假设的是所有单词之间是独立的，这也是我们利用一元语言模型的一个前提假设。回顾’wheninrome’这个分词例子，它有很多候选分词短语，譬如“when in rome”，利用一元语言模型，只需计算P(when) × P(in) × P(rome)。
　　不过Pwords函数同样调用了两个辅助函数:product和Pw(w)，在segment.py中加入如下的代码：
　　def product( nums ):

　　　　”"”Return the product of a sequence of numbers.”"”

　　　　return reduce( operator.mul, nums, 1 )

　　def Pw( word ):

　　　　pass

　　并且在segment.py的开始处加入：
　　import operator

　　因为product函数调用了operator模块中的二元乘积mul函数：
　　operator.mul(a, b)
　　operator.__mul__(a, b)
　　　　Return a * b, for a and b numbers.
　　事实上operator.mul是被producet中的reduce函数调用的，reduce在python2.6中是内建函数（注意在python3.0中已不是，需要“from functools import reduce”）:
　　reduce(func,seq[,init])：func 为二元函数，将func作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列的元素），连续的将现有的结果和下一个值作用在获得的随后的结果上，最后减少我们的序列为一个单一的返回值：如果初始值init给定，第一个比较会是init和第一个序列元素而不是序列的头两个元素。
　　这里的func为operator.mul，最终reduce返回给product的结果是数字序列的乘积结果，可以在python的解释器中做如下验证：
　　>>> reload( segment )
　　
　　>>> segment.product( [1, 2, 3, 4, 5] )
　　120

未完待续：分词4

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/beautiful-data-统计语言模型的应用三分词3

Beautiful Data-统计语言模型的应用三：分词2

52nlp — Tue, 02 Mar 2010 13:06:15 +0000

　　现在，我们就可以应用这个方法来进行分词了。首先定义一个函数：segment，其输入是一串没有空格的字符串，而输出则是一个单词列表，既最好的分词结果：

　　>>> segment(‘choosespain’)
　　['choose', 'spain']

　　让我们从第一步概率语言模型开始。一个单词序列的概率是给定单词的上下文——在这里是前面的所有的单词——每一个单词概率之积。用数学公式可以如下表达：

　　P(W1:n) = Πk=1:nP(Wk | W1:k–1)

　　我们没有足够的数据来准确计算这个概率，所以我们可以通过使用小一点的语料库来近似地计算这个概率（公式）。由于Google语言模型最大到5元(5-grams),所以我们可以使用5-grams来计算整个单词序列的概率，故一个n-word序列的概率等于给定前4个单词（并不是前面所有单词）每一个单词的概率之积。
　　关于5元语言模型，存在三个困难。首先，Google语言模型中5-gram数据大约有30G，一般机器的内存是无法加载的。其次，很多5元短语的计数为0，我们需要一些方法来回退（或者平滑），既使用较短的（短语）序列来估计这些计数为0的5元短语概率。第三，候选短语的搜索空间将会很大，因为其所依赖的单词数目达到4个。当然，只要想点办法，所有的这三个困难都是可以克服的。但是我们可以先简化一下这个问题，仅考虑一元(unigram)语言模型，这样就能立即解决这三个问题。利用一元语言模型，单词序列的概率就等于每一个单词自身（没有依赖）概率之积，而每一个单词概率与其他单词概率是独立的：

　　 P(W1:n) = Πk=1:nP(Wk)

　　相应的，我们来看’wheninrome’这个分词例子，它有很多候选分词短语，譬如“when in rome”，利用一元语言模型，只需计算P(when) × P(in) × P(rome)。如果这个乘积结果比其他任何候选短语的乘积都高，那么“when in rome”就是最好的分词结果。
　　一个包含n个字符的字符串有2^(n-1)种不同的分词方案（在字符之间有n-1个位置，每一个位置既可以作为单词边界也可以不作为边界）。因此，对于字符串“ wheninthecourseofhumaneventsitbecomesnecessary”,有35万亿(trillion)种切分方法。但是可以肯定，你能够在几秒钟之内找到正确的分词形式，并且不需要枚举所有的候选分词短语。首先扫描“w”,然后是”wh”以及”whe”,并且拒绝这些不大可能的“单词”，但是接受“when”作为可能的“单词”。之后再扫描剩余的部分，与前面同理，依次找到可能的分词，并最终找到最佳的分词短语。一旦我们对问题做了简化，既每一个单词相互是独立的，那么也就意味着我们不需要考虑单词之间的所有组合。
　　这给了我们一个大致的分词函数轮廓：考虑将字符串切分成首词和剩余字符串所有分法（可以任意限定最长的单词长度，例如，L＝20字符）。对于每一种可能的分法，搜索剩余字符串最好的切分方法。对于所有的候选切分， P(first) × P(remaining) 乘积最高的那一个就是最佳分法。

未完待续：分词3

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/beautiful-data-统计语言模型的应用三分词2

Beautiful Data-统计语言模型的应用三：分词1

52nlp — Fri, 26 Feb 2010 15:43:45 +0000

　　本节我们开始《Beautiful Data》中的“Word Segmentation”之旅，虽然Peter Norvig大牛从中文分词的需求讲起，但本节事实上讲得是英文分词，毕竟Google语言模型是以英文语料库为基础的，用中文分词举例Google语言模型就无用武之地了。一般说来，英文是不需要分词的，基本上tokenization就够了。但是某些时候，譬如英文网址（URLs)就没有空格，对于搜索引擎或者文字处理程序来说正确的分词就很重要了。不过，无论英文分词还是中文分词，利用统计语言模型来分词的思想本质是一样的。
　　首先来看一个例子，如“choosespain.com”，这是一个希望说服你“choose Spain”(选择西班牙）作为旅游目的地的网站。如果被分成“chooses pain”（选择痛苦），其结果可想而知。对于人类来说，凭借多年的经验，做出正确的分词应该没什么问题，但是对于计算机，将这些经验进行编码几乎是不可能的任务。不过还是有“捷径”可以走的：对于这两条候选的分词短语，在Google语言模型中的二元（bigram）表中进行查找，其中“choose Spain”出现了3,210次，而”chooses pain”则没有出现，这也就意味着”chooses pain”在Google的trillion-word语料库中出现的次数少于40次。因此，“choose Spain”至少有80倍的可能作为正确的分词结果。
　　再来看另一个例子，假设存在这样一个未分词的短语“insufficientnumbers”，如果我们不考虑Google语言模型里的单词的大小写问题，以下两种分法的计数结果是：

　　insufficient numbers 20751
　　in sufficient numbers 32378

　　虽然后者比前者多了大约50％，但是相对于Google语料库的规模，区别不是很明显，尽管我们可以猜测哪一个是正确的分词结果，却不能肯定这个猜测。对于不确定的问题，我们没有任何办法计算出一个百分百正确的答案，也没有一个完整的模型使得只有一个结果是正确的，事实上对于人类专家来说也是如此。不过，对于解决这类不确定的问题，还是有一套既定的方法：
　　1.定义一个概率模型。我们不能通过定义所有的要素（语义、语法、词汇等）来决定“choose Spain”是否是一个更好的候选分词结果，但是可以通过一个简化的模型给出一个近似的概率。对于较短的候选短语如“choose Spain”,可以通过在语料库数据中查找n-gram次数的方式来决定其概率。对于较长的候选短语，可以通过将其分解为较小短语的方式来得到相关的概率。至于未登录词，也可以通过一些方法估计其概率。这里的关键点就是定义一个语言模型(language model)——一个覆盖了大多数字符串的某种语言的概率分布——并且通过语料库数据学习相关的参数，然后利用该模型来决定每一个候选短语的概率。
　　2.枚举候选短语。我们不能确定”insufficient numbers”或者”in sufficient numbers”中哪一个是更可能的分词短语，但是我们可以将这两个均看作是候选短语，甚至““in suffi cient numb ers”也是候选。在这一步里，我们暂时不做判断，而是尽可能多的枚举各种可能的候选短语，或者仔细的挑选样本。
　　3.选择最可能的候选短语。对于每一个候选短语，利用语言模型计算其概率，然后选择获得最高概率的那一个短语作为最佳结果。
　　如果你喜欢数学公式，那么这个方法可以定义为：
　　　best = argmax c∈candidates P(c)
　　或者，如果你喜欢计算机编码（我们将使用Python)，也可以如下描述：
　　　best = max(c in candidates, key=P)

未完待续：分词2

注：原创文章，转载请注明出处“我爱自然语言处理”：www.52nlp.cn

本文链接地址：http://www.52nlp.cn/beautiful-data-统计语言模型的应用三分词1