用HMM实现中文分词

1.jieba分词

    jieba分词的三种分词模式：

• 精确模式，试图将句子最精确地切开，适合文本分析；
• 全模式，把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义；
• 搜索引擎模式，在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。

    jieba分词的三种算法：

• 基于Trie树结构实现高效的词图扫描，生成句子中汉字所有可能成词情况所构成的有向无环图（DAG)，根据给定的词典进行查词典操作, 生成几种可能的句子切分。jieba的作者在DAG中记录的是句子中某个词的开始位置，从0到n-1(n为句子的长度), 每个开始位置作为字典的键, value是个list, 其中保存了可能的词语的结束位置，(通过查字典得到词, 开始位置+词语的长度得到结束位置)，注：所以可以联想到，jieba支持全模式分词，能把句子中所有的可以成词的词语都扫描出来
• 采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合，查找待分词句子中已经切分好的词语, 对该词语查找该词语出现的频率(次数/总数), 根据动态规划查找最大概率路径的方法, 对句子从右往左反向计算最大概率
• 对于未登录词，采用了基于汉字成词能力的HMM模型，使用了Viterbi算法

• 基于Viterbi算法做词性标注；

• 基于tf-idf和textrank模型抽取关键词；

2.HMM实现

第一部分是训练，有详细注释,所需要的训练语料：人民日报中文语料库

#encoding:utf-8
import sys
import math

A_dic = {}#状态转移概率矩阵
B_dic = {}#观测概率矩阵
Count_dic = {}#用于记录所有B、M、E、S的数量
Pi_dic = {}#初始概率矩阵，即记录了每个字是BMSE的概率
word_set = set()#所有词语的集合
state_list = ['B','M','E','S']
line_num = -1
INPUT_DATA = "trainCorpus.txt_utf8"
INPUT_DATA = "trainCorpus.txt_utf8"
PROB_START = "prob_start.py"   #初始状态概率
PROB_EMIT = "prob_emit.py"     #发射概率
PROB_TRANS = "prob_trans.py"   #转移概率

#初始化字典，初始化的矩阵A全部为0
def init():
    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=open(PROB_START,'w')
    emit_fp=open(PROB_EMIT,'w')
    trans_fp=open(PROB_TRANS,'w')
    for key in Pi_dic:           #状态的初始概率
        Pi_dic[key]=float(Pi_dic[key])/ line_num
    print (Pi_dic,file=start_fp)
    for key in A_dic:            #状态转移概率
        for key1 in A_dic[key]:
            A_dic[key][key1]=A_dic[key][key1]/Count_dic[key]
    print (A_dic,file=trans_fp)
    for key in B_dic:            #观测概率，
        for word in B_dic[key]:
            B_dic[key][word] =B_dic[key][word]/Count_dic[key]
    print (B_dic,file=emit_fp)
    start_fp.close()
    emit_fp.close()
    trans_fp.close()

def main():
    ifp=open(INPUT_DATA,'rb')
    init()
    global word_set 
    global line_num
    for line in ifp.readlines():
        line_num+=1
        line=line.strip()
        if not line:continue
        line = line.decode("utf-8","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=[]#用于存放每个字符的BMSE属性
        for item in lineArr:
            line_state.extend(getList(item))
        for i in range(len(line_state)):#遍历这个字符串的所有BMSE
            if i==0:
                Pi_dic[line_state[0]]+=1
                Count_dic[line_state[0]]+= 1   #记录每一个状态的出现次数
            else:
                A_dic[line_state[i-1]][line_state[i]] += 1    #用于计算转移概率
                Count_dic[line_state[i]] += 1
                if word_list[i] not in B_dic[line_state[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()

上一部分代码是用训练数据集求得了HMM的三要素，即初始概率矩阵（语料中第一个字是BMSE的概率），转移矩阵（B到E之类这种的转移概率），以及发射矩阵每个字是BMSE的概率，接下来就用这三个矩阵来进行分词测试。

# -*- coding: utf-8 -*-
def load_model(f_name):
    ifp=open(f_name,'rb').read()
    ifp=ifp.decode('GB2312',"ignore")
    return eval(ifp)

import chardet
file=open("prob_emit.py",'rb').read()
f_charInfo=chardet.detect(file)
print(f_charInfo)
prob_start = load_model("prob_start.py")
prob_trans = load_model("prob_trans.py")
prob_emit = load_model("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)  
        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)