Python 自然语言处理（1）中文分词技术

中文分词技术

中文自动分词可主要归纳为“规则分词”“统计分词”和“混合分词”，规则分词主要是通过人工设立词库，按照一定方式进行匹配切分，实现简单高效，但对新词很难进行处理，统计分词能够较好应对新词发现能特殊场景，但太过于依赖语料的质量，因此实践中多是采用两者的结合，即混合分词。

1.1 规则分词

基于规则的分词是一种机械分词方法，主要是通过维护词典，在切分语句时，将语句的每个字符串与词表中的词进行逐一匹配，找到则切分，否则不予切分。

按照匹配切分的方式，主要有正向最大匹配法、逆向最大匹配法以及双向最大匹配法三种方法。

1.1.1 正向最大匹配法

正向最大匹配（Maximum Match Method, MM）法的基本思想为：假定分词词典中的最长词有 i 个汉字字符，则用被处理文档的当前字串中的前 i 个字作为匹配字段，查找字典。若字典中存在这样的一个 i 字词，则匹配成功，匹配字段被作为一个词切分出来。如果字典中找不到这样的一个 i 字词，则匹配失败，将匹配字段中的最后一个字去掉。对剩下的字串重新进行匹配处理。如此进行下去，直到匹配成功，即切分出一个词或剩余字串的长度为零为止，这样就完成了一轮匹配，然后取下一个 i 字字串进行匹配处理，直到文档被扫描完为止。示例代码如下：

class MM(object):
    def __init__(self, dic_path):
        self.dictionary = set()
        self.maximum = 0
        with open(dic_path, 'r', encoding="utf8") as f:
            for line in f:
                line = line.strip()
                if not line:
                    continue
                self.dictionary.add(line)
                self.maximum = max(self.maximum, len(line))
 
    def cut(self, text):
        result = []
        index = 0
        text_length = len(text)
        while text_length > index:
            for size in range(self.maximum + index, index, -1):
                piece = text[index:size]
                if piece in self.dictionary:
                    index = size - 1
                    break
            index = index + 1
            result.append(piece + '----')
        print(result)
 
if __name__ == '__main__':
    text = '研究生命的起源'
    tokenizer = MM('./data/mm_dic.utf8')
    print(tokenizer.cut(text))

1.1.2 逆向最大匹配法

逆向最大匹配（Reverse Maximum Match Method, RMM 法）的基本原理与 MM 法相同，不同的是分词切分的方向与 MM 法相反。逆向最大匹配法从被处理文档的末端开始匹配扫描，每次取最末端的 i 个字符（i 为词典中最长词数）作为匹配字段，若匹配失败，则去掉匹配字段最前面的一个字，继续匹配。相应地，它使用的分词词典是逆序词典，其中的每个词都将按逆序方式存放。在实际处理时，先将文档进行倒排处理，生成逆序文档。然后，根据逆序词典，对逆序文档用正向最大匹配法处理即可。

1.1.3 双向最大匹配法

双向最大匹配法（Bi-direction Matching Method）是将正向最大匹配法得到的分词结果和逆向最大匹配法得到的结果进行比较，然后按照最大匹配原则，选取词数切分最少的作为结果。

双向最大匹配的规则是：

1. 如果正反向分词结果词数不同，则取分词数量较少的那个（如“南京市/长江/大桥”的分词数量为3，而“南京市/长江大桥”的分词数量为2，所以返回分词数量为2的）。
2. 如果分词结果词数相同：1）分词结果相同，就说明没有歧义，可返回任意一个；2）分词结果不同，返回其中单字较少的那个。

1.2 统计分词

基于统计的中文分词算法主要思想是把每个词看做是由词的最小单位的各个字组成的，如果相连的字在不同的文本中出现的次数越多，就证明这相连的字很可能就是一个词。

