我的第一次知识图谱问答

这次想写一个知识图谱问答系列，从文本读取的知识图谱元素到智能处理的对话问答系统，涉及到实体识别、意图识别、槽位提取等技术。这里解释一下名词的含义。

实体识别：这个一般处理是正则表达式，或者是训练分类也就是BIO标签tag+softmax....有些人说是前者规则，后者学习。哈哈哈都行~~~

意图识别：就是判别这个问题是什么类型的问题，表示什么意思。比如，感冒可以吃什么药。我们可以知道这个问题是根据病来查吃什么药。。

槽位提取：就是对提的问题关键词进行提取，问题的关键词就是需要提取的槽位，上面一个例子，感冒就是槽位。

在介绍简单的概念后，正式开始今天的知识。主要步骤就是：构建图谱、分析问题类型（分类）、提取槽位、查询图谱。

一、构建图谱

初始化与neo4j的连接

def __init__(self):cur_dir = '\\'.join(os.path.abspath(__file__).split('\\')[:-1])   # 获取当前绝对路径的上层目录 linux中应用'/'split和joinself.data_path = os.path.join(cur_dir, 'data\hepatopathy.json')   # 获取json文件路径self.g = Graph(host="localhost",  # neo4j 搭载服务器的ip地址，ifconfig可获取到http_port=7474,  # neo4j 服务器监听的端口号user="neo4j",  # 数据库user name，如果没有更改过，应该是neo4jpassword="neo4jneo4j")

读取数据文件

'''读取文件'''def read_nodes(self):# 共７类节点drugs = [] # 药品foods = [] #　食物checks = [] # 检查departments = [] #科室producers = [] #药品大类diseases = [] #疾病symptoms = []#症状disease_infos = []#疾病信息# 构建节点实体关系 共11类rels_department = [] #　科室－科室关系（属于）rels_noteat = [] # 疾病－忌吃食物关系rels_doeat = [] # 疾病－宜吃食物关系rels_recommandeat = [] # 疾病－推荐吃食物关系rels_commonddrug = [] # 疾病－通用（常用）药品关系rels_recommanddrug = [] # 疾病－热门（推荐）药品关系rels_check = [] # 疾病－检查关系rels_drug_producer = [] # 厂商－药物关系rels_symptom = [] #疾病症状关系rels_acompany = [] # 疾病并发关系rels_category = [] #　疾病与科室之间的关系count = 0for data in open(self.data_path,encoding='utf-8'):   # 逐行读取disease_dict = {}count += 1print(count)data_json = json.loads(data)disease = data_json['name']disease_dict['name'] = diseasediseases.append(disease)disease_dict['desc'] = ''disease_dict['prevent'] = ''disease_dict['cause'] = ''disease_dict['easy_get'] = ''disease_dict['cure_department'] = ''disease_dict['cure_way'] = ''disease_dict['cure_lasttime'] = ''disease_dict['symptom'] = ''disease_dict['cured_prob'] = ''if 'symptom' in data_json:symptoms += data_json['symptom']     # +号用于组合列表for symptom in data_json['symptom']:            # 对于每个症状都建立一个疾病——症状的关系rels_symptom.append([disease, symptom])if 'acompany' in data_json:for acompany in data_json['acompany']:rels_acompany.append([disease, acompany])if 'desc' in data_json:disease_dict['desc'] = data_json['desc']if 'prevent' in data_json:disease_dict['prevent'] = data_json['prevent']if 'cause' in data_json:disease_dict['cause'] = data_json['cause']if 'get_prob' in data_json:disease_dict['get_prob'] = data_json['get_prob']if 'get_way' in data_json:disease_dict['get_way'] = data_json['get_way']else:disease_dict['get_way'] = '不知'if 'easy_get' in data_json:disease_dict['easy_get'] = data_json['easy_get']if 'can_eat' in data_json:disease_dict['can_eat'] = data_json['can_eat']# else:#     disease_dict['can_eat'] = '不知'if 'cure_department' in data_json:cure_department = data_json['cure_department']if len(cure_department) == 1:rels_category.append([disease, cure_department[0]])if len(cure_department) == 2:big = cure_department[0]small = cure_department[1]rels_department.append([small, big])      # 提取科室——科室关系rels_category.append([disease, small])disease_dict['cure_department'] = cure_departmentdepartments += cure_departmentif 'cure_way' in data_json:disease_dict['cure_way'] = data_json['cure_way']if  'cure_lasttime' in data_json:disease_dict['cure_lasttime'] = data_json['cure_lasttime']if 'cured_prob' in data_json:disease_dict['cured_prob'] = data_json['cured_prob']if 'common_drug' in data_json:common_drug = data_json['common_drug']for drug in common_drug:rels_commonddrug.append([disease, drug])drugs += common_drugif 'recommand_drug' in data_json:recommand_drug = data_json['recommand_drug']drugs += recommand_drugfor drug in recommand_drug:rels_recommanddrug.append([disease, drug])if 'not_eat' in data_json:not_eat = data_json['not_eat']for _not in not_eat:rels_noteat.append([disease, _not])foods += not_eatif 'do_eat' in data_json:do_eat = data_json['do_eat']for _do in do_eat:rels_doeat.append([disease, _do])foods += do_eatif 'recommand_eat' in data_json:recommand_eat = data_json['recommand_eat']for _recommand in recommand_eat:rels_recommandeat.append([disease, _recommand])foods += recommand_eatif 'check' in data_json:check = data_json['check']for _check in check:rels_check.append([disease, _check])checks += checkif 'drug_detail' in data_json:drug_detail = data_json['drug_detail']producer = [i.split('(')[0] for i in drug_detail]rels_drug_producer += [[i.split('(')[0], i.split('(')[-1].replace(')', '')] for i in drug_detail]producers += producerdisease_infos.append(disease_dict)return set(drugs), set(foods), set(checks), set(departments), set(producers), set(symptoms), set(diseases), disease_infos,\rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug,\rels_symptom, rels_acompany, rels_category

