基于一阶 HMM 标注序列算法的分词算法解析

之前看到的有关python写的一篇 基于 一阶HMM 序列标注算法的分词代码，主要是基于B M E S序列状态和维特比算法，对当前的句子进行序列标注，然后基于标注序列进行中文分词，这也是目前主流的分词算法，因此结合代码，进行HMM 分词算法的详细分析，加深序列标注算法的理解，为后面的CRF + LSTM算法进行中文分词打下基础

隐马尔科夫模型（HMM）

模型介绍

HMM模型是由一个“五元组”组成:

• StatusSet: 状态值集合
• ObservedSet: 观察值集合
• TransProbMatrix: 转移概率矩阵
• EmitProbMatrix: 发射概率矩阵
• InitStatus: 初始状态分布

将HMM应用在分词上，要解决的问题是：参数(ObservedSet, TransProbMatrix, EmitRobMatrix, InitStatus)已知的情况下，求解状态值序列。解决这个问题的最有名的方法是viterbi算法。

参数介绍

1. StatusSet，状态值集合为(B, M, E, S): {B:begin, M:middle, E:end, S:single}。分别代表每个状态代表的是该字在词语中的位置，B代表该字是词语中的起始字，M代表是词语中的中间字，E代表是词语中的结束字，S则代表是单字成词。
2. ObservedSet，观察值集合就是所有汉字，甚至包括标点符号所组成的集合。
3. TransProbMatrix，状态转移概率矩阵的含义就是从状态X转移到状态Y的概率，是一个4×4的矩阵，即{B,E,M,S}×{B,E,M,S}。
4. EmitProbMatrix，发射概率矩阵的每个元素都是一个条件概率，代表P(Observed[i]|Status[j])
5. InitStatus，初始状态概率分布表示句子的第一个字属于{B,E,M,S}这四种状态的概率。

Viterbi算法

Viterbi算法的核心思想就是动态规划实现最短路径，按照Michael Collins教的，核心思想是： 
Define a dynamic programming table π(k,u,v), 
π(k,u,v) = maximum probability of a tag sequence ending in tags u,v at position k. 
For any k ∈ {1…n}: π(k,u,v) = max ( π(k-1,w,u) × q(v|w,u) × e(xk|v) ) 
完整的Viterbi算法网上有很多资料可以查看，本文主要关注代码的实现。

---

实验

代码1：模型训练

生成三个文件： 
- prob_start.py 为初始状态概率 
- prob_trans.py 为状态转移概率 
- prob_emit.py 为发射概率

