jieba分词原理 ‖ 词性标注

小鱼儿 2024-04-18 18:40 17阅读 0赞

1.  [jieba分词原理 ‖ 基于前缀词典及动态规划的分词实现][jieba_ _]
2.  [jieba分词原理 ‖ 基于汉字成词能力的HMM模型识别未登录词实现][jieba_ _ _HMM]
3.  [jieba分词原理 ‖ 词性标注][jieba_ _ 1]
4.  [jieba分词原理 ‖ 关键词抽取][jieba_ _ 2]

--------------------

# 1 简介 #

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

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

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

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

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

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

# 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”（英文）。流程图如下所示，

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2ODExMzc3_size_16_color_FFFFFF_t_70][]

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

其中，基于隐马尔科夫模型进行词性标注，就是将词性标注视为序列标注问题，利用Viterbi算法进行求解，原理及源码剖析，具体可参考 [结巴分词3--基于汉字成词能力的HMM模型识别未登录词][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 `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')

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

\_\_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
    
        .......
        .......

## 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
    
        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])

## 4.4 Viterbi算法 ##

viterbi函数是在jieba/posseg/viterbi.py文件中实现。实现过程非常类似于[结巴分词3--基于汉字成词能力的HMM模型识别未登录词][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][_7]中提到，
> 
> 状态多一些使得分词更准确这一点我也赞同。其实，在jieba分词的词性标注子模块posseg中，就是将BMES四种状态和20集中词性做笛卡尔集得到所有的状态，最后的效果也的确比finalseg要好，尤其是人名识别方面，但是速度就严重下降了。

[https://github.com/fxsjy/jieba/blob/master/jieba/posseg/prob\_start.py][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 = 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)

**相关优化：**

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

[jieba_ _]: https://blog.csdn.net/sinat_26811377/article/details/100692140
[jieba_ _ _HMM]: https://blog.csdn.net/sinat_26811377/article/details/100693627
[jieba_ _ 1]: https://blog.csdn.net/sinat_26811377/article/details/100703439
[jieba_ _ 2]: https://blog.csdn.net/sinat_26811377/article/details/100750251
[ICTCLAS]: http://fhqllt.iteye.com/blog/947917
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2ODExMzc3_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/65dccb2b4b1e4128a9fc0bee054d231d.png
[2--]: http://www.cnblogs.com/zhbzz2007/p/6084196.html
[3--_HMM]: http://www.cnblogs.com/zhbzz2007/p/6092313.html
[_7]: https://github.com/fxsjy/jieba/issues/7
[https_github.com_fxsjy_jieba_blob_master_jieba_posseg_prob_start.py]: https://github.com/fxsjy/jieba/blob/master/jieba/posseg/prob_start.py