作者:zhbzz2007 出处:http://www.cnblogs.com/zhbzz2007 欢迎转载,也请保留这段声明。谢谢!

1 简介

词性(part-of-speech)是词汇基本的语法范畴,通常也称为词类,主要用来描述一个词在上下文的作用。例如,描述一个概念的词就是名词,在下文引用这个名词的词就是代词。有的词性经常会出现一些新的词,例如名词,这样的词性叫做开放式词性。另外一些词性中的词比较固定,例如代词,这样的词性叫做封闭式词性。因为存在一个词对应多个词性的现象,所以给词准确地标注词性并不是很容易。例如,“改革”在“中国开始对计划经济体制进行改革”这句话中是一个动词,但是在“医药卫生改革中的经济问题”这个句子中是一个名词。把这个问题抽象出来,就是已知单词序列,给每个单词标注词性。词性标注是自然语言处理中一项非常重要的基础性工作。

汉语词性标注同样面临许多棘手的问题,其主要的难点可以归纳为以下三个方面:

  • (1) 汉语是一种缺乏词形态变化的语言,词的类别不能像印欧语言那样,直接从词的形态变化来判别;
  • (2) 常用词兼类现象严重,越是常用的词,不同的用法越多,尽管兼类现象仅仅占汉语词汇很小的一部分,但是由于兼类使用的程度高,兼类现象纷繁,覆盖面广,涉及汉语中大部分词类,因而造成汉语文本中词类歧义排除的任务量大,而且面广,复杂多样;
  • (3) 研究者主观原因造成的困难。语言学界在词性划分的目的、标准等问题还存在分歧;

不同的语言有不同的词性标注集。为了方便指明词的词性,可以给每个词性编码,可以具体参考 ICTCLAS 汉语词性标注集 ,其中,常见的有a表示形容词,d表示副词,n表示名词,p表示介词,v表示动词。

目前采用的词性标注方法主要有基于统计模型的标注方法、基于规则的标注方法、统计方法与规则方法相结合的方法、基于有限状态转换机的标注方法和基于神经网络的词性标注方法。

jieba分词中提供了词性标注功能,可以标注标注句子分词后每个词的词性,词性标注集采用北大计算所词性标注集,属于采用基于统计模型的标注方法,下面将通过实例讲解介绍如何使用jieba分词的词性标注接口、以及通过源码讲解其实现的原理。

PS:

jieba是采用和ICTCLAS兼容的标记法,参考链接:ictclas 词性标注在哪里可以看到? #47词性 eng 是啥? 为什么官方没有词性对照表? #411;计算所词性标注集的作者是张华平老师,张华平老师也是ICTCLAS的作者,因此ICTCLAS词性标注集就是北大计算所的词性标注集,参考 计算所汉语词性标记集 。ICTCLAS现在已经更新为NLPIR,github地址为 https://github.com/NLPIR-team/NLPIR

2 实例讲解

示例代码如下所示,

# 引入词性标注接口
import jieba.posseg as psg

text = “去北京大学玩”
#词性标注
seg = psg.cut(text)

#将词性标注结果打印出来
for ele in seg:
print ele

控制台输出,

去/v
北京大学/nt
玩/v

可以观察到“去”是动词,“北京大学”是机构名称,“玩”也是动词。

3 jieba分词系统的词性标注流程

jieba分词的词性标注过程非常类似于jieba分词的分词流程,同时进行分词和词性标注。在词性标注的时候,首先基于正则表达式(汉字)进行判断,1)如果是汉字,则会基于前缀词典构建有向无环图,然后基于有向图计算最大概率路径,同时在前缀词典中查找所分出的词的词性,如果没有找到,则将其词性标注为“x”(非语素字 非语素字只是一个符号,字母x通常用于代表未知数、符号);如果HMM标志位置位,并且该词为未登录词,则通过隐马尔科夫模型对其进行词性标注;2)如果是其它,则根据正则表达式判断其类型,分别赋予“x”,“m”(数词 取英语numeral的第3个字母,n,u已有他用),“eng”(英文)。流程图如下所示,