最后得到的就是，所有的实体，以及数据库关系而形成的实体间关系。这些字典数据将用于构建知识图谱。

set(drugs), set(foods), set(checks), set(departments), set(producers), set(symptoms), set(diseases), disease_infos,\rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug,\rels_symptom, rels_acompany, rels_category

建立节点、节点边的两个函数

'''创建知识图谱实体节点类型schema'''def create_graphnodes(self):Drugs, Foods, Checks, Departments, Producers, Symptoms, Diseases, disease_infos,rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug,rels_symptom, rels_acompany, rels_category = self.read_nodes()self.create_diseases_nodes(disease_infos)self.create_node('Drug', Drugs)print(len(Drugs))self.create_node('Food', Foods)print(len(Foods))self.create_node('Check', Checks)print(len(Checks))self.create_node('Department', Departments)print(len(Departments))self.create_node('Producer', Producers)print(len(Producers))self.create_node('Symptom', Symptoms)return'''创建实体关系边'''def create_graphrels(self):Drugs, Foods, Checks, Departments, Producers, Symptoms, Diseases, disease_infos, rels_check, rels_recommandeat, rels_noteat, rels_doeat, rels_department, rels_commonddrug, rels_drug_producer, rels_recommanddrug,rels_symptom, rels_acompany, rels_category = self.read_nodes()self.create_relationship('Disease', 'Food', rels_recommandeat, 'recommand_eat', '推荐食谱')self.create_relationship('Disease', 'Food', rels_noteat, 'no_eat', '忌吃')self.create_relationship('Disease', 'Food', rels_doeat, 'do_eat', '宜吃')self.create_relationship('Department', 'Department', rels_department, 'belongs_to', '属于')self.create_relationship('Disease', 'Drug', rels_commonddrug, 'common_drug', '常用药品')self.create_relationship('Producer', 'Drug', rels_drug_producer, 'drugs_of', '生产药品')self.create_relationship('Disease', 'Drug', rels_recommanddrug, 'recommand_drug', '好评药品')self.create_relationship('Disease', 'Check', rels_check, 'need_check', '诊断检查')self.create_relationship('Disease', 'Symptom', rels_symptom, 'has_symptom', '症状')self.create_relationship('Disease', 'Disease', rels_acompany, 'acompany_with', '并发症')self.create_relationship('Disease', 'Department', rels_category, 'belongs_to', '所属科室')

