一，标记问题解决分词：就是将 词语开始和结束的字标记出来，就能对一个句子完成分词，假设使用两个标记B (开始)，E(结束)对句子进行处理，如：“民主是普世价值”，民B主E是B普B世E价B值E, 这样标记明确，分词结果就明确了。

二，如何找到最好的标记结果：知道如何用标记的方式解决分词，那么怎么为一个句子找到一个最好的标记序列呢，CRF为这样的问题提供了一个解决方案，对于输入序列X1,X2…Xn(对于分词，就是那个句子)，求这个输入序列条件下 某个 标记序列(Y1,Y2…Yn)的概率 极值。

三，解码过程：

这里用一个例子来说明，对于CRF的原理，我不做详述，我是半吊子，怕解释不好，只说一下我理解的解码过程。

CRF的公式：P(y|x,λ)=Σj λjFj(y,x)/Z(x)     //这里的j都是下标

先说问题：

使用4标记，B-开始，O-单独成词，M-词语中间的字，E-结束，

特征：一元特征，V-1 当前字的前一个字，V0当前字，V1当前字的后一个字

二元特征，各标记间的转移特征

句子如下：

民   主   是   普   世   价   值

B     B    B    B   B    B    B

O    O   O    O   O    O     O

M   M   M   M   M   M   M

E     E    E    E    E    E     E

Viterbe解码就是在以上由标记组成的 数组中 搜索一条 最优的路径。

对于每一列的每一个标记，我们都要计算到达该标记的分数，这个分数由三部分组成，它本身的一元特征权重W，它前面一个字标记的 路径分数PreScore，前面一个字标记到当前标记转移特征权重TransW，

1. 计算第一列的分数(score),对于，‘民’来说，我们要算 B,O,M,E的Score，因为是第一列，所以PreSocre和TransW都是0，就不用计算，只需要计算自己的一元特征的权重：

对于标记，B，我们计算它的Score，记为S1B=W1B=w(null,民,B)+w(民,B)+w(民,B,主)  //这些特征的意思是： (null，民，B)，当前字为 ‘民’标记为B，前面一个字为空，(民,B):当前字为‘民’，标记为B，(民,B,主)：当前字为’民’，标记为B，当前字的后一个字为‘主’。特征的权重都是在训练时得到的。

对于标记，O，M，E，一样要计算W1O，W1M，W1E,从而得到分数S1O，S1M，S1E

2.对于第二列，首先要计算是每个标记的 一元权重W2B，W2O,W2M,W2E.

对于B，到达该标记的最大分数为：S2B=Max((v(BB)+S1B),(v(OB)+S1O),(v(MB)+S1M),(v(EB)+S1E))+W2B，其中v(BB)等为B到B的转移特征的权重。这个也是由训练得到的。同样对于第二列的O,M,E也要计算S2O，S2M，S2E

3.一直计算到最后一列，‘值’字的所有标记，得到S7B，S7O，S7M，S7E.比较这四个值中的最大值，即为最优路径的分数，然后以该值的标记点为始点 回溯得到最优路径（这里在计算过程中，要记录到达该标记的前一个标记，用于回溯）

终于写好！:)

相关文章:

1. 初学者报道（2）：实现 1-gram分词算法
2. stardict2.4.8的main函数简要说明与注释
3. 基于哈希表和二叉树的词典研究(一)
4. MIT自然语言处理第一讲：简介和概述（第二部分）
5. MIT自然语言处理第二讲：单词计数（第四部分）
6. 条件随机场文献阅读指南

借鉴了之前在这个blog上看到的n-gram算法中的split函数的写法，其他部分自己写的。

Dictionary.py:

class Dictionary:
    'Dictionary Loading and Management'
    def __init__(self,dicname):
        self.dictMap={}
        self.N = 0;
        dictfile = open(dicname,'r')
        for eachLine in dictfile:
            dictstr = eachLine.decode("cp936")
            strlist = dictstr.split("t",2)
            self.dictMap[strlist[0]] = strlist[1].split("n",1)[0]
            self.N+=int(self.dictMap[strlist[0]])
        dictfile.close()
        print self.N
    def getCount(self,wordname):
        if(self.dictMap.has_key(wordname)):
            return int(self.dictMap[wordname])
        else:
            return 0.5;#如果词典中没有，这个词的出现次数被定为 0.5
    def getPvalue(self,wordname):
        return float(self.getCount(wordname))/self.N
    def isAWord(self,word):
        return self.dictMap.has_key(word)

if __name__=='__main__':
    dict1=Dictionary("dict.txt")

