Bigram-MLE语言模型和模拟输入法的python实现

一、题目要求

 二、实验数据集

          https://github.com/liweikuan123/-.git

三、python代码

function.py(对语料进行处理，生成用于构建二元语言模型和模拟输入法的中间文件）

import re
import jsonlines


# 训练语料：metadata.txt
# 生成文档： 1. d.jsonl文件,  2. output.jsonl文件  3. generator_5possible_value.jsonl文件   4. data.txt文件



new_ll=[]  #词汇表：存储单词
dict_file={}  #cut函数中，对每一行数据切分后,产生的中间存储变量, 字典格式：dict{the:[boy,boy, girl,apple, apple,...], boy:[like,like, eat, play,play.....], like:[eatting, playing.....], eatting:[apple,apple.... ].....}
total_list=[] #全部单词(包含重复单词)
d={} #存储每个单词以及它的统计频数, d{read:13, the:10,  a:12, book: 15,......... }
frequency_dict={} #用于封装key_value{}的中间存储变量。
key_value={} #在output.jsonl文件中按行存储的字典
###############################################################################################################
key_5value={}  #用于封装value{}的中间存储变量。
word_num=5  #每个单词后最可能出现的单词的数目。
value={}   #generator_5possible_value.jsonl文件中按行存储的字典



#count_list()函数：用于统计词汇表中的单词
#new_ll中存储词汇表中的单词
def count_list(list_file):
    #用一个列表记录总共多少种单词
    global new_ll
    for i in list_file:
        if i not in new_ll:
            new_ll.append(i)



#存储字典d (字典中包含键值对，例如：{read:13, the:10,  a:12, book: 15,......... },生成d.jsonl文件。
def save_dict(line):
    with jsonlines.open('i:d.jsonl', mode='w') as writer:
        writer.write(line)



#遍历total_list列表，对列表中的单个单词进行统计数目，将结果存入d[]字典内，例如：d{ read : 20,  the : 30,....}
def count_total_list(total_list):
 #用一个字典记录结果 ,遍历列表 , 求count()
    global new_ll
    for i in new_ll:
        d[i]=total_list.count(i) #统计某个单词在训练语料中出现的频数。
    save_dict(d)  #存储d字典



#对一行数据进行切分，例如：the boy like eatting apple, 切分为：{the:[boy], boy:[like], like:[eatting], eatting:[apple].......}
#如果dict_file中存在某一个key=result_list[i],将result_list[i+1]添加到dict_file[result_list[i]]的列表中。
#构建dict_file字典，字典最终格式：dict{the:[boy,boy, girl,apple, apple,...], boy:[like,like, eat, play,play.....], like:[eatting, playing.....], eatting:[apple,apple.... ].....}
def cut(result_list):
   global dict_file
   for i in range(len(result_list)-1):
       if result_list[i] not in dict_file:
          dict_file[result_list[i]]=[result_list[i+1]]
       else:
           dict_file[result_list[i]].append(result_list[i+1])


#对frequency_count()函数产生的key_value{}进行存储。
#以json格式按行存储字典元素(字典元素中包含键值对，每条json数据格式：key_value{read :{ the:10,  a:12, book: 15 } }  ,即以read开头的，二元语法及频数。
#生成output.jsonl文件
def save_key_value(line):
    with jsonlines.open('i:output.jsonl', mode='a') as writer:
        writer.write(line)



#对new_ll(词汇表)中各个单词，挑选其后最可能出现的五个单词，生成generator_5possible_value.jsonl文件, 用于模拟输入法程序。
#value字典的格式形式： value { the:30, a:20, book:15, pen:12, apple:2}
def generator_5possible_value(i,data):
    global value,key_5value
    data_list = list(data.keys())
    length = len(data_list)
    if length < word_num:
        for count in range(length):
            value[data_list[count]]=data[data_list[count]]
        key_5value[i]=value
    else:
        for count in range(word_num):
            value[data_list[count]] = data[data_list[count]]
        key_5value[i] = value
    with jsonlines.open('i:generator_5possible_value.jsonl', mode='a') as writer:
        writer.write(key_5value)    #生成generator_5possible_value.jsonl文件,存储每个单词后最有可能出现的五个单词。
    key_5value={}  #用于封装value{}的中间存储变量。
    value={}




#对于new_ll中的每一个单词,例如:read，查看是否在dict_file字典中存在key==i，如果存在，对于dict_file[i]中每个j,构建frequency_dict[name]=key，其中name=str(j),key=dict_file[i].count(j)
#对 frequency_dict中的对象，按照频数排序。
#再对frequency_dict进行封装，即：key_value[i]=data
#最终key_value字典格式为：key_value{read: {the:10, a:12, book:5,....}  } 及二元语法中，read后出现的单词，以及各自的频数。
def frequency_count():
    global key_value,frequency_dict,new_ll
    for i in new_ll: #new_ll中每个单词
        if i in dict_file: #判断是否在dict_file中存在key==i
          for j in dict_file[i]:
            name=str(j)
            key=dict_file[i].count(j)
            frequency_dict[name]=key

          data=dict(sorted(frequency_dict.items(), key=lambda d: d[1], reverse=True))#对 frequency_dict中的对象，按照频数排序。
          # print(data)
          key_value[i] =data    #对frequency_dict进行封装
          generator_5possible_value(i,data)   #对new_ll中各个单词，挑选其后最可能出现的五个单词
          save_key_value(key_value)   #对分装好的key_value进行存储
          frequency_dict={}
          key_value = {}
          # frequency.append(frequency_dict)
          # frequency_dict = {}




def main():
 with open('i:metadata.txt',"r",encoding='utf-8') as f:    #设置文件对象
   with open('i:data.txt', 'w') as out:
     for line in f.readlines():  # 依次读取每行
         str_ =str(line)
         # print(str_)
         str_=str_[::-1]
         count=str_.find("|")
         # print(str_)
         # print(count)
         str_=str_[0:count]
         str_=str_[::-1]
         result_list = re.findall('[a-zA-Z0-9]+', str_)

         result_list.insert(0,"BOS")
         result_list.append("EOS")
                           #以上两行代码，对metadata.txt中第三列的每个句子处理为格式：result_list[ 'BOS','the','boy','is','a','very','great','child','EOS']
         for i in result_list:
             total_list.append(i)#统计所有单词，包括重复单词。
         # print(result_list)
         count_list(result_list)
         cut(result_list)
         out.writelines(result_list)  #生成data.txt文件，文件中储存处理后的句子，每个句子处理为格式：result_list[ 'BOS','the','boy','is','a','very','great','child','EOS']。
         out.writelines("
")
              # 以上部分代码，负责对metadata.txt中第三列进行处理，total_list中存储切分后的所有单词(包括重复单词).
     count_total_list(total_list) #遍历total_list列表，对列表中的单个单词进行统计数目，将结果存入d[]字典内，例如：d{ read : 20,  the : 30,....}
     print("字典"+str(d))
     print(len(d))
     frequency_count()  #生成key_value字典, 最终key_value字典格式为：key_value{read: {the:10, a:12, book:5,....}  } 及二元语法中，read后出现的单词，以及各自的频数。
     print("字符" + str(new_ll))
     print(len(new_ll))
     print("键-值" + str(dict_file))
     print(len(dict_file))
     print(len(total_list))
     out.close()
     f.close()




if __name__ == "__main__":
      main()

 LanguageModel.py(Bigram-MLE语言模型和模拟输入法程序）

import jsonlines

d={}   #用于接收d.jsonl文件中的d{}字典
copy_data=[]  #用于接收generator_5possible_value.jsonl文件中的value{}字典
sentence={}  #用于存储输入句子的最终处理结果的字典
probability_key_value={}  #用于存储句子[the first time]中二元语法的概率，例如：格式 {BOS-the:0.028100, the-first:0.009096, first-time:0.034375, time-EOS:0.110638}


#init_data()函数
#进行数据初始化，导入d.jsonl文件和generator_5possible_value.jsonl文件。
def init_data():
    global d,copy_data
    with jsonlines.open('i:d.jsonl', "r") as dict_reader:
        for line in dict_reader: #d{}字典在d.json文件中，实际上存储在一个json文件中，此循环只执行一次。
            d = line
    with jsonlines.open('i:generator_5possible_value.jsonl',"r") as reader:
        for obj in reader: #在generator_5possible_value.jsonl文件中，存在多个value{}字典，value{}字典的个数等于new_ll(词汇表)中单词的数目，循环执行多次。
            copy_data.append(obj)



#find()函数的功能
#对于一个二元语法模型<read a>,计算p(a|read)=c(read a)/c(read),返回计算结果
def find(key,value):
    global copy_data
    for i in copy_data:
        if key in i:
            if value in i[key]:
                return i[key][value]
            else:
                return 0



#Bigram-MLE模型算法
def algorithm_Bigram(data):
    global sentence,d,probability_key_value
    probability=1 #存储句子概率的中间变量。

    output=data.split()
    output.insert(0,"BOS")
    output.append("EOS")
            #上面三行代码，对输入的句子进行处理。 例如：句子[ i am a student ]处理结果为['BOS','i','am','a','student','EOS']
    for i in range(len(output)-1):
        sentence[output[i]]=output[i+1]  #处理后格式：sentence{ BOS:i , i:am, am:a, a:student, student:EOS}
    for j in range(len(output)-1):
        try:
            value= find(output[j],output[j+1])/d[output[j]]
        except ZeroDivisionError:
                value=-1
                print("不存在"+str(output[j]))
        probability_key_value[str(output[j])+'-'+str(output[j+1])]=value
        print(probability_key_value)
        probability*=value
    # print(sentence)
    # print(output)
    return probability





#模拟输入法：给定一个单词推荐接下来最有可能输入的5个单词。
def algorithm_IME(data):
    global  copy_data
    for dict_data in copy_data:
        if data in dict_data:
            print(dict_data[data])
        # print(i)
        # data2 = json.dumps(history, sort_keys=True, indent=4, separators=(',', ': '))
        # print(data2)





def main():
    init_data()
    # print(copy_data)
    # print(len(copy_data))
    select = input("Bigram-MLE计算语句概率未使用平滑技术(输入1)    模拟输入法(输入2)请输入选择：  ")
    if select=='1':
        print("Bigram-MLE计算语句概率未使用平滑技术")
        data = input("请输入： ")
        probability=algorithm_Bigram(data)
        print(probability)
        print("结束")
    if select=='2':
        print("模拟输入法")
        while True:
            data = input ("请输入： ")
            if data=='#':
                break
            print("你输入的内容是: ", data)
            algorithm_IME(data)
        print("结束")



if __name__ == "__main__":
      main()

四、可能的改进

语言模型概率：
1.概率科学计数
为了防止概率计算的时候因为越算越小导致计算机无法比较，所有的概率都进行了自然对数运算
2.引入平滑技术
3.语言模型的性能评估(准备测试集，计算交叉熵和困惑度）