其中涉及创建节点方法，通过py建立知识图谱。这里采用Node定义节点、create在neo4j中创建。——直接用Node创建

'''建立节点'''def create_node(self, label, nodes):count = 0for node_name in nodes:node = Node(label, name=node_name)self.g.create(node)count += 1print(label, count, len(nodes))return'''创建知识图谱中心疾病的节点'''def create_diseases_nodes(self, disease_infos):count = 0for disease_dict in disease_infos:node = Node("Disease", name=disease_dict['name'], desc=disease_dict['desc'],prevent=disease_dict['prevent'] ,cause=disease_dict['cause'],get_way=disease_dict['get_way'] , easy_get=disease_dict['easy_get'],cure_lasttime=disease_dict['cure_lasttime'],cure_department=disease_dict['cure_department'],cure_way=disease_dict['cure_way'] , cured_prob=disease_dict['cured_prob'])self.g.create(node)count += 1print(count)return

创建边的方法，通过query方法，首先"match(p:%s),(q:%s) where p.name='%s' and q.name='%s'匹配到两边节点，然后create (p)-[rel:%s{name:'%s'}]->(q)"创建边。——采用run query的方法创建。

    '''创建实体关联边'''def create_relationship(self, start_node, end_node, edges, rel_type, rel_name):count = 0# 去重处理set_edges = []for edge in edges:set_edges.append('###'.join(edge))# print(set_edges)all = len(set(set_edges))for edge in set(set_edges):edge = edge.split('###')p = edge[0]q = edge[1]query = "match(p:%s),(q:%s) where p.name='%s'and q.name='%s' create (p)-[rel:%s{name:'%s'}]->(q)" % (start_node, end_node, p, q, rel_type, rel_name)try:self.g.run(query)count += 1print(rel_type, count, all)except Exception as e:print(e)return

if __name__ == '__main__':handler = MedicalGraph()handler.create_graphnodes()handler.create_graphrels()

二、问题分类+槽位提取

就是对输入的文字判断其问题类型是什么。同时会提取对应实体的名称，也就是槽位。

步骤 1：输入文字，判断实体

步骤 2：判断意图，问题分类

步骤 3：组装json，送给search

步骤1：输入文字，判断实体

