自然语言处理——分词系统（双向最大匹配）

算法分析

双向最大匹配，顾名思义就是将正向最大匹配和逆向最大匹配结合在一起
具体算法，详见正向最大匹配
将而二者得到的结果进行比较
1.如果正反向分词结果词数不同，则取分词数量较少的那个。
2.如果分词结果词数相同
.a.分词结果相同，就说明没有歧义，可返回任意一个。
.b.分词结果不同，返回其中单字较少的那个。

代码实现

BMM.py

#实现切词方法
def cut_words(raw_sentence, words_dic):
    #找到最大词的长度
    max_length = max(len(word) for word in words_dic)
    sentence = raw_sentence.strip()
    words_length = len(sentence)
    #存储切分好的分词
    cut_words = []
    #开始切分
    while words_length > 0:
        #求算每次切分的长度
        max_cut_length = min(words_length, max_length)
        #切分出一个子串，从右侧切分
        subSentence = sentence[-max_cut_length:]
        #切分一轮，在左侧删去一个字符 每成功匹配一次就进行break
        while max_cut_length > 0:
            #成功匹配一个分词
            if subSentence in words_dic:
                cut_words.append(subSentence)
                break
            #只剩下一个字
            elif max_cut_length == 1:
                cut_words.append(subSentence)
                break
            #都不符合，从左侧去掉一个词，长度减一，继续循环
            else:
                max_cut_length -= 1
                subSentence = subSentence[-max_cut_length:]
        #将切掉的单词(后侧)删去，将切掉的长度减去
        sentence = sentence[0:-max_cut_length]
        words_length -= max_cut_length
    cut_words.reverse()
    #words = '/'.join(cut_words)
    return cut_words

FMM.py

#实现正向最大匹配法
def cut_words(raw_sentence, words_dic):
    #统计词典种最长的词(若小于待切分总长度，则每次从未匹配处找这么长的字符串开始匹配)
    max_length = max(1, 3)   #len(word) for word in words_dic
    sentence = raw_sentence.strip()   #移除字符串内的空格
    #统计序列长度
    words_length = len(sentence)
    #存储切分好的词语
    cut_word_list = []
    while words_length > 0:
        max_cut_length = min(max_length, words_length)
        subSentence = sentence[0 : max_cut_length]
        #进行一轮分词，在左侧切出一个词
        while max_cut_length > 0:
            if subSentence in words_dic:  #若待切分的词在词典中，则将其加入已分列表，跳出循环
                cut_word_list.append(subSentence)
                break
            elif max_cut_length == 1:   #剩下单个字,将其切分，并跳出循环
                cut_word_list.append(subSentence)
                break
            else:     #都不符合则从右侧去掉一个词，重新分词
                max_cut_length = max_cut_length - 1
                subSentence = subSentence[0 : max_cut_length]
        #将切掉的单词删去
        sentence = sentence[max_cut_length:]
        words_length = words_length - max_cut_length
    #words = "/".join(cut_word_list)
    #为了配合双向匹配
    return cut_word_list

BIMM.py

import FMM
import BMM

words_dic = []

def init():
    """
    读取词典文件
    载入词典
    :return:
    """
    #with as 的用法噶
    with open("dict.txt", encoding="utf8") as dic_input:
        for word in dic_input:
            words_dic.append(word.strip())

#实现双向最大匹配法   正反相同返回分次数少的那个
def cut_words(raw_sentence, word_dic):
    bmm_word_list = BMM.cut_words(raw_sentence, word_dic)
    fmm_word_list = FMM.cut_words(raw_sentence, word_dic)
    bmm_size = len(bmm_word_list)
    fmm_size = len(fmm_word_list)
    #分词结果数不同
    if bmm_size != fmm_size:
        if bmm_size < fmm_size:
            return bmm_word_list
        else:
            return fmm_size
    #分词结果数相同，1.结果相同，无歧义，返回任意一个  2。结果不同，返回单字少的那个
    else:
        Fsingle = 0
        Bsingle = 0
        isSame = True
        for i in range(bmm_size):
            #分词结果不同
            if bmm_word_list[i] != fmm_word_list[i]:   # not in也可以
                isSame = False
            #统计单个词的数量
            if len(bmm_word_list[i]) == 1:
                Bsingle += 1
            if len(fmm_word_list[i]) == 1:
                Fsingle += 1
        if isSame == True:
            return bmm_word_list
        #分词结果不同选词数少的一个
        else:
            if Fsingle >= Bsingle:
                return bmm_word_list
            else:
                return fmm_word_list

def main():
    """
    于用户交互接口
    :return:
    """
    init()
    while True:
        print("请输入您要分词的序列")
        input_str = input()
        if not input_str:
            break
        result = cut_words(input_str, words_dic)
        result = '/'.join(result)
        print("分词结果：")
        print(result)
if __name__ == '__main__':
    main()