class Ngram:
    def __init__(self,dictionary):
        self.mDict=dictionary
        self.wordList=()
        self.valueMap = {}
        self.segMap={}
    def splitsentence(self,sentence):
        wordlist = []
        for eachNum in range(len(sentence)):
            wordlist.append((sentence[:eachNum+1],sentence[eachNum+1:]))
        return wordlist
    def maxP(self, sentence):
        if(len(sentence)<=1):
            return self.mDict.getPvalue(sentence)
        SenSplitList = self.splitsentence(sentence);
        maxPvalue = 0;
        wordPair = [];
        wordP = 0;
        for eachPair in SenSplitList:
            if(len(eachPair[0])>0 and len(eachPair[1])>0):
                p1=0;
                p2=0
                if(self.valueMap.has_key(eachPair[0])):
                    p1=self.valueMap[eachPair[0]]
                else:
                    p1=self.maxP(eachPair[0])
                if(self.valueMap.has_key(eachPair[1])):
                    p2=self.valueMap[eachPair[1]]
                else:
                    p2=self.maxP(eachPair[1])
                wordP=p1*p2
            if(maxPvalue<wordP):
                maxPvalue = wordP
                wordPair = eachPair

        v=self.mDict.getPvalue(sentence)
        if((v)>maxPvalue and self.mDict.isAWord(sentence)):
            self.valueMap[sentence]=v
            self.segMap[sentence]=sentence
            return v
        else:
            self.valueMap[sentence]=maxPvalue
            self.segMap[sentence]=wordPair
            return maxPvalue
    def getSeg(self):
        return self.segMap
if(__name__ =="__main__"):
    ngram1 = Ngram("dict1")
    print ngram1.splitsentence("ABC")

from Dictionary import Dictionary
from ngram import Ngram

def printSeg(segMap,sentence):
    if(segMap.has_key(sentence)):
        pair = segMap[sentence]
        if(isinstance(pair,tuple)):
            printSeg(segMap,pair[0])
            printSeg(segMap,pair[1])
        else:
            if(sentence==pair):
                print sentence
            else:
                printSeg(segMap,pair)
    else:
        print sentence

dict1 = Dictionary("dict.txt")
while(True):
    ngram1 =Ngram(dict1)
    sentence = raw_input("please input a Chinese Sentence:").decode("cp936");
    print ngram1.maxP(sentence)
    segmap=ngram1.getSeg()
    #for eachkey in segmap:

     #   if(isinstance(segmap[eachkey],tuple)):
      #      print (eachkey+":"+segmap[eachkey][0]+','+segmap[eachkey][1])
       # else:
        #    print (eachkey+":"+segmap[eachkey])
    printSeg(segmap,sentence)

相关文章:

1. 初学者报到: 实现了一个最大匹配的分词算法
2. Beautiful Data-统计语言模型的应用三：分词3
3. Beautiful Data-统计语言模型的应用三：分词8
4. 初学者报道(3) CRF 中文分词解码过程理解
5. 中文分词入门之最大匹配法
6. Beautiful Data-统计语言模型的应用三：分词7
7. Beautiful Data-统计语言模型的应用三：分词6
8. Beautiful Data-统计语言模型的应用三：分词5
9. 一个不错的自然语言处理词典
10. 基于哈希表和二叉树的词典研究(一)

今天下载了一个分词的字典，自己用python写了一个分词的函数。

放上来，给大家踩，不吝赐教！

用的是最大匹配算法。

# -*- coding: cp936 -*-

import string