'''分类主函数'''def classify(self, question):data = {}medical_dict = self.check_medical(question)if not medical_dict:if 'diseases_dict' in globals():    # 判断是否是首次提问，若首次提问，则diseases_dict无值medical_dict = diseases_dictelse:return {}print("medical_dict : ", medical_dict)data['args'] = medical_dict#收集问句当中所涉及到的实体类型types = []for type_ in medical_dict.values():types += type_# print(types)question_types = []# 症状if self.check_words(self.symptom_qwds, question) and ('disease' in types):question_type = 'disease_symptom'question_types.append(question_type)if self.check_words(self.symptom_qwds, question) and ('symptom' in types):question_type = 'symptom_disease'question_types.append(question_type)# 原因if self.check_words(self.cause_qwds, question) and ('disease' in types):question_type = 'disease_cause'question_types.append(question_type)# 并发症if self.check_words(self.acompany_qwds, question) and ('disease' in types):question_type = 'disease_acompany'question_types.append(question_type)# 推荐食品if self.check_words(self.food_qwds, question) and 'disease' in types:deny_status = self.check_words(self.deny_words, question)if deny_status:question_type = 'disease_not_food'else:question_type = 'disease_do_food'if self.check_words(['能吃','能喝','可以吃','可以喝'], question):question_types.append('disease_can_eat')print(question_type)question_types.append(question_type)#已知食物找疾病if self.check_words(self.food_qwds+self.cure_qwds, question) and 'food' in types and 'disease' not in types:deny_status = self.check_words(self.deny_words, question)if deny_status:question_type = 'food_not_disease'else:question_type = 'food_do_disease'question_types.append(question_type)# 推荐药品if self.check_words(self.drug_qwds, question) and 'disease' in types:question_type = 'disease_drug'question_types.append(question_type)# 药品治啥病if self.check_words(self.cure_qwds, question) and 'drug' in types:question_type = 'drug_disease'question_types.append(question_type)# 疾病接受检查项目if self.check_words(self.check_qwds, question) and 'disease' in types:question_type = 'disease_check'question_types.append(question_type)# 已知检查项目查相应疾病if self.check_words(self.check_qwds+self.cure_qwds, question) and 'check' in types:question_type = 'check_disease'question_types.append(question_type)#　症状防御if self.check_words(self.prevent_qwds, question) and 'disease' in types:question_type = 'disease_prevent'question_types.append(question_type)# 疾病医疗周期if self.check_words(self.lasttime_qwds, question) and 'disease' in types:question_type = 'disease_lasttime'question_types.append(question_type)# 疾病治疗方式if self.check_words(self.cureway_qwds, question) and 'disease' in types:question_type = 'disease_cureway'question_types.append(question_type)# 疾病治愈可能性if self.check_words(self.cureprob_qwds, question) and 'disease' in types:question_type = 'disease_cureprob'question_types.append(question_type)# 疾病易感染人群if self.check_words(self.easyget_qwds, question) and 'disease' in types :question_type = 'disease_easyget'question_types.append(question_type)# 疾病传染性if self.check_words(self.getway_qwds, question) and 'disease' in types:question_type = 'disease_getway'question_types.append(question_type)# 若没有查到相关的外部查询信息，且类型为疾病，那么则将该疾病的描述信息返回if question_types == [] and 'disease' in types:question_types = ['disease_desc']# 若没有查到相关的外部查询信息，且类型为症状，那么则将该症状的疾病信息返回if question_types == [] and 'symptom' in types:question_types = ['symptom_disease']# 将多个分类结果进行合并处理，组装成一个字典data['question_types'] = question_typesreturn data

这里用到一个关键的问句过滤。本质上要做的是实体识别，这里直接采用知识的做法，而不是学习的方法。

知识的做法是，结合大量的实体知识文本、逐个去做匹配，得到对应实体，顺便完成了槽位提取。

学习的方法是，提前训练好一个CRF系列的实体识别网络，直接输出实体的句中位置，也就完成了槽位的提取。
    '''问句过滤'''def check_medical(self, question):region_wds = []for i in self.region_tree.iter(question):   # ahocorasick库 匹配问题  iter返回一个元组，i的形式如(3, (23192, '乙肝'))wd = i[1][1]      # 匹配到的词region_wds.append(wd)print(region_wds)stop_wds = []for wd1 in region_wds:for wd2 in region_wds:if wd1 in wd2 and wd1 != wd2:stop_wds.append(wd1)       # stop_wds取重复的短的词，如region_wds=['乙肝', '肝硬化', '硬化']，则stop_wds=['硬化']final_wds = [i for i in region_wds if i not in stop_wds]     # final_wds取长词final_dict = {i:self.wdtype_dict.get(i) for i in final_wds}  # 获取词和词所对应的实体类型global diseases_dictif final_dict:diseases_dict = final_dictprint("final_dict : ",final_dict)if 'diseases_dict' in globals():print("diseases_dict : ",diseases_dict)else:print("diseases_dict does not exist.")return final_dict
关键点有3个：

1. region_tree提前把实体知识读取，构建加速树，形成(word，（index，word）)
# 构造领域actree
self.region_tree = self.build_actree(list(self.region_words))'''构造actree，加速过滤'''
def build_actree(self, wordlist):actree = ahocorasick.Automaton()         # 初始化trie树for index, word in enumerate(wordlist):actree.add_word(word, (index, word))     # 向trie树中添加单词actree.make_automaton()    # 将trie树转化为Aho-Corasick自动机return actree
2. 提取槽位实体。在匹配到词后，需要进行长短同义词辨识去重（肝硬化、硬化就是长短同义词，会被重复识别，需要去重）

