词性(part-of-speech)是词汇基本的语法范畴,通常也称为词类,主要用来描述一个词在上下文的作用。例如,描述一个概念的词就是名词,在下文引用这个名词的词就是代词。有的词性经常会出现一些新的词,例如名词,这样的词性叫做开放式词性。另外一些词性中的词比较固定,例如代词,这样的词性叫做封闭式词性。因为存在一个词对应多个词性的现象,所以给词准确地标注词性并不是很容易。例如,"改革" 在 "中国开始对计划经济体制进行改革" 这句话中是一个动词,但是在 "医药卫生改革中的经济问题" 这个句子中是一个名词。把这个问题抽象出来,就是已知单词序列,给每个单词标注词性。词性标注是自然语言处理中一项非常重要的基础性工作。
汉语词性标注同样面临许多棘手的问题,其主要的难点可以归纳为以下三个方面:
不同的语言有不同的词性标注集。为了方便指明词的词性,可以给每个词性编码,可以具体参考 ,其中,常见的有 a 表示形容词,d 表示副词,n 表示名词,p 表示介词,v 表示动词。
目前采用的词性标注方法主要有基于统计模型的标注方法、基于规则的标注方法、统计方法与规则方法相结合的方法、基于有限状态转换机的标注方法和基于神经网络的词性标注方法。
jieba 分词中提供了词性标注功能,可以标注标注句子分词后每个词的词性,词性标注集采用和 ictclas 兼容的标记法,属于采用基于统计模型的标注方法,下面将通过实例讲解介绍如何使用 jieba 分词的词性标注接口、以及通过源码讲解其实现的原理。
示例代码如下所示,
- # 引入词性标注接口
- import jieba.posseg as psg
- text = "去北京大学玩"
- #词性标注
- seg = psg.cut(text)
- #将词性标注结果打印出来
- for ele in seg:
- print ele
控制台输出,
- 去/v
- 北京大学/nt
- 玩/v
可以观察到 "去" 是动词,"北京大学" 是机构名称,"玩" 也是动词。
jieba 分词的词性标注过程非常类似于 jieba 分词的分词流程,同时进行分词和词性标注。在词性标注的时候,首先基于正则表达式(汉字)进行判断,1)如果是汉字,则会基于前缀词典构建有向无环图,然后基于有向图计算最大概率路径,同时在前缀词典中查找所分出的词的词性,如果没有找到,则将其词性标注为 "x"(非语素字 非语素字只是一个符号,字母 x 通常用于代表未知数、符号);如果 HMM 标志位置位,并且该词为未登录词,则通过隐马尔科夫模型对其进行词性标注;2)如果是其它,则根据正则表达式判断其类型,分别赋予 "x","m"(数词 取英语 numeral 的第 3 个字母,n,u 已有他用),"eng"(英文)。流程图如下所示,
其中,基于前缀词典构造有向无环图,然后基于有向无环图计算最大概率路径,原理及源码剖析,具体可参考 这篇 blog。
其中,基于隐马尔科夫模型进行词性标注,就是将词性标注视为序列标注问题,利用 Viterbi 算法进行求解,原理及源码剖析,具体可参考 这篇 blog。
jieba 分词的词性标注功能,是在 jieba/posseg 目录下实现的。
其中,__init__.py 实现了词性标注的大部分函数;
char_state_tab.py 存储了离线统计的字及其对应的状态;
prob_emit.py 存储了状态到字的发射概率的对数值;
prob_start.py 存储了初始状态的概率的对数值;
prob_trans.py 存储了前一时刻的状态到当前时刻的状态的转移概率的对数值;
viterbi.py 实现了 Viterbi 算法;
jieba 分词的词性标注接口的主调函数是 cut 函数,位于 jieba/posseg/__init__.py 文件中。
默认条件下,jieba.pool 是 None,jieba.pool is None 这个条件为 True,会执行下面的 for 循环。
- def cut(sentence, HMM=True):
- """
- Global `cut` function that supports parallel processing.
- Note that this only works using dt, custom POSTokenizer
- instances are not supported.
- """
- global dt
- # 默认条件下,此条件为True
- if jieba.pool is None:
- # 执行for循环
- for w in dt.cut(sentence, HMM=HMM):
- yield w
- else:
- parts = strdecode(sentence).splitlines(True)
- if HMM:
- result = jieba.pool.map(_lcut_internal, parts)
- else:
- result = jieba.pool.map(_lcut_internal_no_hmm, parts)
- for r in result:
- for w in r:
- yield w
for 循环中的 dt = POSTokenizer(jieba.dt),POSTokenizer 就是 jieba 分词中的词性标注定义的类,其中 jieba.dt 是 jieba 自己实现的分词接口。POSTokenizer 类在初始化的时候,会读取离线统计的词典(每行分别为字、频率、词性),加载为词 -- 词性词典。
最终,程序会执行 dt.cut 函数。
cut 函数是默认条件下 jieba 分词的词性标注过程的执行函数,位于 jieba/posseg/__init__.py 文件定义的 POSTokenizer 中。cut 函数会执行__cut_internal 这个函数。
__cut_internal 函数会首先根据标志位,选择不同的分割函数,然后会首先基于正则表达式对输入句子进行分割,如果是汉字,则根据分割函数进行分割;否则,进一步根据正则表达式判断其类型。
默认情况下,HMM 标志位为 True,因此 cut_blk = self.__cut_DAG,也就会使用 HMM 模型来对未登录词进行词性标注。
- def __cut_internal(self, sentence, HMM=True):
- self.makesure_userdict_loaded()
- sentence = strdecode(sentence)
- blocks = re_han_internal.split(sentence)
- # 根据标志位判断,选择不同的分割函数
- if HMM:
- # 使用HMM模型
- cut_blk = self.__cut_DAG
- else:
- # 不使用HMM模型
- cut_blk = self.__cut_DAG_NO_HMM
- for blk in blocks:
- # 匹配汉字的正则表达式,进一步根据分割函数进行切割
- if re_han_internal.match(blk):
- for word in cut_blk(blk):
- yield word
- # 没有匹配上汉字的正则表达式
- else:
- tmp = re_skip_internal.split(blk)
- for x in tmp:
- if re_skip_internal.match(x):
- yield pair(x, 'x')
- else:
- for xx in x:
- # 匹配为数字
- if re_num.match(xx):
- yield pair(xx, 'm')
- # 匹配为英文
- elif re_eng.match(x):
- yield pair(xx, 'eng')
- # 未知类型
- else:
- yield pair(xx, 'x')
__cut_DAG 函数会首先根据离线统计的词典(每行分别为字、频率、词性)构建前缀词典这个词典。然后基于前缀词典构建有向无环图,然后基于有向无环图计算最大概率路径,对句子进行分割。基于分割结果,如果该词在词 -- 词性词典中,则将词典中该词的词性赋予给这个词,否则赋予 "x";如果前缀词典中不存在该词,则这个词是未登录词,则利用隐马尔科夫模型对其进行词性标注;如果上述两个条件都没有满足,则将词性标注为 "x"。
- def __cut_DAG(self, sentence):
- # 构建有向无环图
- DAG = self.tokenizer.get_DAG(sentence)
- route = {}
- # 计算最大概率路径
- self.tokenizer.calc(sentence, DAG, route)
- x = 0
- buf = ''
- N = len(sentence)
- while x < N:
- y = route[x][1] + 1
- l_word = sentence[x:y]
- if y - x == 1:
- buf += l_word
- else:
- if buf:
- if len(buf) == 1:
- # 词--词性词典中有该词,则将词性赋予给该词;否则为"x"
- yield pair(buf, self.word_tag_tab.get(buf, 'x'))
- # 前缀词典中不存在这个词,则利用隐马尔科夫模型进行词性标注
- elif not self.tokenizer.FREQ.get(buf):
- recognized = self.__cut_detail(buf)
- for t in recognized:
- yield t
- else:
- # 两种条件都不满足,则将词性标注为"x"
- for elem in buf:
- yield pair(elem, self.word_tag_tab.get(elem, 'x'))
- buf = ''
- # 默认将词性标注为"x"
- yield pair(l_word, self.word_tag_tab.get(l_word, 'x'))
- x = y
- .......
- .......
__cut_detail 函数是利用隐马尔科夫模型进行词性标注的主函数。
__cut_detail 函数首先利用正则表达式对未登录词组成的句子进行分割,然后根据正则表达式进行判断,如果匹配上,则利用隐马尔科夫模型对其进行词性标注;否则,进一步根据正则表达式,判断其类型。
其中,__cut 是隐马尔科夫模型进行词性标注的执行函数。
- def __cut_detail(self, sentence):
- # 根据正则表达式对未登录词组成的句子进行分割
- blocks = re_han_detail.split(sentence)
- for blk in blocks:
- # 匹配上正则表达式
- if re_han_detail.match(blk):
- # 利用隐马尔科夫模型对其进行词性标注
- for word in self.__cut(blk):
- yield word
- # 没有匹配上正则表达式
- else:
- tmp = re_skip_detail.split(blk)
- for x in tmp:
- if x:
- # 匹配为数字
- if re_num.match(x):
- yield pair(x, 'm')
- # 匹配为英文
- elif re_eng.match(x):
- yield pair(x, 'eng')
- # 匹配为未知类型
- else:
- yield pair(x, 'x')
__cut 函数会首先执行 Viterbi 算法,由 Viterbi 算法得到状态序列(包含分词及词性标注),也就可以根据状态序列得到分词结果。其中状态以 B 开头,离它最近的以 E 结尾的一个子状态序列或者单独为 S 的子状态序列,就是一个分词。以 "去北京大玩学城" 为例,其中,"去" 和 "北京" 在前缀词典中有,因此直接通过词 -- 词性词典对其匹配即可,它俩的词性分别为 "去 / v","北京 / ns";而对于 "大玩学城" 这个句子,是未登录词,因此对其利用隐马尔科夫模型对其进行词性标志,它的隐藏状态序列就是 [(u'S', u'a'), (u'B', u'n'), (u'E', u'n'), (u'B', u'n')] 这个列表,列表中的每个元素为一个元组,则分词为 "S / BE / B",对应观测序列,也就是 "大 / 玩学 / 城"。
- def __cut(self, sentence):
- # 执行Viterbi算法
- prob, pos_list = viterbi(
- sentence, char_state_tab_P, start_P, trans_P, emit_P)
- begin, nexti = 0, 0
- for i, char in enumerate(sentence):
- # 根据状态进行分词
- pos = pos_list[i][0]
- if pos == 'B':
- begin = i
- elif pos == 'E':
- yield pair(sentence[begin:i + 1], pos_list[i][1])
- nexti = i + 1
- elif pos == 'S':
- yield pair(char, pos_list[i][1])
- nexti = i + 1
- if nexti < len(sentence):
- yield pair(sentence[nexti:], pos_list[nexti][1])
viterbi 函数是在 jieba/posseg/viterbi.py 文件中实现。实现过程非常类似于 这篇 blog 3.3 章节中讲解的。
其中,obs 是观测序列,也即待标注的句子;
states 是每个词可能的状态,在 jieba/posseg/char_state_tab.py 文件中定义,格式如下,表示字 "一"(\u4e00)可能的状态包括 1)"B" 表明位于词的开始位置,"m" 表示词性为为数词;2)"S" 表明单字成词,"m" 表示词性为为数词等等状态。
P={'\u4e00': (('B', 'm'),
('S', 'm'),
('B', 'd'),
('B', 'a'),
('M', 'm'),
('B', 'n'),
...
}
start_p,是初始状态,在 jieba/posseg/prob_start.py 文件中定义,格式如下,表示 1)"B" 表明位于词的开始位置,"a" 表示为形容词,其对数概率为 - 4.762305214596967;2)=)"B" 表明位于词的开始位置,"b" 表示为区别词(取汉字 "别" 的声母),其初始概率的对数值为 - 5.018374362109218 等等状态。
P={('B', 'a'): -4.762305214596967,
('B', 'ad'): -6.680066036784177,
('B', 'ag'): -3.14e+100,
('B', 'an'): -8.697083223018778,
('B', 'b'): -5.018374362109218,
...
}
trans_p,是状态转移概率,在 jieba/posseg/prob_trans.py 文件中定义中定义,格式如下,表示 1)前一时刻的状态为("B" 和 "a"),也即前一个字为词的开始位置,词性为形容词,当前时刻的状态为("E" 和 "a"),也即当前字位于词的末尾位置,词性为形容词,它的状态转移概率的对数值为 - 0.0050648453069648755 等等状态。
P={('B', 'a'): {('E', 'a'): -0.0050648453069648755,
('M', 'a'): -5.287963037107507},
('B', 'ad'): {('E', 'ad'): -0.0007479013978476627,
('M', 'ad'): -7.198613337130562},
('B', 'ag'): {},
('B', 'an'): {('E', 'an'): 0.0},
...
}
emit_p,是状态发射概率,在 jieba/posseg/prob_emit.py 文件中定义中定义,格式如下,表示 1)当前状态为("B" 和 "a"),也即当前字位于词的开始位置,词性为形容词,到汉字 "一" 的发射概率的对数值为 - 3.618715666782108;2)到汉字 "万"(\u4e07)的发射概率的对数值为 - 10.500566885381515。
P={('B', 'a'): {'\u4e00': -3.618715666782108,
'\u4e07': -10.500566885381515,
'\u4e0a': -8.541143017159477,
'\u4e0b': -8.445222895280738,
'\u4e0d': -2.7990867583580403,
'\u4e11': -7.837979058356061,
...
}
viterbi 函数会先计算各个初始状态的对数概率值,然后递推计算,依次 1)获取前一时刻所有的状态集合;2)根据前一时刻的状态和状态转移矩阵,提前计算当前时刻的状态集合,再根据当前的观察值获得当前时刻的可能状态集合,再与上一步骤计算的状态集合取交集;3)根据每时刻当前所处的状态,其对数概率值取决于上一时刻的对数概率值、上一时刻的状态到这一时刻的状态的转移概率、这一时刻状态转移到当前的字的发射概率三部分组成。最后再根据最大概率路径依次回溯,得到最优的路径,也即为要求的各个时刻的状态。
jieba 分词中的状态如何选取?在中提到,
状态多一些使得分词更准确这一点我也赞同。其实,在 jieba 分词的词性标注子模块 posseg 中,就是将 BMES 四种状态和 20 集中词性做笛卡尔集得到所有的状态,最后的效果也的确比 finalseg 要好,尤其是人名识别方面,但是速度就严重下降了。
- def viterbi(obs, states, start_p, trans_p, emit_p):
- V = [{}] # tabular
- mem_path = [{}]
- # 根据状态转移矩阵,获取所有可能的状态
- all_states = trans_p.keys()
- # 时刻t=0,初始状态
- for y in states.get(obs[0], all_states): # init
- V[0][y] = start_p[y] + emit_p[y].get(obs[0], MIN_FLOAT)
- mem_path[0][y] = ''
- # 时刻t=1,...,len(obs) - 1
- for t in xrange(1, len(obs)):
- V.append({})
- mem_path.append({})
- #prev_states = get_top_states(V[t-1])
- # 获取前一时刻所有的状态集合
- prev_states = [
- x for x in mem_path[t - 1].keys() if len(trans_p[x]) > 0]
- # 根据前一时刻的状态和状态转移矩阵,提前计算当前时刻的状态集合
- prev_states_expect_next = set(
- (y for x in prev_states for y in trans_p[x].keys()))
- # 根据当前的观察值获得当前时刻的可能状态集合,再与上一步骤计算的状态集合取交集
- obs_states = set(
- states.get(obs[t], all_states)) & prev_states_expect_next
- # 如果当前状态的交集集合为空
- if not obs_states:
- # 如果提前计算当前时刻的状态集合不为空,则当前时刻的状态集合为提前计算当前时刻的状态集合,否则为全部可能的状态集合
- obs_states = prev_states_expect_next if prev_states_expect_next else all_states
- # 当前时刻所处的各种可能的状态集合
- for y in obs_states:
- # 分别获取上一时刻的状态的概率对数,该状态到本时刻的状态的转移概率对数,本时刻的状态的发射概率对数
- # prev_states是当前时刻的状态所对应上一时刻可能的状态集合
- prob, state = max((V[t - 1][y0] + trans_p[y0].get(y, MIN_INF) +
- emit_p[y].get(obs[t], MIN_FLOAT), y0) for y0 in prev_states)
- V[t][y] = prob
- mem_path[t][y] = state
- # 最后一个时刻
- last = [(V[-1][y], y) for y in mem_path[-1].keys()]
- # if len(last)==0:
- # print obs
- prob, state = max(last)
- # 从时刻t = len(obs) - 1,...,0,依次将最大概率对应的状态保存在列表中
- route = [None] * len(obs)
- i = len(obs) - 1
- while i >= 0:
- route[i] = state
- state = mem_path[i][state]
- i -= 1
- # 返回最大概率及各个时刻的状态
- return (prob, route)
相关优化:
来源: http://www.cnblogs.com/zhbzz2007/p/6165442.html