中文分詞的python實現-基於HMM算法

隱馬爾科夫模型（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 = 0
A_dic = {}
B_dic = {}
Count_dic = {}
Pi_dic = {}
word_set = set()
state_list = ['B','M','E','S']
line_num = -1

INPUT_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] = 0


def 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_str


def 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']

• 1
• 2

• 1
• 2

人工分詞的預料（trainCorpus.txt_utf8）可以從此處下載。