stop_wds取重复的短的词，如region_wds=['乙肝', '肝硬化', '硬化']，则stop_wds=['硬化']，这可以实现 '肝硬化', '硬化' 取一个
stop_wds = []
for wd1 in region_wds:for wd2 in region_wds:if wd1 in wd2 and wd1 != wd2:stop_wds.append(wd1)       # stop_wds取重复的短的词，如region_wds=['乙肝', '肝硬化', '硬化']，则stop_wds=['硬化']
final_wds = [i for i in region_wds if i not in stop_wds]     # final_wds取长词
3. 对槽位实体进行归类，用于获取《槽位实体》词和词对应的实体类型
final_dict = {i:self.wdtype_dict.get(i) for i in final_wds}  # 获取词和词所对应的实体类型'''构造词对应的类型'''def build_wdtype_dict(self):wd_dict = dict()for wd in self.region_words:wd_dict[wd] = []if wd in self.disease_wds:wd_dict[wd].append('disease')if wd in self.department_wds:wd_dict[wd].append('department')if wd in self.check_wds:wd_dict[wd].append('check')if wd in self.drug_wds:wd_dict[wd].append('drug')if wd in self.food_wds:wd_dict[wd].append('food')if wd in self.symptom_wds:wd_dict[wd].append('symptom')if wd in self.producer_wds:wd_dict[wd].append('producer')return wd_dict
4. 上下文模式，记录上轮对话的槽位实体global disease_dict
global diseases_dict
if final_dict:diseases_dict = final_dict
print("final_dict : ",final_dict)
if 'diseases_dict' in globals():print("diseases_dict : ",diseases_dict)
else:print("diseases_dict does not exist.")
return final_dict        
最后就是得到了final_dict，就是需要的实体

步骤 2：判断意图，问题分类

        medical_dict = self.check_medical(question)if not medical_dict:if 'diseases_dict' in globals():    # 判断是否是首次提问，若首次提问，则diseases_dict无值medical_dict = diseases_dictelse:return {}print("medical_dict : ", medical_dict)data['args'] = medical_dict#收集问句当中所涉及到的实体类型types = []for type_ in medical_dict.values():types += type_

提取的槽位就是medical_dict，根据该实体/实体类型，得到对应的问题予语义是什么意思，就是问题分类。以

# 推荐食品
if self.check_words(self.food_qwds, question) and 'disease' in types:
deny_status = self.check_words(self.deny_words, question)
if deny_status:
question_type = 'disease_not_food'
else:
question_type = 'disease_do_food'
if self.check_words(['能吃','能喝','可以吃','可以喝'], question):
question_types.append('disease_can_eat')
print(question_type)
question_types.append(question_type)