结巴分词4--词性标注-LMLPHP

其中,基于前缀词典构造有向无环图,然后基于有向无环图计算最大概率路径,原理及源码剖析,具体可参考 结巴分词2--基于前缀词典及动态规划实现分词 这篇blog。

其中,基于隐马尔科夫模型进行词性标注,就是将词性标注视为序列标注问题,利用Viterbi算法进行求解,原理及源码剖析,具体可参考 结巴分词3--基于汉字成词能力的HMM模型识别未登录词 这篇blog。

4 源码分析

jieba分词的词性标注功能,是在jieba/posseg目录下实现的。

其中,__init__.py实现了词性标注的大部分函数;

char_state_tab.py存储了离线统计的字及其对应的状态;

prob_emit.py存储了状态到字的发射概率的对数值;

prob_start.py存储了初始状态的概率的对数值;

prob_trans.py存储了前一时刻的状态到当前时刻的状态的转移概率的对数值;

viterbi.py实现了Viterbi算法;

4.1 主调函数

jieba分词的词性标注接口的主调函数是cut函数,位于jieba/posseg/__init__.py文件中。

默认条件下,jieba.pool是None,jieba.pool is None这个条件为True,会执行下面的for循环。

def cut(sentence, HMM=True):
    """
 Global cutcut 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
<span class="hljs-keyword">for</span> blk <span class="hljs-keyword">in</span> blocks:
    <span class="hljs-comment"># 匹配汉字的正则表达式,进一步根据分割函数进行切割</span>
    <span class="hljs-keyword">if</span> re_han_internal.match(blk):
        <span class="hljs-keyword">for</span> word <span class="hljs-keyword">in</span> cut_blk(blk):
            <span class="hljs-keyword">yield</span> word
    <span class="hljs-comment"># 没有匹配上汉字的正则表达式</span>
    <span class="hljs-keyword">else</span>:
        tmp = re_skip_internal.split(blk)
        <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> tmp:
            <span class="hljs-keyword">if</span> re_skip_internal.match(x):
                <span class="hljs-keyword">yield</span> pair(x, <span class="hljs-string">'x'</span>)
            <span class="hljs-keyword">else</span>:
                <span class="hljs-keyword">for</span> xx <span class="hljs-keyword">in</span> x:
                    <span class="hljs-comment"># 匹配为数字</span>
                    <span class="hljs-keyword">if</span> re_num.match(xx):
                        <span class="hljs-keyword">yield</span> pair(xx, <span class="hljs-string">'m'</span>)
                    <span class="hljs-comment"># 匹配为英文</span>
                    <span class="hljs-keyword">elif</span> re_eng.match(x):
                        <span class="hljs-keyword">yield</span> pair(xx, <span class="hljs-string">'eng'</span>)
                    <span class="hljs-comment"># 未知类型</span>
                    <span class="hljs-keyword">else</span>:
                        <span class="hljs-keyword">yield</span> pair(xx, <span class="hljs-string">'x'</span>)</code></pre>

4.2 基于有向无环图计算最大概率路径

__cut_DAG函数会首先根据离线统计的词典(每行分别为字、频率、词性)构建前缀词典这个词典。然后基于前缀词典构建有向无环图,然后基于有向无环图计算最大概率路径,对句子进行分割。基于分割结果,如果该词在词--词性词典中,则将词典中该词的词性赋予给这个词,否则赋予“x”;如果前缀词典中不存在该词,则这个词是未登录词,则利用隐马尔科夫模型对其进行词性标注;如果上述两个条件都没有满足,则将词性标注为“x”。

def __cut_DAG(self, sentence):
    # 构建有向无环图
    DAG = self.tokenizer.get_DAG(sentence)
    route = {}
<span class="hljs-comment"># 计算最大概率路径</span>
<span class="hljs-keyword">self</span>.tokenizer.calc(sentence, DAG, route)

x = <span class="hljs-number">0</span>
buf = <span class="hljs-string">''</span>
N = len(sentence)
<span class="hljs-keyword">while</span> x &lt; <span class="hljs-symbol">N:</span>
    y = route[x][<span class="hljs-number">1</span>] + <span class="hljs-number">1</span>
    l_word = sentence[<span class="hljs-symbol">x:</span>y]
    <span class="hljs-keyword">if</span> y - x == <span class="hljs-number">1</span>:
        buf += l_word
    <span class="hljs-symbol">else:</span>
        <span class="hljs-keyword">if</span> <span class="hljs-symbol">buf:</span>
            <span class="hljs-keyword">if</span> len(buf) == <span class="hljs-number">1</span>:
                <span class="hljs-comment"># 词--词性词典中有该词,则将词性赋予给该词;否则为“x”</span>
                <span class="hljs-keyword">yield</span> pair(buf, <span class="hljs-keyword">self</span>.word_tag_tab.get(buf, <span class="hljs-string">'x'</span>))
            <span class="hljs-comment"># 前缀词典中不存在这个词,则利用隐马尔科夫模型进行词性标注</span>
            elif <span class="hljs-keyword">not</span> <span class="hljs-keyword">self</span>.tokenizer.FREQ.get(buf):
                recognized = <span class="hljs-keyword">self</span>.__cut_detail(buf)
                <span class="hljs-keyword">for</span> t <span class="hljs-keyword">in</span> <span class="hljs-symbol">recognized:</span>
                    <span class="hljs-keyword">yield</span> t
            <span class="hljs-symbol">else:</span>
                <span class="hljs-comment"># 两种条件都不满足,则将词性标注为“x”</span>
                <span class="hljs-keyword">for</span> elem <span class="hljs-keyword">in</span> <span class="hljs-symbol">buf:</span>
                    <span class="hljs-keyword">yield</span> pair(elem, <span class="hljs-keyword">self</span>.word_tag_tab.get(elem, <span class="hljs-string">'x'</span>))
            buf = <span class="hljs-string">''</span>
        <span class="hljs-comment"># 默认将词性标注为“x”</span>
        <span class="hljs-keyword">yield</span> pair(l_word, <span class="hljs-keyword">self</span>.word_tag_tab.get(l_word, <span class="hljs-string">'x'</span>))
    x = y

.......
.......</code></pre>

4.3 隐马尔科夫识别未登录词

__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
<span class="hljs-keyword">for</span> i, char <span class="hljs-keyword">in</span> enumerate(sentence):
    <span class="hljs-comment"># 根据状态进行分词</span>
    pos = pos_list[i][<span class="hljs-number">0</span>]
    <span class="hljs-keyword">if</span> pos == <span class="hljs-string">'B'</span>:
        <span class="hljs-keyword">begin</span> = i
    elif pos == <span class="hljs-string">'E'</span>:
        <span class="hljs-keyword">yield</span> pair(sentence[<span class="hljs-symbol">begin:</span>i + <span class="hljs-number">1</span>], pos_list[i][<span class="hljs-number">1</span>])
        nexti = i + <span class="hljs-number">1</span>
    elif pos == <span class="hljs-string">'S'</span>:
        <span class="hljs-keyword">yield</span> pair(char, pos_list[i][<span class="hljs-number">1</span>])
        nexti = i + <span class="hljs-number">1</span>
<span class="hljs-keyword">if</span> nexti &lt; len(sentence):
    <span class="hljs-keyword">yield</span> pair(sentence[<span class="hljs-symbol">nexti:</span>], pos_list[nexti][<span class="hljs-number">1</span>])</code></pre>

4.4 Viterbi算法

viterbi函数是在jieba/posseg/viterbi.py文件中实现。实现过程非常类似于结巴分词3--基于汉字成词能力的HMM模型识别未登录词 这篇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分词中的状态如何选取?在模型的数据是如何生成的? #7中提到,

状态多一些使得分词更准确这一点我也赞同。其实,在jieba分词的词性标注子模块posseg中,就是将BMES四种状态和20集中词性做笛卡尔集得到所有的状态,最后的效果也的确比finalseg要好,尤其是人名识别方面,但是速度就严重下降了。https://github.com/fxsjy/jieba/blob/master/jieba/posseg/prob_start.py

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 </span>= <span class="hljs-keyword">set</span>(
        (y <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> prev_states <span class="hljs-keyword">for</span> y <span class="hljs-keyword">in</span> trans_p[x].keys()))

    <span class="hljs-meta"># 根据当前的观察值获得当前时刻的可能状态集合,再与上一步骤计算的状态集合取交集</span>
    obs_states = <span class="hljs-keyword">set</span>(
        states.<span class="hljs-keyword">get</span>(obs[t], all_states)) &amp; prev_states_expect_next

    <span class="hljs-meta"># 如果当前状态的交集集合为空</span>
    <span class="hljs-keyword">if</span> not obs_states:
        <span class="hljs-meta"># 如果提前计算当前时刻的状态集合不为空,则当前时刻的状态集合为提前计算当前时刻的状态集合,否则为全部可能的状态集合</span>
        obs_states = prev_states_expect_next <span class="hljs-keyword">if</span> prev_states_expect_next <span class="hljs-keyword">else</span> all_states

    <span class="hljs-meta"># 当前时刻所处的各种可能的状态集合</span>
    <span class="hljs-keyword">for</span> y <span class="hljs-keyword">in</span> obs_states:
        <span class="hljs-meta"># 分别获取上一时刻的状态的概率对数,该状态到本时刻的状态的转移概率对数,本时刻的状态的发射概率对数</span>
        <span class="hljs-meta"># prev_states是当前时刻的状态所对应上一时刻可能的状态集合</span>
        prob, state = max((V[t - <span class="hljs-number">1</span>][y0] + trans_p[y0].<span class="hljs-keyword">get</span>(y, MIN_INF) +
                           emit_p[y].<span class="hljs-keyword">get</span>(obs[t], MIN_FLOAT), y0) <span class="hljs-keyword">for</span> y0 <span class="hljs-keyword">in</span> prev_states)
        V[t][y] = prob
        mem_path[t][y] = state

<span class="hljs-meta"># 最后一个时刻</span>
last = [(V[<span class="hljs-number">-1</span>][y], y) <span class="hljs-keyword">for</span> y <span class="hljs-keyword">in</span> mem_path[<span class="hljs-number">-1</span>].keys()]
<span class="hljs-meta"># <span class="hljs-meta-keyword">if</span> len(last)==0:</span>
<span class="hljs-meta">#     print obs</span>
prob, state = max(last)

<span class="hljs-meta"># 从时刻t = len(obs) - 1,...,0,依次将最大概率对应的状态保存在列表中</span>
route = [None] * len(obs)
i = len(obs) - <span class="hljs-number">1</span>
<span class="hljs-keyword">while</span> i &gt;= <span class="hljs-number">0</span>:
    route[i] = state
    state = mem_path[i][state]
    i -= <span class="hljs-number">1</span>
<span class="hljs-meta"># 返回最大概率及各个时刻的状态</span>
<span class="hljs-keyword">return</span> (prob, route)</code></pre>

相关优化:

  • 1 根据前一时刻的状态和状态转移矩阵,提前计算当前时刻的状态集合,再根据当前的观察值获得当前时刻的可能状态集合,再与上一步骤计算的状态集合取交集,可以减少当前时刻的所处的状态数目;

5 Reference

词性标注

ICTCLAS 汉语词性标注集

统计自然语言处理(宗成庆)--第7章 汉语自动分词与词性标注

12-16 15:37