def loaddict():
filename=raw_input(‘Enter file name:’)
f = open(filename,’r')

DICT={}
for eachLine in f:
dictStr = eachLine.decode(‘cp936′)
strList=dictStr.split(“t”,2)
DICT[strList[0]]=strList[1].split(“n”,1)[0]
global DIC_MAXL
if(DIC_MAXL<len(strList[0])):
DIC_MAXL = len(strList[0])
f.close()
print(“max length:”)
print(DIC_MAXL)
return DICT;

def segmentation(dic):
sentence = unicode(raw_input(‘请输入中文句子：’),’cp936′)
print sentence
length=len(sentence)
print(‘length:’)
print length
global DIC_MAXL
if(length<DIC_MAXL):
wlen=length
else:
wlen=DIC_MAXL
testS=sentence
wordList=[]
while(len(testS)>0):
word=testS[0:wlen]
meet=False;
while((not meet )and (len(word)>0) ):
if(dic.has_key(word)):
wordList.append(word)
testS=testS[len(word):len(testS)]
meet=True;
else:
if(len(word)==1):
wordList.append(word)
testS=testS[len(word):len(testS)]
meet=True;
else:
word=word[0:len(word)-1]
return wordList

DIC_MAXL=0
dictionary=loaddict()
print DIC_MAXL
while(True):
wordl=segmentation(dictionary)
for eachChar in wordl:
print eachChar

真的很初级，大家轻踩！

也别不好意思踩，踩了我就能进步了！

多谢

相关文章:

1. 初学者报道（2）：实现 1-gram分词算法
2. 中文分词入门之资源
3. Beautiful Data-统计语言模型的应用三：分词8
4. 中文分词入门之最大匹配法
5. Beautiful Data-统计语言模型的应用三：分词7
6. Beautiful Data-统计语言模型的应用三：分词3
7. 编译stardict-tools-3.0.1及使用stardict2txt
8. Beautiful Data-统计语言模型的应用三：分词6
9. MIT自然语言处理第二讲：单词计数（第四部分）
10. 中文分词入门之字标注法2

记得第一次了解中文分词算法是在 Google 黑板报 上看到的，当初看到那个算法时我彻底被震撼住了，想不到一个看似不可能完成的任务竟然有如此神奇巧妙的算法。最近在詹卫东老师的《中文信息处理导论》课上 再次学到中文分词算法，才知道这并不是中文分词算法研究的全部，前前后后还有很多故事可讲。在没有建立统计语言模型时，人们还在语言学的角度对自动分词进 行研究，期间诞生了很多有意思的理论。

中文分词的主要困难在于分词歧义。“结婚的和尚未结婚的”，应该分成“结婚／的／和／尚未／结婚／的”，还是“结婚／的／和尚／未／结婚／ 的”？人来判断很容易，要交给计算机来处理就麻烦了。问题的关键就是，“和尚未”里的“和尚”也是一个词，“尚未”也是一个词，从计算机的角度看上去，两 者似乎都有可能。对于计算机来说，这样的分词困境就叫做“交集型歧义”。

有时候，交集型歧义的“歧义链”有可能会更长。“中外科学名著”里，“中外”、“外科”、“科学”、“学名”、“名著”全是词，光从词库的 角度来看，随便切几刀下去，得出的切分都是合理的。类似的例子数不胜数，“提高产品质量”、“鞭炮声响彻夜空”、“努力学习语法规则”等句子都有这样的现 象。在这些极端例子下，分词算法谁优谁劣可谓是一试便知。

最简单的，也是最容易想到的自动分词算法，便是“最大匹配法”了。也就是说，从句子左端开始，不断匹配最长的词（组不了词的单字则单独划开），直 到把句子划分完。算法的理由很简单：人在阅读时也是从左往右逐字读入的，最大匹配法是与人的习惯相符的。而在大多数情况下，这种算法也的确能侥幸成功。不 过，这种算法并不可靠，构造反例可以不费吹灰之力。例如，“北京大学生前来应聘”本应是“北京／大学生／前来／应聘”，却会被误分成“北京大学／生前／来 ／应聘”。

维护一个特殊规则表，可以修正一些很机械的问题，效果相当不错。例如，“不可能”要划分成“不／可能”，“会诊”后面接“断”、“疗”、“脉”、“治”时要把“会”单独切出，“的确切”后面是抽象名词时要把“的确切”分成“的／确切”，等等。

还有一个适用范围相当广的特殊规则，这个强大的规则能修正很多交集型歧义的划分错误。首先我们要维护一个一般不单独成词的字表，比如 “民”、“尘”、“伟”、“习”等等；这些字通常不会单独划出来，都要跟旁边的字一块儿组成一个词。在分词过程中时，一旦发现这些字被孤立出来，都重新考 虑它与前面的字组词的可能。例如，在用最大匹配法切分“为人民服务”时，算法会先划出“为人”一词，而后发现“民”字只能单独成词了。查表却发现，“民” 并不能单独划出，于是考虑进行修正——把“为人”的“人”字分配给“民”字。巧在这下“为”和“人民”正好都能成词，据此便可得出正确的划分“为／人民／ 服务”。

不过，上述算法归根结底，都是在像人一样从左到右地扫描文字。为了把问题变得更加形式化，充分利用计算机的优势，我们还有一种与人的阅读习惯完全 不同的算法思路：把句子作为一个整体来考虑，从全局的角度评价一个句子划分方案的好坏。设计自动分词算法的问题，也就变成了如何评估分词方案优劣的问题。 最初所用的办法就是，寻找词数最少的划分。注意，每次都匹配最长的词，得出的划分不见得是词数最少的，错误的贪心很可能会不慎错过一些更优的路。因而，在 有的情况下，最少词数法比最大匹配法效果更好。若用最大匹配法来划分，“独立自主和平等互利的原则”将被分成“独立自主／和平／等／互利／的／原则”，一 共有 6 个词；但词数更少的方案则是“独立自主／和／平等互利／的／原则”，一共只有 5 个词。

当然，最少词数法也会有踩大便的时候。“为人民办公益”的最大匹配划分和最少词数划分都是“为人／民办／公益”，而正确的划分则是“为／人 民／办／公益”。同时，很多句子也有不止一个词数最少的分词方案，最少词数法并不能从中选出一个最佳答案。不过，把之前提到的“不成词字表”装备到最少词 数法上，我们就有了一种简明而强大的算法：

对于一种分词方案，里面有多少词，就罚多少分；每出现一个不成词的单字，就加罚一分。最好的分词方案，也就是罚分最少的方案。

这种算法的效果出人意料的好。“他说的确实在理”是一个很困难的测试用例，“的确”和“实在”碰巧也成词，这给自动分词带来了很大的障碍。但是“确”、“实”、“理”通常都不单独成词的，因此很多切分方案都会被扣掉不少分：

他／说／的／确实／在理 （罚分：1+1+1+1+1 = 5 ）
他／说／的确／实／在理 （罚分：1+1+1+2+1 = 6 ）
他／说／的确／实在／理 （罚分：1+1+1+1+2 = 6 ）

正确答案胜出。

需要指出的是，这个算法并不需要枚举所有的划分可能。整个问题可以转化为图论中的最短路径问题，利用动态规划效率则会更高。

算法还有进一步加强的余地。大家或许已经想到了，“字不成词”有一个程度的问题。“民”是一个不成词的语素，它是绝对不会单独成词的。 “鸭”一般不单独成词，但在儿歌童谣和科技语体中除外。“见”则是一个可以单独成词的语素，只是平时我们不常说罢了。换句话说，每个字成词都有一定的概 率，每个词出现的频率也是不同的。

何不用每个词出现的概率，来衡量分词的优劣？于是我们有了一个更标准、更连续、更自动的改进算法：先统计大量真实语料中各个词出现的频率，然后把每种分词方案中各词的出现概率乘起来作为这种方案的得分。利用动态规划，不难求出得分最高的方案。

以“有意见分歧”为例，让我们看看最大概率法是如何工作的。查表可知，在大量真实语料中，“有”、“有意”、“意见”、“见”、“分歧”的 出现概率分别是 0.0181 、 0.0005 、 0.0010 、 0.0002 、 0.0001 ，因此“有／意见／分歧”的得分为 1.8×10^-9 ，但“有意／见／分歧”的得分只有 1.0×10^-11 ，正确方案完胜。

这里的假设是，用词造句无非是随机选词连在一块儿，是一个简单的一元过程。显然，这个假设理想得有点不合理，必然会有很多问题。考虑下面这句话：

这／事／的确／定／不／下来

但是概率算法却会把这个句子分成：

这／事／的／确定／不／下来

原因是，“的”字的出现概率太高了，它几乎总会从“的确”中挣脱出来。

其实，以上所有的分词算法都还有一个共同的大缺陷：它们虽然已经能很好地处理交集型歧义的问题，却完全无法解决另外一种被称为“组合型歧 义”的问题。所谓组合型歧义，就是指同一个字串既可合又可分。比如说，“个人恩怨”中的“个人”就是一个词，“这个人”里的“个人”就必须拆开；“这扇门 的把手”中的“把手”就是一个词，“把手抬起来”的“把手”就必须拆开；“学生会宣传部”中的“学生会”就是一个词，“学生会主动完成作业”里的“学生 会”就必须拆开。这样的例子非常多，“难过”、“马上”、“将来”、“才能”、“过人”、“研究所”、“原子能”都有此问题。究竟是合还是分，还得取决于 它两侧的词语。到目前为止，所有算法对划分方案的评价标准都是基于每个词固有性质的，完全不考虑相邻词语之间的影响；因而一旦涉及到组合型歧义的问题，最 大匹配、最少词数、概率最大等所有策略都不能实现具体情况具体分析。

于是，我们不得不跳出一元假设。此时，便有了那个 Google 黑板报上提到的统计语言模型算法。对于任意两个词语 w₁ 、 w₂ ，统计在语料库中词语 w₁ 后面恰好是 w₂ 的概率 P(w₁, w₂) 。这样便会生成一个很大的二维表。再定义一个句子的划分方案的得分为 P(∅, w₁) · P(w₁, w₂) · … · P(w_n-1, w_n) ，其中 w₁, w₂, …, w_n 依次表示分出的词。我们同样可以利用动态规划求出得分最高的分词方案。这真是一个天才的模型，这个模型一并解决了词类标注、语音识别等各类自然语言处理问题。

至此，中文自动分词算是有了一个漂亮而实用的算法。

但是，随便拿份报纸读读，你就会发现我们之前给出的测试用例都太理想了，简直就是用来喂给计算机的。在中文分词中，还有一个比分词歧义更令人头疼 的东西——未登录词。中文没有首字母大写，专名号也被取消了，这叫计算机如何辨认人名地名之类的东西？最近十年来，中文分词领域都在集中攻克这一难关。

在汉语的未定义词中，中国人名的规律是最强的了。根据统计，汉语姓氏大约有 1000 多个，其中“王”、“陈”、“李”、“张”、“刘”五大姓氏的覆盖率高达 32% ，前 400 个姓氏覆盖率高达 99% 。人名的用字也比较集中，“英”、“华”、“玉”、“秀”、“明”、“珍”六个字的覆盖率就有 10.35% ，最常用的 400 字则有 90% 的覆盖率。虽然这些字分布在包括文言虚词在内的各种词类里，但就用字的感情色彩来看，人名多用褒义字和中性字，少有不雅用字，因此规律性还是非常强的。根 据这些信息，我们足以计算一个字符串能成为名字的概率，结合预先设置的阈值便能很好地识别出可能的人名。

可是，如何把人名从句子中切出来呢？换句话说，如果句中几个连续字都是姓名常用字，人名究竟应该从哪儿取到哪儿呢？人名以姓氏为左边界，相 对容易判定一些。人名的右边界则可以从下文的提示确定出来：人名后面通常会接“先生”、“同志”、“校长”、“主任”、“医生”等身份词，以及“是”、 “说”、“报道”、“参加”、“访问”、“表示”等动作词。

但麻烦的情况也是有的。一些高频姓氏本身也是经常单独成词的常用字，例如“于”、“马”、“黄”、“常”、“高”等等。很多反映时代性的名 字也是本身就成词的，例如“建国”、“建设”、“国庆”、“跃进”等等。更讨厌的就是那些整个名字本身就是常用词的人了，他们会彻底打乱之前的各种模型。 如果分词程序也有智能的话，他一定会把所有叫“高峰”、“汪洋”、”庞博“的人拖出去斩了。

还有那些恰好与上下文组合成词的人名，例如：

费孝通向人大常委会提交书面报告
邓颖超生前使用过的物品

这就是最考验分词算法的句子了。

相比之下，中国地名的用字就分散得多了，重庆就有一个叫做“犀牛屙屎”的地方。不过，中国地名委员会编写了《中华人民共和国地名录》，收录 了从高原盆地到桥梁电站共 10 万多个地名，这让中国地名的识别便利了很多。外文人名和地名的用字非常集中，识别的正确率要高出许多。

真正有些困难的就是识别机构名了，虽然机构名的后缀比较集中，但左边界的判断就有些难了。更难的就是品牌名了。如今各行各业大打创意战，品牌名可以说是无奇不有，而且经常本身就包含常用词，更是给自动分词添加了不少障碍。

最难识别的未登录词就是缩略语了。“教改”、“发改委”、“北医三院”都是比较好认的缩略语了，有些缩略语搞得连人也是丈二和尚摸不着头脑。你能猜到“人影办”是什么机构的简称吗？打死你都想不到，是“人工影响天气办公室”。

汉语中构造缩略语的规律很诡异，目前也没有一个定论。初次听到这个问题，几乎每个人都会做出这样的猜想：缩略语都是选用各个成分中最核心的 字，比如“安全检查”缩成“安检”，“人民警察”缩成“民警”等等。不过，反例也是有的，“邮政编码”就被缩成了“邮编”，但“码”无疑是更能概括“编 码”一词的。当然，这几个缩略语已经逐渐成词，可以加进词库了；不过新近出现的或者临时构造的缩略语该怎么办，还真是个大问题。

说到新词，网络新词的大量出现才是分词系统真正的敌人。这些新词汇的来源千奇百怪，几乎没有固定的产生机制。要想实现对网络文章的自动分词，目前来看可以说是相当困难的。革命尚未成功，分词算法还有很多进步的余地。

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

本文链接地址：http://www.52nlp.cn/matrix67-漫话中文分词算法

相关文章:

1. 中文分词入门之最大匹配法扩展2
2. 中文分词入门之资源
3. 中文分词入门之篇外
4. 中文分词入门之最大匹配法扩展1
5. 中文分词入门之最大匹配法
6. 中文分词入门之字标注法2
7. 中文分词入门之字标注法1
8. 中文分词入门之文献
9. 基于字标注的中文分词方法
10. 推荐张华平老师的中文分词工具ICTCLAS2010

邮箱：wzc@zencai.com

摘要 词典是许多中文分词系统的一个重要的组成部分。其查询速度直接影响到分词系统的处理速度。本文使用汇编语言设计了一种高效的基于哈希表和二叉树的分词词典。

关键词 中文分词 哈希表 二叉树 词典

Study on Chinese Word Segmentation Based on Hash Table and Binary Tree

Abstract The dictionary mechanism serves as one of the important components in a lot of Chinese word segmentation systems. Its perfomance influences the segmentation speed significantly. In this paper,we design a highly efficient dictionary mechanism in Assemble language, which is based on Hash table and binary tree.

Key words Chinese segmentation; Hash table; Binary tree; Dictionary

一 介绍

虽然有人提出了不需要词典的中文分词算法，如胥桂仙等人利用统计提出了基于“找最长字共现”原则的分词算法。[2] 但是，不管是基于规则方法还是统计方法，大部分中文分词算法都有自己的词典。词典的查询速度直接影响到分词系统的处理速度。本文使用汇编语言（编译器MASM32V10）设计了一种高效的基于哈希表和二叉树的分词词典。该算法为：将所有的汉字利用哈希表存储，即根据汉字机内码的编码规律，通过直接寻址哈希函数实现词语首字的快速查找，其查找时间为O(1)；然后将首字相同的词语用二叉树存储；最后将二叉树的内存地址与哈希表进行绑定。

二 首字哈希算法

一个汉语词典动不动就上十万条词语，词典的查询速度是决定分词算法效率的决定性因素之一。为了提高查询效率，本文词典对词语的首字采用哈希表来存储。

在具体阐述首字哈希算法之前，我们需要明确三个概念：国标码，区位码，机内码。

国标码是汉字信息交换的标准编码，又称汉字交换码。例如中华人民共和国国家标准局于1981年5月颁布了《信息交换用汉字编码字符集—基本集》，代号为GB2312-80，即著名的国标码GB2312-80。该编码共对6763个汉字和682个图形字符进行了编码，每个字符用两个字节表示。[5]

所有的国标码汉字及符号组成一个94行94列的二维代码表中。在此方阵中，每一行称为一个”区”，每一列称为一个”位”。这个方阵实际上组成一个有94个区（编号由01到94），每个区有94个位（编号由01到94）的汉字字符集。每两个字节分别用两位十进制编码，前字节的编码称为区码，后字节的编码称为位码，此即区位码，其中，高两位为区号，低两位为位号。这样区位码可以唯一地确定某一汉字或字符；反之，任何一个汉字或符号都对应一个唯一的区位码，没有重码。如“保”字在二维代码表中处于17区第3位，区位码即为“1703 ”。[6]

国标码并不等于区位码，它是由区位码稍作转换得到,其转换方法为：先将十进制区码和位码分别转换为十六进制的区码和位码，;这样就得了一个与国标码有一个相对位置差的代码，再将这个代码的第一个字节和第二个字节分别加上20(十六进制)，就得到国标码。如：“保”字的国标码为3123H。[6]它是经过下面的转换得到的：1703D－>1103H->+20H－>3123H。

机内码即国标码在电脑内的编码，它与国标码、区位码有一个对应关系。为了不与ASCII码发生冲突，机内码采用的是变形的国标码，其变换方法为：将国标码的每个字节都加上128，即将两个字节的最高位由0改1，其余7位不变，如：由上面我们知道，“保”字的国标码为3123（十六进制），前字节为00110001（二进制），后字节为00100011（二进制），高位改1为10110001（二进制）和10100011（二进制） 即为B1A3（十六进制），因此，“保”字的机内码就是B1A3（十六进制）。

下面我们来看一个验证上述理论的程序：

源代码a.asm：

.386

.model flat,stdcall

option casemap:none

include windows.inc

include user32.inc

includelib user32.lib

include kernel32.inc

includelib kernel32.lib

.data

szCaption db ‘消息框!’,0

;汉字“保”的机内码

szText db 0b1h,0a3h,0

.code

start:

invoke MessageBox,NULL,offset szText,offset szCaption,MB_OK

invoke ExitProcess,NULL

end start

Makefile文件：

NAME=A

OBJS=$(NAME).obj

LINK_FLAG=/subsystem:windows

ML_FLAG=/c /coff

$(NAME).exe:$(OBJS)

Link $(LINK_FLAG) $(OBJS)

.asm.obj:

ml  $(ML_FLAG) $<

clean:

del   *.obj

我们使用机内码到其区位码的映射作为哈希函数。假设汉字的机内码key的第一个字节为char1，第二个字节为char2，即

f(char1)=(char1-160)

f(char2)=(char2-160)

f(key)=f(char1)*256+f(char2)-257

源代码B.asm如下：

.386

.model    flat,stdcall

option    casemap:none

include   windows.inc

include    user32.inc

includelib              user32.lib

include   kernel32.inc

includelib             kernel32.lib

include    HashTable.inc

include    masm32.inc

includelib       masm32.lib

include           ole32.inc

includelib       ole32.lib

.data

;哈希表的初始化

HashA     HashTable       23902    dup(<0,0>)

szCaption       db    ‘消息框!’,0

szText     db               60000     dup(0)

filePath db ‘e:gb2312.txt’,0

.code

; 用机内码到其区位码的映射创建哈希表的一个结点

;ht:ptr HashTable

;key:word–机内码

CreateNode    proc              uses        esi  ebx  ht:ptr    HashTable,key:word,data:dword

local char1:byte

local char2:byte

mov              esi,ht

mov        ax,key

;char1=ah,char2=al

;f(key)=(char1-160)*256+(char2-160)-257

;计算出存储位置

mov char1,ah

mov char2,al

sub  ah,160

mov ebx,256

movzx eax,ah

mul  ebx

movzx     ebx,char2

add  eax,ebx

sub  eax,417

mov              ebx,type               HashTable

mul               ebx

add               esi,eax

;寻址

mov        ax,key

mov        (HashTable   ptr [esi]).key,ax

mov              eax,data

mov        (HashTable    ptr        [esi]).data,eax

ret

CreateNode           endp

;用机内码到其区位码的映射查找某个结点

;返回data

HashSearch           proc        uses      esi ebx  ht:ptr      HashTable,key:word

local char1:byte

local char2:byte

mov              esi,ht

mov        ax,key

;char1=ah,char2=al

;f(key)=(char1-160)*256+(char2-160)-257

;计算出存储位置

mov char1,ah

mov char2,al

sub  ah,160

mov ebx,256

movzx eax,ah

mul  ebx

movzx     ebx,char2

add  eax,ebx

sub  eax,417

mov              ebx,type               HashTable

mul               ebx

add               esi,eax

mov eax,(HashTable       ptr [esi]).data

ret

HashSearch    endp

;初始化哈希表

InitHashTable               proc        uses      esi ebx  ht:ptr      HashTable

local key:word

local i:dword

local j:dword

mov              esi,ht

mov eax,1

mov i,eax

mov j,eax

;机内码key=(区码+160）*256+（位码+160）

AreaFor:

;区码i

mov eax,i

cmp eax,95

je InitHashTableReturnLine

mov ebx,1

mov j,ebx

;位码j

PosFor:

mov eax,i

mov ebx,j

cmp ebx,95

je IAddOne

;计算出key

add eax,160

mov ebx,256

mul ebx

mov ebx,j

add eax,ebx

add eax,160

invoke CreateNode,esi,ax,0

inc j

jmp PosFor

IAddOne:

inc   i

jmp AreaFor

InitHashTableReturnLine:

ret

InitHashTable        endp

;将哈希表每个元素的key复制到字符串中

WriteHashTable            proc        uses      esi ebx  ht:ptr      HashTable

local key:word

local i:dword

local j:dword

local index:dword

mov              esi,ht

mov eax,0

mov index,0

mov eax,1

mov i,eax

mov j,eax

;机内码key=(区码+160）*256+（位码+160）

AreaFor:

;区码i

mov eax,i

cmp eax,95

je WriteHashTableReturnLine

mov ebx,1

mov j,ebx

;位码j

PosFor:

mov eax,i

mov ebx,j

cmp ebx,95

je IAddOne

;计算出key

add eax,160

mov ebx,256

mul ebx

mov ebx,j

add eax,ebx

add eax,160

mov ebx,index

mov szText[ebx],ah

inc index

mov ebx,index

mov szText[ebx],al

inc index

inc j

jmp PosFor

IAddOne:

inc   i

jmp AreaFor

WriteHashTableReturnLine:

invoke MessageBox,NULL,offset szText,offset szCaption,MB_OK

invoke write_disk_file,offset filePath,offset szText,index

ret

WriteHashTable     endp

start:

;初始化

invoke    InitHashTable, addr       HashA

invoke     WriteHashTable,addr HashA

mov ax,0b1a3h

invoke     HashSearch,addr HashA,ax

invoke     ExitProcess,NULL

end               start

哈希表结构HashTable.inc：

HashTable       struct

key  word       0

data dword     0

HashTable       ends

nmake文件：

NAME=B

OBJS=$(NAME).obj

LINK_FLAG=/subsystem:windows

ML_FLAG=/c /coff

$(NAME).exe:$(OBJS)

Link $(LINK_FLAG) $(OBJS)

.asm.obj:

ml  $(ML_FLAG) $<

clean:

del   *.obj

参考资料：

1. 孙茂松等，《汉语自动分词词典机制的实验研究》，《中文信息学报》第14卷第1期

2. 胥桂仙等，《中文文本挖掘中的无词典分词的算法及其应用》，《吉林工学院学报》，2002年3月

3. 姚兴山，《基于Hash算法的中文分词研究》，《现代图书情报技术》，2008年第3期

4. 黄新亚等，《信息编码技术及其应用大全》，电子工业出版社，1994年8月

5. 国家标准局，《信息交换用汉字编码字符集—基本集》，1981年5月

6. 百度百科机内码词条

相关文章:

1. 初学者报道（2）：实现 1-gram分词算法
2. 中文分词入门之文献
3. 中文分词入门之最大匹配法
4. 基于字标注的中文分词方法
5. 一个不错的自然语言处理词典
6. 初学者报到: 实现了一个最大匹配的分词算法
7. 中文分词入门之资源
8. 中文分词入门之字标注法1
9. 中文分词入门之最大匹配法扩展1
10. ACL09 Full Paper录用情况

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

本文链接地址：http://www.52nlp.cn/推荐张华平老师的中文分词工具-ictclas2010

相关文章:

1. 百度搜索研发部专场招聘会——3月26日（周六）
2. 中文分词入门之文献
3. 摘录：祖国应该做海外华人更好的娘家-新马之旅观感
4. LDC上免费的中文信息处理资源
5. 中文分词入门之最大匹配法扩展2
6. 中文分词入门之篇外
7. 中文分词入门之字标注法2
8. 中文分词入门之字标注法1
9. 中文分词入门之资源
10. Matrix67：漫话中文分词算法

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

　　在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

相关文章:

1. Beautiful Data-统计语言模型的应用三：分词3
2. Beautiful Data-统计语言模型的应用三：分词6
3. Beautiful Data-统计语言模型的应用三：分词4
4. Beautiful Data-统计语言模型的应用三：分词7
5. Beautiful Data-统计语言模型的应用三：分词5
6. Beautiful Data-统计语言模型的应用三：分词1
7. Beautiful Data-统计语言模型的应用三：分词2
8. Beautiful Data-统计语言模型的应用一：缘起
9. Beautiful Data-统计语言模型的应用二：背景
10. 初学者报道（2）：实现 1-gram分词算法

　　其中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函数的代码吧：

　　关于“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

相关文章:

1. Beautiful Data-统计语言模型的应用三：分词3
2. Beautiful Data-统计语言模型的应用三：分词4
3. Beautiful Data-统计语言模型的应用三：分词5
4. Beautiful Data-统计语言模型的应用三：分词6
5. Beautiful Data-统计语言模型的应用三：分词8
6. Beautiful Data-统计语言模型的应用三：分词2
7. Beautiful Data-统计语言模型的应用三：分词1
8. Beautiful Data-统计语言模型的应用二：背景
9. Beautiful Data-统计语言模型的应用一：缘起
10. 初学者报道（2）：实现 1-gram分词算法

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

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

　　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
　　<generator object datafile at 0xb76b7eb4>
　　利用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

相关文章:

1. Beautiful Data-统计语言模型的应用三：分词7
2. Beautiful Data-统计语言模型的应用三：分词5
3. Beautiful Data-统计语言模型的应用三：分词4
4. Beautiful Data-统计语言模型的应用三：分词3
5. Beautiful Data-统计语言模型的应用三：分词8
6. Beautiful Data-统计语言模型的应用三：分词2
7. Beautiful Data-统计语言模型的应用三：分词1
8. Beautiful Data-统计语言模型的应用一：缘起
9. Beautiful Data-统计语言模型的应用二：背景
10. 中文分词入门之最大匹配法

　　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

相关文章:

1. Beautiful Data-统计语言模型的应用三：分词6
2. Beautiful Data-统计语言模型的应用三：分词4
3. Beautiful Data-统计语言模型的应用三：分词7
4. Beautiful Data-统计语言模型的应用三：分词3
5. Beautiful Data-统计语言模型的应用三：分词2
6. Beautiful Data-统计语言模型的应用三：分词8
7. Beautiful Data-统计语言模型的应用三：分词1
8. Beautiful Data-统计语言模型的应用一：缘起
9. Beautiful Data-统计语言模型的应用二：背景
10. 微软：Web N-gram Services