为例。分析问题类型，通过正则表达式匹配的思路，判断问句疑问词是否出现，对应到哪个问题类型。

        # 问句疑问词self.symptom_qwds = ['症状', '表征', '现象', '症候', '表现', '会引起']self.cause_qwds = ['原因','成因', '病因', '为什么', '怎么会', '怎样才', '咋样才', '怎样会', '如何会', '为啥', '为何', '如何才会', '怎么才会', '会导致', '会造成']self.acompany_qwds = ['并发症', '并发', '一起发生', '一并发生', '一起出现', '一并出现', '一同发生', '一同出现', '伴随发生', '伴随', '共现', '引起','有关']self.food_qwds = ['饮食', '饮用', '吃', '食', '伙食', '膳食', '喝', '菜' ,'忌口', '补品', '保健品', '食谱', '菜谱', '食用', '食物','补品']self.drug_qwds = ['吃','药', '药品', '用药', '胶囊', '口服液', '炎片']self.prevent_qwds = ['预防', '防范', '抵制', '抵御', '防止','躲避','逃避','避开','免得','逃开','避开','避掉','躲开','躲掉','绕开','怎样才能不', '怎么才能不', '咋样才能不','咋才能不', '如何才能不','怎样才不', '怎么才不', '咋样才不','咋才不', '如何才不','怎样才可以不', '怎么才可以不', '咋样才可以不', '咋才可以不', '如何可以不','怎样才可不', '怎么才可不', '咋样才可不', '咋才可不', '如何可不','日常','护理']self.lasttime_qwds = ['周期', '多久', '多长时间', '多少时间', '几天', '几年', '多少天', '多少小时', '几个小时', '多少年']self.cureway_qwds = ['怎么治疗', '如何医治', '怎么医治', '怎么治', '怎么医', '如何治', '医治方式', '疗法', '咋治', '怎么办', '咋办', '咋治']self.cureprob_qwds = ['多大概率能治好', '多大几率能治好', '治好希望大么', '几率', '几成', '比例', '可能性', '能治', '可治', '可以治', '可以医']self.getway_qwds = ['传染']self.easyget_qwds = ['易感人群', '容易感染', '易发人群', '什么人', '哪些人', '感染', '染上', '得上']self.check_qwds = ['检查', '检查项目', '查出', '检查', '测出', '试出']self.belong_qwds = ['属于什么科', '属于', '什么科', '科室']self.cure_qwds = ['治疗什么', '治啥', '治疗啥', '医治啥', '治愈啥', '主治啥', '主治什么', '有什么用', '有何用', '用处', '用途','有什么好处', '有什么益处', '有何益处', '用来', '用来做啥', '用来作甚', '需要', '要','可以治']print('model init finished ......')

步骤 3：组装json，送给search

data['args'] = medical_dict# 将多个分类结果进行合并处理，组装成一个字典
data['question_types'] = question_types

data数据中包含args和question_types。如“乙肝怎么治疗”，得到的data如下：

{'args': {'乙肝': ['disease']}, 'question_types': ['disease_cureway']}

三、查询图谱

提取data中的args、question_type，创建cypher语句，用于查询图谱，得到的是一个sqls的JSON格式。包含questoin_type、sql，如下，