1. 基于统计的分词，一般要做如下两步操作：建立统计语言模型。
2. 对句子进行单词划分，然后对划分结果进行概率计算，获得概率最大的分词方式。这里就用到了统计学习算法，如隐含马尔可夫（HMM）、条件随机场（CRF）等。

1.2.1 HMM 模型

隐含马尔可夫（HMM）是将分词作为字在字串中的序列标注任务来实现的。其基本思路是：每个字在构造一个特定的词语时都占据着一个特定的构词位置，现规定每个字最多只有四个构词位置：即B（词首）、M（词中）、E（词尾）和 S（单独成词），那么下面句子1）的分词结果可以表示成2）所示的逐字标注形式：

1）中文/分词/是/.文本处理/不可或缺/的/一步！

2）中/B文/E分/B词/E是/S文/B本/M处/M理/M不/B可/M或/M缺/E的/S一/B步/E！/S

用数学抽象表示如下：用 λ = λ₁λ₂...λ_n 代表输入的句子，n 为句子长度， λ_i 表示字，ο = ο₁ο₂...ο_n 代表输出的标签，那么理想的输出即为：

max = maxP(ο₁ο₂...ο_n|λ₁λ₂...λ_n)

在分词任务上，ο 即为B、M、E、S 这 4 种标记，λ 为诸如“中”、“文”等句子中的每个字（包括标点等非中文字符）。引入观测独立性假设，即每个字的输出仅仅与当前字有关，于是就能得到下式：

P(ο₁ο₂...ο_n|λ₁λ₂...λ_n) = P(ο₁|λ₁)P(ο₂|λ₂)...P(ο_n|λ_n)

通过贝叶斯公式得到：

P(ο|λ) = P(ο, λ)/P(λ) = P(λ|ο)P(ο)/P(λ)

λ 为给定的输入，因此 P(λ) 计算为常数，可以忽略，因此最大化 P(ο|λ) 等价于最大化 P(λ|ο)P(ο)。针对 P(λ|ο)P(ο) 作马尔可夫假设，得到：

P(λ|ο) = P(λ₁|ο₁)P(λ₂|ο₂)...P(λ_n|ο_n)

对 P(ο) 做齐次马尔可夫假设，每个输出仅仅与上一个输出有关，那么：

P(ο) = P(ο₁)P(ο₂|ο₁)P(ο₃|ο₂)...P(ο_n|ο_n-1)

于是：

P(λ|ο)P(ο) ～ P(λ₁|ο₁)P(ο₂|ο₁)P(λ₂|ο₂)P(ο₃|ο₂)...P(ο_n|ο_n-1)P(λ_n|ο_n)

在 HMM 中，将 P(λ_k|ο_k) 称为发射概率，P(ο_k|ο_k-1) 称为转移概率。通过设置某些 P(ο_k|ο_k-1) = 0，可以排除类似 BBB、EM等不合理的组合。

在 HMM 中，求解 maxP(λ|ο)P(ο) 的常用方法是 Veterbi 算法。它是一种动态规划方法，核心思想是：如果最终的最优路径经过某个 ο_i，那么从初始节点到 ο_i-1 点的路径必然也是一个最优路径——因为每一个节点 ο_i 只会影响前后两个 P(ο_i-1|ο_i) 和 P(ο_i|ο_i+1)。

下面是通过 python 来实现的 HMM，将其封装成一个类：