# -*- coding: utf-8 -*-# 二元隐马尔科夫模型（Bigram HMMs）# 'trainCorpus.txt_utf8'为人民日报已经人工分词的预料，29万多条句子import sys#state_M = 4#word_N = 0A_dic = {}B_dic = {}Count_dic = {}Pi_dic = {}word_set = set()state_list = ['B','M','E','S']line_num = -1INPUT_DATA = "trainCorpus.txt_utf8"PROB_START = "trainHMM\prob_start.py"   #初始状态概率PROB_EMIT = "trainHMM\prob_emit.py"     #发射概率PROB_TRANS = "trainHMM\prob_trans.py"   #转移概率def init():  #初始化字典    #global state_M    #global word_N    for state in state_list:        A_dic[state] = {}        for state1 in state_list:            A_dic[state][state1] = 0.0    for state in state_list:        Pi_dic[state] = 0.0        B_dic[state] = {}        Count_dic[state] = 0def getList(input_str):  #输入词语，输出状态    outpout_str = []    if len(input_str) == 1:        outpout_str.append('S')    elif len(input_str) == 2:        outpout_str = ['B','E']    else:        M_num = len(input_str) -2        M_list = ['M'] * M_num        outpout_str.append('B')        outpout_str.extend(M_list)  #把M_list中的'M'分别添加进去        outpout_str.append('E')    return outpout_strdef Output():   #输出模型的三个参数：初始概率+转移概率+发射概率    start_fp = file(PROB_START,'w')    emit_fp = file(PROB_EMIT,'w')    trans_fp = file(PROB_TRANS,'w')    print "len(word_set) = %s " % (len(word_set))    for key in Pi_dic:           #状态的初始概率        Pi_dic[key] = Pi_dic[key] * 1.0 / line_num    print >>start_fp,Pi_dic    for key in A_dic:            #状态转移概率        for key1 in A_dic[key]:            A_dic[key][key1] = A_dic[key][key1] / Count_dic[key]    print >>trans_fp,A_dic    for key in B_dic:            #发射概率(状态->词语的条件概率)        for word in B_dic[key]:            B_dic[key][word] = B_dic[key][word] / Count_dic[key]    print >>emit_fp,B_dic    start_fp.close()    emit_fp.close()    trans_fp.close()def main():    ifp = file(INPUT_DATA)    init()    global word_set   #初始是set()    global line_num   #初始是-1    for line in ifp:        line_num += 1        if line_num % 10000 == 0:            print line_num        line = line.strip()        if not line:continue        line = line.decode("utf-8","ignore")  #设置为ignore，会忽略非法字符        word_list = []        for i in range(len(line)):            if line[i] == " ":continue            word_list.append(line[i])        word_set = word_set | set(word_list)   #训练预料库中所有字的集合        lineArr = line.split(" ")        line_state = []        for item in lineArr:            line_state.extend(getList(item))   #一句话对应一行连续的状态        if len(word_list) != len(line_state):            print >> sys.stderr,"[line_num = %d][line = %s]" % (line_num, line.endoce("utf-8",'ignore'))        else:            for i in range(len(line_state)):                if i == 0:                    Pi_dic[line_state[0]] += 1      #Pi_dic记录句子第一个字的状态，用于计算初始状态概率                    Count_dic[line_state[0]] += 1   #记录每一个状态的出现次数                else:                    A_dic[line_state[i-1]][line_state[i]] += 1    #用于计算转移概率                    Count_dic[line_state[i]] += 1                    if not B_dic[line_state[i]].has_key(word_list[i]):                        B_dic[line_state[i]][word_list[i]] = 0.0                    else:                        B_dic[line_state[i]][word_list[i]] += 1   #用于计算发射概率    Output()    ifp.close()if __name__ == "__main__":    main()
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

代码2：测试分词效果

# -*- coding: utf-8 -*-def load_model(f_name):    ifp = file(f_name, 'rb')    return eval(ifp.read())  #eval参数是一个字符串, 可以把这个字符串当成表达式来求值,prob_start = load_model("trainHMM\prob_start.py")prob_trans = load_model("trainHMM\prob_trans.py")prob_emit = load_model("trainHMM\prob_emit.py")def viterbi(obs, states, start_p, trans_p, emit_p):  #维特比算法（一种递归算法）    V = [{}]    path = {}    for y in states:   #初始值        V[0][y] = start_p[y] * emit_p[y].get(obs[0],0)   #在位置0，以y状态为末尾的状态序列的最大概率        path[y] = [y]    for t in range(1,len(obs)):        V.append({})        newpath = {}        for y in states:      #从y0 -> y状态的递归            (prob, state) = max([(V[t-1][y0] * trans_p[y0].get(y,0) * emit_p[y].get(obs[t],0) ,y0) for y0 in states if V[t-1][y0]>0])            V[t][y] =prob            newpath[y] = path[state] + [y]        path = newpath  #记录状态序列    (prob, state) = max([(V[len(obs) - 1][y], y) for y in states])  #在最后一个位置，以y状态为末尾的状态序列的最大概率    return (prob, path[state])  #返回概率和状态序列def cut(sentence):    prob, pos_list =  viterbi(sentence,('B','M','E','S'), prob_start, prob_trans, prob_emit)    return (prob,pos_list)if __name__ == "__main__":    test_str = u"新华网驻东京记者报道"    prob,pos_list = cut(test_str)    print test_str    print pos_list
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
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

结果

新华网驻东京记者报道['B', 'M', 'E', 'S', 'B', 'E', 'B', 'E', 'B', 'E']