[{'question_type': 'disease_cureway', 'sql': ["MATCH (m:Disease) where m.name = '乙肝' return m.name, m.cure_way"]}]

    '''解析主函数'''def parser_main(self, res_classify):args = res_classify['args']entity_dict = self.build_entitydict(args)question_types = res_classify['question_types']sqls = []for question_type in question_types:sql_ = {}sql_['question_type'] = question_typesql = []if question_type == 'disease_symptom':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'symptom_disease':sql = self.sql_transfer(question_type, entity_dict.get('symptom'))elif question_type == 'disease_cause':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_acompany':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_can_eat':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_not_food':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_do_food':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'food_not_disease':sql = self.sql_transfer(question_type, entity_dict.get('food'))elif question_type == 'food_do_disease':sql = self.sql_transfer(question_type, entity_dict.get('food'))elif question_type == 'disease_drug':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'drug_disease':sql = self.sql_transfer(question_type, entity_dict.get('drug'))elif question_type == 'disease_check':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'check_disease':sql = self.sql_transfer(question_type, entity_dict.get('check'))elif question_type == 'disease_prevent':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_lasttime':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_cureway':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_cureprob':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_getway':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_easyget':sql = self.sql_transfer(question_type, entity_dict.get('disease'))elif question_type == 'disease_desc':sql = self.sql_transfer(question_type, entity_dict.get('disease'))if sql:sql_['sql'] = sqlsqls.append(sql_)return sqls'''针对不同的问题，分开进行处理'''def sql_transfer(self, question_type, entities):if not entities:return []# 查询语句sql = []# 查询疾病的原因if question_type == 'disease_cause':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.cause".format(i) for i in entities]# 查询疾病的防御措施elif question_type == 'disease_prevent':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.prevent".format(i) for i in entities]# 查询疾病的持续时间elif question_type == 'disease_lasttime':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.cure_lasttime".format(i) for i in entities]# 查询疾病的治愈概率elif question_type == 'disease_cureprob':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.cured_prob".format(i) for i in entities]# 查询疾病的治疗方式elif question_type == 'disease_cureway':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.cure_way".format(i) for i in entities]# 查询疾病传染性elif question_type == 'disease_getway':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.get_way".format(i) for i in entities]# 查询疾病的易发人群elif question_type == 'disease_easyget':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.easy_get".format(i) for i in entities]# 查询疾病的相关介绍elif question_type == 'disease_desc':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.desc".format(i) for i in entities]# 查询疾病有哪些症状elif question_type == 'disease_symptom':sql = ["MATCH (m:Disease)-[r:has_symptom]->(n:Symptom) where m.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]# 查询症状会导致哪些疾病elif question_type == 'symptom_disease':sql = ["MATCH (m:Disease)-[r:has_symptom]->(n:Symptom) where n.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]# 查询疾病的并发症elif question_type == 'disease_acompany':sql1 = ["MATCH (m:Disease)-[r:acompany_with]->(n:Disease) where m.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql2 = ["MATCH (m:Disease)-[r:acompany_with]->(n:Disease) where n.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql = sql1 + sql2# 查询疾病是否可以吃某种食物：elif question_type == 'disease_can_eat':sql = ["MATCH (m:Disease) where m.name = '{0}' return m.name, m.can_eat".format(i) for i in entities]# 查询疾病的忌口elif question_type == 'disease_not_food':sql = ["MATCH (m:Disease)-[r:no_eat]->(n:Food) where m.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]# 查询疾病建议吃的东西elif question_type == 'disease_do_food':sql1 = ["MATCH (m:Disease)-[r:do_eat]->(n:Food) where m.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql2 = ["MATCH (m:Disease)-[r:recommand_eat]->(n:Food) where m.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql = sql1 + sql2# 已知忌口查疾病elif question_type == 'food_not_disease':sql = ["MATCH (m:Disease)-[r:no_eat]->(n:Food) where n.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]# 已知推荐查疾病elif question_type == 'food_do_disease':sql1 = ["MATCH (m:Disease)-[r:do_eat]->(n:Food) where n.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql2 = ["MATCH (m:Disease)-[r:recommand_eat]->(n:Food) where n.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql = sql1 + sql2# 查询疾病常用药品－药品别名记得扩充elif question_type == 'disease_drug':sql1 = ["MATCH (m:Disease)-[r:common_drug]->(n:Drug) where m.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql2 = ["MATCH (m:Disease)-[r:recommand_drug]->(n:Drug) where m.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql = sql1 + sql2# 已知药品查询能够治疗的疾病elif question_type == 'drug_disease':sql1 = ["MATCH (m:Disease)-[r:common_drug]->(n:Drug) where n.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql2 = ["MATCH (m:Disease)-[r:recommand_drug]->(n:Drug) where n.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]sql = sql1 + sql2# 查询疾病应该进行的检查elif question_type == 'disease_check':sql = ["MATCH (m:Disease)-[r:need_check]->(n:Check) where m.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]# 已知检查查询疾病elif question_type == 'check_disease':sql = ["MATCH (m:Disease)-[r:need_check]->(n:Check) where n.name = '{0}' return m.name, r.name, n.name".format(i) for i in entities]print(sql)return sql

四、拼装答复

查询语句执行后，对返回的结果进行拼装为答复结果。

'''执行cypher查询，并返回相应结果'''def search_main(self, sqls):final_answers = []for sql_ in sqls:question_type = sql_['question_type']queries = sql_['sql']answers = []for query in queries:ress = self.g.run(query).data()answers += ressfinal_answer = self.answer_prettify(question_type, answers)if final_answer:final_answers.append(final_answer)return final_answers

其中根据question_type和查到的结果answer，调用回复模板，组装构成回复结果

    '''根据对应的qustion_type，调用相应的回复模板'''def answer_prettify(self, question_type, answers):final_answer = []if not answers:return ''if question_type == 'disease_symptom':desc = [i['n.name'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}的症状包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'symptom_disease':desc = [i['m.name'] for i in answers]subject = answers[0]['n.name']final_answer = '症状{0}可能染上的疾病有：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_cause':desc = [i['m.cause'] for i in answers]print(answers)print(desc)subject = answers[0]['m.name']final_answer = '{0}可能的成因有：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_prevent':desc = [i['m.prevent'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}的预防措施包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_lasttime':desc = [i['m.cure_lasttime'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}治疗可能持续的周期为：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_cureway':desc = [';'.join(i['m.cure_way']) for i in answers]subject = answers[0]['m.name']final_answer = '{0}可以尝试如下治疗：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_cureprob':desc = [i['m.cured_prob'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}治愈的概率为（仅供参考）：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_getway':desc = [i['m.get_way'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}的传播方式为：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_easyget':desc = [i['m.easy_get'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}的易感人群包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_desc':desc = [i['m.desc'] for i in answers]subject = answers[0]['m.name']final_answer = '{0},熟悉一下：{1}'.format(subject,  '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_acompany':desc1 = [i['n.name'] for i in answers]desc2 = [i['m.name'] for i in answers]subject = answers[0]['m.name']desc = [i for i in desc1 + desc2 if i != subject]final_answer = '{0}的并发症包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_can_eat':desc = [answers[0]['m.can_eat']]print(answers)print(desc)subject = answers[0]['m.name']print(subject)if desc:final_answer = '{0}可以吃/喝：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_not_food':desc = [i['n.name'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}忌食的食物包括有：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_do_food':do_desc = [i['n.name'] for i in answers if i['r.name'] == '宜吃']recommand_desc = [i['n.name'] for i in answers if i['r.name'] == '推荐食谱']subject = answers[0]['m.name']final_answer = '{0}推荐{1}\n推荐食谱包括有：{2}'.format(subject, ';'.join(list(set(do_desc))[:self.num_limit]), ';'.join(list(set(recommand_desc))[:self.num_limit]))elif question_type == 'food_not_disease':desc = [i['m.name'] for i in answers]subject = answers[0]['n.name']final_answer = '患有{0}的人最好不要吃{1}'.format('；'.join(list(set(desc))[:self.num_limit]), subject)elif question_type == 'food_do_disease':desc = [i['m.name'] for i in answers]subject = answers[0]['n.name']final_answer = '患有{0}的人建议多试试{1}'.format('；'.join(list(set(desc))[:self.num_limit]), subject)elif question_type == 'disease_drug':desc = [i['n.name'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}通常的使用的药品包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'drug_disease':desc = [i['m.name'] for i in answers]subject = answers[0]['n.name']final_answer = '{0}主治的疾病有{1},可以试试'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'disease_check':desc = [i['n.name'] for i in answers]subject = answers[0]['m.name']final_answer = '{0}通常可以通过以下方式检查出来：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))elif question_type == 'check_disease':desc = [i['m.name'] for i in answers]subject = answers[0]['n.name']final_answer = '通常可以通过{0}检查出来的疾病有{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))print("final_answer: ",final_answer)return final_answer

至此就结束了，最后来看一下等待始终执行的主函数。

from question_classifier import *
from question_parser import *
from answer_search import *'''问答类'''
class ChatBotGraph:def __init__(self):self.classifier = QuestionClassifier()self.parser = QuestionPaser()self.searcher = AnswerSearcher()def chat_main(self, sent):answer = '您好，我是肝病问答小助手，希望可以帮到您。祝您身体健康！'res_classify = self.classifier.classify(sent)print(res_classify)if not res_classify:return '抱歉，小助手暂时无法回答您的问题，请咨询医生。'res_sql = self.parser.parser_main(res_classify)final_answers = self.searcher.search_main(res_sql)if not final_answers:return answerelse:return '\n'.join(final_answers)if __name__ == '__main__':handler = ChatBotGraph()while 1:question = input('用户:')answer = handler.chat_main(question)print('小助手:', answer)

五、总结

知识图谱问答，最重要的就是判断问题类型、提取实体槽位，主要用到规则 + 学习两种方法。

意图识别：学习——采用文本分类，规则——问题类型关键词匹配

槽位提取：学习——采用CRF识别，规则——预置实体知识库匹配