隐马尔可夫模型（Hidden Markov Model，HMM）是统计模型，它用来描述一个含有隐含未知参数的马尔可夫过程。其难点是从可观察的参数中确定该过程的隐含参数。然后利用这些参数来作进一步的分析，例如模式识别。是在被建模的系统被认为是一个马尔可夫过程与未观测到的（隐藏的）的状态的统计马尔可夫模型。
具体原理可以参考“一文搞懂HMM（隐马尔可夫模型）“：
用python根据原理实现HMM，然后训练自己的 Python 中文分词器：
import pickle
import json
import re
# 定义 HMM 中的状态，初始化概率，以及中文停顿词
STATES = {'B', 'M', 'E', 'S'}
EPS = 0.0001
# 定义停顿标点
seg_stop_words = {" ", "，", "。", "“", "”", '“', "？", "！", "：","《",
"》","、","；", "·", "‘ ", "’", "──", ",", ".", "?",
"!", "`", "~", "@", "#", "$", "%", "^", "&", "*", "(", ")",
"-", "_", "+", "=", "[", "]", "{", "}",
'"', "'", "<", ">", "\\", "|" "\r", "\n", "\t"}
# 将 HMM 模型封装为独立的类 HMM_Model
class HMM_Model:
def __init__(self):
'''
类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
数据结构：
trans_mat：状态转移矩阵，trans_mat[state1][state2] 表示训练集中由 state1 转移到 state2 的次数。
emit_mat：观测矩阵，emit_mat[state][char] 表示训练集中单字 char 被标注为 state 的次数。
init_vec：初始状态分布向量，init_vec[state] 表示状态 state 在训练集中出现的次数。
state_count：状态统计向量，state_count[state] 表示状态 state 出现的次数。
word_set：词集合，包含所有单词。
'''
self.trans_mat = {}
self.emit_mat = {}
self.init_vec = {}
self.state_count = {}
self.states = {}
self.inited = False
# 初始化数据结构
def setup(self):
'''
初始化第一个方法中的数据结构
'''
for state in self.states:
# build trans_mat
self.trans_mat[state] = {}
for target in self.states:
self.trans_mat[state][target] = 0.0
self.emit_mat[state] = {}
self.init_vec[state] = 0
self.state_count[state] = 0
self.inited = True
# 模型保存
def save(self, filename="hmm.json", code='json'):
'''
保存训练好的模型，filename 指定模型名称，默认模型名称为 hmm.json，
这里提供两种格式的保存类型，JSON 或者 pickle 格式，
通过参数 code 来决定，code 的值为 code='json' 或者 code = 'pickle'，
默认为 code='json'
'''
data = {
"trans_mat": self.trans_mat,
"emit_mat": self.emit_mat,
"init_vec": self.init_vec,
"state_count": self.state_count
}
if code == "json":
fw = open(filename, 'w+', encoding='utf-8')
txt = json.dumps(data)
txt = txt.encode('utf-8').decode('unicode-escape')
fw.write(txt)
elif code == "pickle":
fw = open(filename, 'wb')
pickle.dump(data, fw)
fw.close()
# 模型加载
def load(self, filename="hmm.json", code="json"):
'''
加载模型，filename 指定模型名称，默认模型名称为 hmm.json，
这里提供两种格式的保存类型，JSON 或者 pickle 格式，
通过参数 code 来决定，code 的值为 code='json' 或者 code = 'pickle'，默认为 code='json'
'''
if code == "json":
fr = open(filename, 'r+', encoding='utf-8')
txt = fr.read()
model = json.loads(txt)
elif code == "pickle":
fr = open(filename, 'rb')
model = pickle.load(fr)
self.trans_mat = model["trans_mat"]
self.emit_mat = model["emit_mat"]
self.init_vec = model["init_vec"]
self.state_count = model["state_count"]
self.inited = True
fr.close()
# 模型训练
def do_train(self, observes, states):
'''
训练模型，因为使用的标注数据集， 因此可以使用更简单的监督学习算法，
训练函数输入观测序列和状态序列进行训练， 依次更新各矩阵数据。
类中维护的模型参数均为频数而非频率， 这样的设计使得模型可以进行在线训练，
使得模型随时都可以接受新的训练数据继续训练，不会丢失前次训练的结果。
'''
if not self.inited:
self.setup()
for i in range(len(states)):
if i == 0:
self.init_vec[states[0]] += 1
self.state_count[states[0]] += 1
if observes[i] not in self.emit_mat[states[i]]:
self.emit_mat[states[i]][observes[i]] = 1
else:
self.emit_mat[states[i]][observes[i]] += 1
else:
self.trans_mat[states[i - 1]][states[i]] += 1
self.state_count[states[i]] += 1
if observes[i] not in self.emit_mat[states[i]]:
self.emit_mat[states[i]][observes[i]] = 1
else:
self.emit_mat[states[i]][observes[i]] += 1
# HMM计算
# 频数转频率
def get_prob(self):
'''
在进行预测前，需将数据结构的频数转换为频率
'''
init_vec = {}
trans_mat = {}
emit_mat = {}
default = max(self.state_count.values())
for key in self.init_vec:
if self.state_count[key] != 0:
init_vec[key] = float(self.init_vec[key]) / self.state_count[key]
else:
init_vec[key] = float(self.init_vec[key]) / default
for key1 in self.trans_mat:
trans_mat[key1] = {}
for key2 in self.trans_mat[key1]:
if self.state_count[key1] != 0:
trans_mat[key1][key2] = float(self.trans_mat[key1][key2]) / self.state_count[key1]
else:
trans_mat[key1][key2] = float(self.trans_mat[key1][key2]) / default
for key1 in self.emit_mat:
emit_mat[key1] = {}
for key2 in self.emit_mat[key1]:
if self.state_count[key1] != 0:
emit_mat[key1][key2] = float(self.emit_mat[key1][key2]) / self.state_count[key1]
else:
emit_mat[key1][key2] = float(self.emit_mat[key1][key2]) / default
return init_vec, trans_mat, emit_mat
# 模型预测
def do_predict(self, sequence):
'''
预测采用 Viterbi 算法求得最优路径
'''
tab = [{}]
path = {}
init_vec, trans_mat, emit_mat = self.get_prob()
# 初始化
for state in self.states:
tab[0][state] = init_vec[state] * emit_mat[state].get(sequence[0], EPS) # dict.get(key, default=None)
path[state] = [state]
# 创建动态搜索表
for t in range(1, len(sequence)):
tab.append({})
new_path = {}
for state1 in self.states:
items = []
for state2 in self.states:
if tab[t - 1][state2] == 0:
continue
prob = tab[t - 1][state2] * trans_mat[state2].get(state1, EPS) * emit_mat[state1].get(sequence[t],
EPS)
items.append((prob, state2))
best = max(items)
tab[t][state1] = best[0]
new_path[state1] = path[best[1]] + [state1]
path = new_path
# 搜索最有路径
prob, state = max([(tab[len(sequence) - 1][state], state) for state in self.states])
return path[state]
# 实现分词器
# 定义两个工具函数
def get_tags(src):
'''
对输入的训练语料中的每个词进行标注，因为训练数据是空格隔开的，可以进行转态标注
'''
tags = []
if len(src) == 1:
tags = ['S']
elif len(src) == 2:
tags = ['B', 'E']
else:
m_num = len(src) - 2
tags.append('B')
tags.extend(['M'] * m_num)
tags.append('E')
return tags
def cut_sent(src, tags):
'''
根据预测得到的标注序列将输入的句子分割为词语列表，
也就是预测得到的状态序列，解析成一个 list 列表进行返回
'''
word_list = []
start = -1
started = False
if len(tags) != len(src):
return None
if tags[-1] not in {'S', 'E'}:
if tags[-2] in {'S', 'E'}:
tags[-1] = 'S'
else:
tags[-1] = 'E'
for i in range(len(tags)):
if tags[i] == 'S':
if started:
started = False
word_list.append(src[start:i])
word_list.append(src[i])
elif tags[i] == 'B':
if started:
word_list.append(src[start:i])
start = i
started = True
elif tags[i] == 'E':
started = False
word = src[start:i + 1]
word_list.append(word)
elif tags[i] == 'M':
continue
return word_list
# 定义分词器类 HMMSoyoger，继承 HMM_Model 类并实现中文分词器训练、分词功能
class HMMSoyoger(HMM_Model):
def __init__(self, *args, **kwargs):
'''
构造函数，定义初始化变量
'''
super(HMMSoyoger, self).__init__(*args, **kwargs)
self.states = STATES
self.data = None
#加载训练数据
#加载语料
def read_txt(self, filename):
'''
加载训练语料，读入文件为 txt，并且 UTF-8 编码，防止中文出现乱码
'''
self.data = open(filename, 'r', encoding="utf-8")
#模型训练函数
def train(self):
'''
根据单词生成观测序列和状态序列，并通过父类的 do_train() 方法进行训练
'''
if not self.inited:
self.setup()
for line in self.data:
line = line.strip()
if not line:
continue
# 观测序列
observes = []
for i in range(len(line)):
if line[i] == " ":
continue
observes.append(line[i])
# print('observes:', len(observes), observes)
# 状态序列
words = re.split(r"[ ]+", line)
# print("words:", words)
states = []
for word in words:
states.extend(get_tags(word))
# print("states:", len(states), states)
# 开始训练
if (len(observes) == len(states)):
self.do_train(observes, states)
else:
pass
#模型分词预测
def lcut(self, sentence):
'''
模型训练好之后，通过该方法进行分词测试
'''
try:
tags = self.do_predict(sentence)
return cut_sent(sentence, tags)
except:
return sentence
# 通过上面两个类和两个方法，就完成了基于 HMM 的中文分词器编码，下面我们来进行模型训练和测试。
# 训练模型
# 实例化 HMMSoyoger 类，然后通过 read_txt() 方法加载语料，再通过 train() 进行在线训练
soyoger = HMMSoyoger()
soyoger.read_txt("./syj_trainCorpus_utf8数据/syj_trainCorpus_utf8/syj_trainCorpus_utf8_2.txt")
soyoger.train()
# 模型测试
print(soyoger.lcut("中国的人工智能发展，进入高潮阶段。"))
soyoger.save(filename="HMM.pickle", code='pickle')
soyoger.load(filename="HMM.pickle", code='pickle')
# soyoger.save(filename="HMM.json", code='json')
# soyoger.load(filename="HMM.json", code='json')
print(soyoger.lcut("中文自然语言处理，是人工智能技术的一个重要分支。"))
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