class HMM(object):
    def __init__(self):
        self.model_file = './data/hmm_model.pkl'
        self.state_list = ['B', 'M', 'E', 'S']
        self.load_para = False
 
    def try_load_model(self, trained):
        if trained:
            import pickle
            with open(self.model_file, 'rb') as f:
                self.A_dic = pickle.load(f)
                self.B_dic = pickle.load(f)
                self.Pi_dic = pickle.load(f)
                self.load_para = True
        else:
            self.A_dic = {}
            self.B_dic = {}
            self.Pi_dic = {}
            self.load_para = False
 
    def train(self, path):
        self.try_load_model(False)
        Count_dic = {}
 
        def init_parameters():
            for state in self.state_list:
                self.A_dic[state] = {s: 0.0 for s in self.state_list}
                self.Pi_dic[state] = 0.0
                self.B_dic[state] = {}
                Count_dic[state] = 0
 
        def makeLabel(text):
            out_text = []
            if len(text) == 1:
                out_text.append('S')
            else:
                out_text += ['B'] + ['M'] * (len(text) - 2) + ['E']
            return out_text
 
        init_parameters()
        line_num = -1
        words = set()
        with io.open(path, encoding='utf8') as f:
            for line in f:
                line_num += 1
                line = line.strip()
                if not line:
                    continue
                word_list = [i for i in line if i != ' ']
                words |= set(word_list)
 
                linelist = line.split()
 
                line_state = []
                for w in linelist:
                    line_state.extend(makeLabel(w))
 
                assert(len(word_list) == len(line_state))
 
                for k, v in enumerate(line_state):
                    Count_dic[v] += 1
                    if k == 0:
                        self.Pi_dic[v] += 1
                    else:
                        self.A_dic[line_state[k-1]][v] += 1
                        self.B_dic[line_state[k]][word_list[k]] = \
                            self.B_dic[line_state[k]].get(word_list[k], 0) + 1.0
        self.Pi_dic = {k: v * 1.0 / line_num for k, v in self.Pi_dic.items()}
        self.A_dic = {k: {k1: v1 / Count_dic[k] for k1, v1 in v.items()}
                      for k, v in self.A_dic.items()}
        self.B_dic = {k: {k1: (v1 + 1) / Count_dic[k] for k1, v1 in v.items()}
                      for k, v in self.B_dic.items()}
 
        import pickle
        with open(self.model_file, 'wb') as f:
            pickle.dump(self.A_dic, f)
            pickle.dump(self.B_dic, f)
            pickle.dump(self.Pi_dic, f)
 
        return self
 
    def viterbi(self, text, states, start_p, trans_p, emit_p):
        V = [{}]
        path = {}
        for y in states:
            V[0][y] = start_p[y] * emit_p[y].get(text[0], 0)
            path[y] = [y]
        print(V)
        print(path)
        for t in range(1, len(text)):
            V.append({})
            newpath = {}
 
            neverSeen = text[t] not in emit_p['S'].keys() and \
                text[t] not in emit_p['M'].keys() and \
                text[t] not in emit_p['E'].keys() and \
                text[t] not in emit_p['B'].keys()
            for y in states:
                emitP = emit_p[y].get(text[t], 0) if not neverSeen else 1.0
                (prob, state) = max(
                    [(V[t-1][y0] * trans_p[y0].get(y, 0) * emitP, y0) for y0 in states if V[t-1][y0] > 0]
                )
                V[t][y] = prob
                newpath[y] = path[state] + [y]
            path = newpath
        if emit_p['M'].get(text[-1], 0) > emit_p['S'].get(text[-1], 0):
            (prob, state) = max([(V[len(text) - 1][y], y) for y in ('E', 'M')])
        else:
            (prob, state) = max([(V[len(text) - 1][y], y) for y in states])
        return (prob, path[state])
 
    def cut(self, text):
        import os
        if not self.load_para:
            self.try_load_model(os.path.exists(self.model_file))
        prob, pos_list = self.viterbi(text, self.state_list, self.Pi_dic, self.A_dic, self.B_dic)
        begin, next = 0, 0
        for i, char in enumerate(text):
            pos = pos_list[i]
            if pos == 'B':
                begin = i
            elif pos == 'E':
                yield text[begin: i+1]
                next = i + 1
            elif pos == 'S':
                yield char
                next = i + 1
        if next < len(text):
            yield text[next:]
 
if __name__ == '__main__':
    hmm = HMM()
    # hmm.train('./data/trainCorpus.txt_utf8')
    text = '这是一个非常棒的方案'
    res = hmm.cut(text)
    print(list(res))