devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

kbqa基于复旦大学的实现代码解析完成步骤 （二）_chatkbqa代码解析

作者：小丑西瓜9 | 2024-06-15 15:15:01

赞

踩

chatkbqa代码解析

      一 已经堆主函数做了部分解释，许多细节是做了一些规则，或者利用了论文立的方法，所以要把代码和论文结合，才能看懂。

      在main_qa用到了两个自己写的文件： 

  1. from KBQA_small_data_version1.kbqa.connectSQLServer import connectSQL
  2. from KBQA_small_data.kbqa.entity_recognize import Entity

那么分别对这两个文件进行解释，

一   connectSQLServer文件

                        不需要做过多的介绍，原因比较简单就是连接一些数据库的信息。

二   entity_recognize

            那么这个文件，其实已经回答的很清楚了，在main_qa主要调用了get_synonym1（）函数，entity_connect（）函数这两个函数，其实并不多，

  1. #! -*- coding:utf-8 -*-
  2.  
  3. """
  4. 为了识别问题与答案中的实体;数据保存在sqlserver，
  5. 思路一：首先加载m2e.txt实体到用户词典；对问题进行切词；（1）通过命名实体识别识别实体，识别不出或者识别出来实体的用m2e,搜索实体，根据答案以及实体在KB中寻找三元组存成（q:{e1,e2,...,en}） 以及(e1:[property,v]) 用的函数是 save_evc 保存
  6. """
  7. import jieba.analyse
  8. import math
  9. from collections import Counter
  10. import jieba.posseg
  11. from time import time
  12. from stanfordcorenlp import StanfordCoreNLP
  13. from KBQA_small_data_version1.kbqa.connectSQLServer import connectSQL
  14. import pickle
  15. # jieba.load_userdict('./../data/user_dict.txt')
  16. # host = 'DQ26-000018Z29'ls
  17. # user = 'chen'
  18. # password = '123456'
  19. # host = '172.17.0.169'
  20. host = '172.16.211.128'
  21.  
  22. user = 'sa'
  23. password = 'chentian184616_'
  24. database= 'chentian'
  25.  
  26. querySQL = connectSQL(host, user, password, database)
  27. class Entity:
  28.     def __init__(self):
  29.         self.jieba_pos=['i','j','l' ,'m' ,'nr','nt','nz','b','nrfg']
  30.         self.tf_idf=jieba.analyse.extract_tags
  31.         self.nlp = StanfordCoreNLP(path_or_host='../../stanford-corenlp/stanford-corenlp-full-2017-06-09/',lang='zh')
  32.         self.sql="SELECT * FROM [chentian].[dbo].[baike_triples1] WHERE entity in %(name)s "
  33.         self.sql2="SELECT * FROM [chentian].[dbo].[baike_triples1] WHERE entity ='%s' "
  34.         # self.question='D:/QA/answer.txt'
  35.         self.sql1="SELECT real_entities FROM [chentian].[dbo].[m2e1] where entity='%s'"
  36.         self.sql3="SELECT value FROM [chentian].[dbo].[baike_triples1] WHERE property='BaiduTAG' "
  37.         # self.KB='./../data/baike_triples.txt'
  38.         # self.m2e='./../data/m2e.txt'
  39.        一些数据库的配置以及数据库的语句，比较简单
  40.  
  41.  
  42.  
  43.  
  44.     def name_entity(self,entity):
  45.         """
  46.         把实体对应的属性全部返回，包括对应类别
  47.         :param entity:
  48.         :return:
  49.         """
  50.         with open(self.KB,'r',encoding='utf-8') as f:
  51.             lines=f.readlines()
  52.             for line in lines:
  53.                 words=line.split("\t")
  54.                 if entity in words[0] :
  55.                     print(line)
  56.     def get_synonym(self,sentence):
  57.         """
  58.         获取实体对应的多义词
  59.         :param entity:
  60.         :return:
  61.         """
  62.         entiies=[]
  63.         for line in open(self.m2e,'r',encoding='utf-8'):
  64.             words=line.strip('\n').split("\t")
  65.             if words[0] in sentence:
  66.                 entiies.append(words[1])
  67.         return entiies
  68.  
  69.     def get_synonym2(self, entity):
  70.         """
  71.         获取实体对应的多义词
  72.         :param entity:
  73.         :return:
  74.         """
  75.         entiies = []
  76.         for line in open(self.m2e, 'r', encoding='utf-8'):
  77.             words = line.strip('\n').split("\t")
  78.             if words[0] == entity:
  79.                 entiies.append(words[1])
  80.         return entiies
  81.  
  82.  
  83.  这个是真正利用的函数，比较简单，相当于把问句中的多个候选实体候选集合拿出来
  84.     def get_synonym1(self,entity):
  85.         """
  86.         获取实体对应的多义词 
  87.         :param entity:
  88.         :return:
  89.         """
  90.         temp_sql = self.sql1 % entity
  91.         result = querySQL.Query(temp_sql)
  92.         return result
  93.  
  94.  
  95.  
  96.  
  97.     def save_evc(self,sentence,answer):
  98.         """
  99.         存储实体value以及对应类别
  100.         :return: 返回问题为{key1 :{e1,p1,v1}, {e2,p2,v2}} 的形式
  101.         """
  102.         jieba_cut = "|".join(jieba.cut(sentence)).split("|")
  103.         if "是谁唱的" in sentence or "是谁写的" in sentence or "谁唱" in sentence or "谁写" in sentence:
  104.             question_entity = ''
  105.             for e in sentence:
  106.                 if e == "是" or e=="谁": break
  107.                 question_entity += e
  108.             question_entity=[question_entity]
  109.         else:
  110.             question_entity=self.nlp.ner(sentence) #获得Stanford的实体识别的结果，以及切词结
  111.             # pos_re=self.nlp.pos_tag(sentence)
  112.             print(question_entity,"2222222222222222")
  113.             pos_jieba=jieba.posseg.cut(sentence)
  114.             # print(pos_re)
  115.             # print(question_entity)
  116.             # print(jieba_cut)
  117.             if len(jieba_cut)<len(question_entity):
  118.                 final_words = []
  119.                 for ele in jieba_cut:
  120.                     tem_word = ''
  121.                     flag = False
  122.                     for el in question_entity:
  123.                         if el[0] in ele:
  124.                             if el[1] !='O' and el[1]!='NT' and el[1]!='NUMBER': flag = True
  125.                             tem_word += el[0]
  126.                     if flag == True:
  127.                         final_words.append(tem_word)
  128.                 question_entity=final_words
  129.                 # print(question_entity,"^^^^^^^^^^^^^^^^^^^^^^^^")
  130.             else:
  131.                 question_entity=self.entity_connect(question_entity)
  132.                 # print(question_entity,"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@2")
  133.             for i in pos_jieba:
  134.                 # print(i.word, i.flag, "#################################################")
  135.                 if i.flag in self.jieba_pos:
  136.                     question_entity.append(i.word)
  137.             # print(question_entity, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1")
  138.             # #对实体进行连接，相邻作为一个实体在kb中寻找，依次递减
  139.             #如果整个句子中不包含实体，则需要从m2e中寻找且此后对应的实体,从名词‘NN’中作为备选实体
  140.             if len(question_entity)==0:
  141.                 jieba_entity=[]
  142.                 jieba_pos = jieba.posseg.cut(sentence)
  143.                 for i in jieba_pos:
  144.                     if i.flag in self.jieba_pos:
  145.                         jieba_entity.append(i.word)
  146.                 question_entity=jieba_entity
  147.                 # print(question_entity,"###################################################")
  148.             if len(question_entity)==0:
  149.                 tf_idf=jieba.analyse.extract_tags
  150.                 JIE=tf_idf(sentence)
  151.                 # print(JIE)
  152.                 words_tag_jieba=JIE[:math.ceil(len(JIE)*0.3)] #这是jieba切词结果，要比stanford更符合中文习惯，
  153.                 question_entities=[]
  154.                 try:
  155.                     words_tag = self.nlp.pos_tag("".join(words_tag_jieba))
  156.                     if len(words_tag_jieba) < len(words_tag):
  157.                         final_words = []
  158.                         for ele in words_tag_jieba:
  159.                             tem_word = ''
  160.                             for el in words_tag:
  161.                                 if el[0] in ele:
  162.                                     tem_word += el[0]
  163.                             final_words.append(tem_word)
  164.                         question_entity = final_words
  165.                     else:
  166.                         for value in words_tag:
  167.                             # print(value)
  168.                             # if value[1] == 'NN'or value[1]=='NR':
  169.                             question_entities.append(value[0])
  170.                         question_entity=question_entities
  171.                     # print(question_entity,"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$4")
  172.                 except:
  173.                     print(sentence,"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$44")
  174.                     return 0
  175.         question_e={}
  176.         tf_idf = jieba.analyse.extract_tags
  177.         JIE = tf_idf(sentence)
  178.         # print(JIE[:2])
  179.         # print(question_entity,"**************")
  180.         extract={} #提取出问题中的实体以及答案中的value,还有对应的property ,类型为[entity,property,value]
  181.         question_entity.extend(JIE[:2])
  182.         question_entity=self.connect_entity(jieba_cut,question_entity)
  183.         # print(question_entity, "**************")
  184.         for entity in question_entity:  #查找m2e文件把所有有关的实体全部找出
  185.             # print(entity,"88888")
  186.             temp_sql_origal = self.sql2 % entity  # real_entity 是一个元组，
  187.             result_origal = querySQL.Query(temp_sql_origal)  # 用sqlserver的in (e1,e2,e3)元组中得到所有的结果，不用再对real_entity实体循环多次select查找
  188.             if len(result_origal)!=0:
  189.                 values = result_origal['value']
  190.                 for index, va in enumerate(values):
  191.                     # print(va, answer, va.replace("<a>", '').replace("</a>", '') in answer)
  192.                     # print(va, answer, answer in va.replace("<a>", '').replace("</a>", ''))
  193.                     # print(va, answer, self.simple_similar(va.replace("<a>", '').replace("</a>", ''), answer))
  194.                     # print("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^")
  195.                     # 对于搜索出来的实体有两个条件可以添加（e,p,v）一是kb被包含在答案中，或者两者简单相似度为0.9以上添加相似对
  196.                     if va.replace("<a>", '').replace("</a>", '') in answer or answer in va.replace("<a>", '').replace(
  197.                             "</a>", '') or self.simple_similar(va.replace("<a>", '').replace("</a>", ''), answer) > 0.8:
  198.                         if ' '.join(list(result_origal.loc[index])) in extract:
  199.                             extract['&&&&&'.join(list(result_origal.loc[index]))] += 1
  200.                         else:
  201.                             extract['&&&&&'.join(list(result_origal.loc[index]))] = 1
  202.             entity=entity.replace("'","''")
  203.             real_entity= [k.replace("'", "") for k in self.get_synonym1(entity)['real_entities']] #由于实体中可能包含',则替换为'' 在数据库中就认为是单引号
  204.             if len(real_entity)==0:real_entity="('"+str(entity)+"')" #如果m2e文件中没有多义词，则实体自己为real_entity
  205.             elif len(real_entity)==1:real_entity="('"+str(real_entity[0])+"')"
  206.             else:real_entity=tuple(real_entity)
  207.             # real_entity=self.get_synonym2(entity)
  208.             temp_sql = self.sql % {'name':real_entity}  #real_entity 是一个元组，
  209.             result = querySQL.Query(temp_sql) #用sqlserver的in (e1,e2,e3)元组中得到所有的结果，不用再对real_entity实体循环多次select查找
  210.             values=result['value']
  211.             for index,va in enumerate(values):
  212.                 # print(va,answer,va.replace("<a>",'').replace("</a>",'') in answer)
  213.                 # print(va,answer,answer in va.replace("<a>",'').replace("</a>",''))
  214.                 # print(va,answer,self.simple_similar(va.replace("<a>",'').replace("</a>",''),answer))
  215.                 # print("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^")
  216.                 #对于搜索出来的实体有两个条件可以添加（e,p,v）一是kb被包含在答案中，或者两者简单相似度为0.9以上添加相似对
  217.                 if va.replace("<a>",'').replace("</a>",'') in answer or answer in va.replace("<a>",'').replace("</a>",'') or self.simple_similar(va.replace("<a>",'').replace("</a>",''),answer)>0.8:
  218.                     if ' '.join(list(result.loc[index])) in extract:
  219.                         extract['&&&&&'.join(list(result.loc[index]))]+=1
  220.                     else:
  221.                         extract['&&&&&'.join(list(result.loc[index]))]=1
  222.  
  223.         if len(extract)!=0:
  224.             question_e[sentence]=extract
  225.             print(question_e)
  226.             return question_e
  227.         else:
  228.             # print(sentence,"%%%%",answer)
  229.             # print("&&&&&&&&&&&")
  230.             return 0
  231.  
  232.     def connect_entity(self,question,question_entity):
  233.         prio = []
  234.         real_enity=[]
  235.         for question_e in question_entity:
  236.             if question_e in question:
  237.                 prio.append(question.index(question_e))
  238.         k=1
  239.         print(question_entity)
  240.         while k<len(prio):
  241.             if prio[k]-prio[k-1]==1:
  242.                temp_enity=question[prio[k-1]]+question[prio[k]]
  243.                print(question[prio[k-1]])
  244.                print(question[prio[k]])
  245.                print(question_entity,"^^^^^^^^^^^")
  246.                question_entity.remove(question[prio[k-1]])
  247.                question_entity.remove(question[prio[k]])
  248.                real_enity.append(temp_enity)
  249.             k+=1
  250.         real_enity.extend(question_entity)
  251.         return real_enity
  252.  
  253. 这个也是利用的函数，非常将单，函数说明也比较清除就不再说明
  254.     def entity_connect(self,entity,flag=['O','NUMBER']):
  255.         """
  256.         函数作用就是如果两个识别出来的实体相连就认为是一个，某则作为新的实体添加
  257.         """
  258.         entities = []  # 根据stanford找到所有问题中的实体
  259.         temp_entity = ''
  260.         for value in entity:
  261.             if value[1] not in flag:
  262.                 temp_entity += value[0]
  263.             else:
  264.                 if temp_entity != '':
  265.                     entities.append(temp_entity)
  266.                     temp_entity = ''
  267.         if temp_entity != '':
  268.             entities.append(temp_entity)
  269.         return entities
  270.  
  271.     def simple_similar(self,answer, sent):
  272.         """
  273.         比较两个字符串含有共同字符的个数的比例
  274.         :return: 返回比例
  275.         """
  276.         count = 0
  277.         answer_len = len(answer)
  278.         sent_len = len(sent)
  279.         min_len = 0
  280.         if answer_len < sent_len:
  281.             min_len = answer_len
  282.             for an in answer:
  283.                 if an in sent:
  284.                     count += 1
  285.         else:
  286.             min_len = sent_len
  287.             for an in sent:
  288.                 if an in answer:
  289.                     count += 1
  290.         return count * 1.0 / min_len
  291.     def get_pevq(self):
  292.         """
  293.         这个函数是所有的主函数，把问题答案QA语料得到基于KB的EV对
  294.         :return: 返回【{'奥巴马什么时候出生的': {'奥巴马（圣枪游侠） 其他名称 奥巴马': 1, '奥巴马（美国第44任总统） 出生日期 1961年8月4日': 1}}】
  295.         这样的列表形式，以后得存储形式，在效率不足的情况下，在进行讨论
  296.         """
  297.         final_pevq=[]
  298.         i=0
  299.         with open('./../data/train_questions_with_evidence1.txt','r',encoding='utf-8') as f:
  300.             lines=f.readlines()
  301.             start = time()
  302.             for line in lines:
  303.                 # print(line)
  304.                 question,answer=line.strip().replace("\t","").split("&&&&&")
  305.                 question_dict=self.save_evc(question,answer)
  306.                 if question_dict!=0:
  307.                     final_pevq.append(question_dict)
  308.                 i+=1
  309.                 if i%100==0:
  310.                     end=time()
  311.                     print("消耗的时间为"+str(end-start)+"秒")
  312.         output=open('./../data/pqev_final_update.pkl','wb')
  313.         pickle.dump(final_pevq,output)
  314.         output.close()
  315.     def store_EV(self,file_path):
  316.         """
  317.         本函数的作用是把pqev_final.pkl的构造成类似于e:{v1:频数，v2：频数，...,}和v:{e1:频数,e2:频数,...}
  318.         :param file_path: 对应的pqev_final.pkl路径
  319.         """
  320.         entities_values={}
  321.         value_entity={}
  322.         file_path=open(file_path,"rb")
  323.         train_data=pickle.load(file_path)
  324.         for que1 in train_data:
  325.             evi = list(que1.values())[0]  # 问题中的所有（实体-属性-值）
  326.             for key in evi.keys():
  327.                 value_temp={}
  328.                 entity_temp={}
  329.                 e, p, v = key.split("&&&&&")  # 接下来对每一个v 遍历每一个问题中所有的相同v,得到对应的实体e，并且记录实体出现的频数 实体e可能出现多次,对第一个概率没有影响，但是对第二个有影响，本来有结果，
  330.                 if e in entities_values:
  331.                     if v!='':
  332.                         if v in entities_values[e]:
  333.                             entities_values[e][v]+=1
  334.                         else:
  335.                             entities_values[e][v]=1
  336.                 else:
  337.                     if v!='':
  338.                         value_temp[v]=1
  339.                         entities_values[e]=value_temp
  340.                 if v!='':
  341.                     if v in value_entity:
  342.                         if e !='':
  343.                             if e in value_entity[v]:
  344.                                 value_entity[v][e]+=1
  345.                             else:
  346.                                 value_entity[v][e]=1
  347.                     else:
  348.                         if e!='':
  349.                             entity_temp[e]=1
  350.                             value_entity[v]=entity_temp
  351.         output = open('./../data/EV_two.pkl', 'wb')
  352.         pickle.dump(entities_values, output)
  353.         pickle.dump(value_entity,output)
  354.         output.close()
  355.         file_path.close()
  356.     def get_baiduTag(self):
  357.         """
  358.         此函数是获取到concept ，并且计数每一个概念的频数作为概念的权重
  359.         :return:
  360.         """
  361.         tags = querySQL.Query(self.sql3)  # 用sqlserver的in (e
  362.         print(list(tags['value'])[:20])
  363.         concept_count=Counter(list(tags['value']))
  364.         concept_count=dict(concept_count)
  365.         output = open('./../data/concept_count.pkl', 'wb')
  366.         pickle.dump(concept_count, output)
  367.         output.close()
  368. if __name__=="__main__":
  369.     # entity=Entity()
  370.     # entity.get_baiduTag()
  371.     # entity.store_EV("E:\chenmingwei\KBQA_small_data\data\pqev_final.pkl")
  372.     # entity.get_pevq()
  373.     EV=open("E:\chenmingwei\KBQA_small_data\data\pqev_final.pkl",'rb')
  374.     entity_value=pickle.load(EV)
  375.     for key in entity_value:
  376.         print(key)
  377.     # value_entity=pickle.load(EV)
  378.     # for key,value in entity_value.items():
  379.     #     print(key,value)
  380.     # b='全面内战爆发后，国民党反动派在昆明杀害的民盟中央委员是： & & & & & 李公朴'
  381.  
  382.     # a='“昌黎先生”是？&&&&&韩愈'
  383.     # que,ans=a.split("&&&&&")
  384.     # print(len(ans))
  385.     # result=entity.save_evc(que,ans)
  386.     # print(result)
  387.     # sentence='123广西贺州重大故意伤害案什么时候发生的'
  388.     # words=' '.join(jieba.cut(sentence))
  389.     # question = '奥巴马什么时候出生的'
  390.     # answer = '奥巴马出生于1961年8月4日'
  391.     # question='控制器原理'
  392.     # answer='控制器（英文名称：controller）是指按照预定顺序改变主电路或控制电路的接线和改变<a>电路'
  393.     # start1=datetime.datetime.now()
  394.     # final_dict = entity.save_evc(question, answer)
  395.     # print(final_dict)
  396.     # result=entity.get_synonym1('蝴蝶')
  397.     # result=tuple([k.replace("'",'"') for k in result['real_entities']])
  398.     # temp_sql = entity.sql % {'name': result}  # real_entity 是一个元组，
  399.     # print(temp_sql)
  400.     # result = querySQL.Query(temp_sql)
  401.     # print(result)
  402.     # end1=datetime.datetime.now()
  403.     # entiies=entity.get_synonym() #用于获取所有问题的实体，不进行切词处理，防止因为切词造成实体的丢失
  404.                 #对于答案，
  405.     # for entit in entiies:
  406.     #     entity.name_entity(entit,answer)
  407.  
  408.  
  409.   当然这个文件中还有其他函数，就是训练使用的函数，至此差不多就完成了，在训练好模型的前提下，整个服务启动，能够使用的文件比较简单。主要是依赖就是数据集，训练模型参数，就是初始化函数加载的文件，依赖包的安装，用这么多函数，主要就是standford的命名实体识别局限性导致的。

接下来就讲解训练部分的代码，请看三。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/722764
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号