代码改变世界

医疗知识图谱问答——文本分类解析

  北桥苏  阅读(107)  评论(0编辑  收藏  举报

前言

        Neo4j的数据库构建完成后,现在就是要实现医疗知识的解答功能了。因为是初版,这里的问题解答不会涉及深度学习,目前只是一个条件查询的过程。而这个过程包括对问题的关键词拆解分类,然后提取词语和类型去图数据库查询,最后就是根据查询结果和问题类型组装语言完成回答,那么以下就是完成这个过程的全部代码流程了。

 

环境

        这里所需的环境除了前面提到的外,还需要ahocorasick库,用于从问题中提取关键词。另一个是colorama,用于给输出面板文字美化的库。

 

编码

1. 问答面板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
from colorama import init,Fore,Style,Back
from classifier import Classifier
from parse import Parse
from answer import Answer
 
class ChatRobot:
    def __init__(self):
        init(autoreset=True)
        print("====================================")
        print(Back.BLUE+"欢迎进入智慧医疗问答面板!")
        print("====================================")
 
    def main(self, question):
        print("")
 
        default_answer = "您好,小北知识有限,暂时回答不上来,正在努力迭代中!"
        final_classify = Classifier().classify(question)
        parse_sql = Parse().main(final_classify)
        final_answer = Answer().main(parse_sql)
 
        if not final_answer:
            return default_answer
 
        return "\n\n".join(final_answer)
 
if __name__ == "__main__":
    robot = ChatRobot()
    while 1:
        print(" ")
        question = input("您问:")
 
        if "关闭" in question:
            print("")
            print("小北说:", "好的,已经关闭了哦,欢迎您下次提问~")
            break;
 
        answer = robot.main(question)
 
        print(Fore.LIGHTRED_EX+"小北答:", Fore.GREEN + answer)

2. 问题归类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
import ahocorasick
 
class Classifier:
    def __init__(self):
        # print("开始初始化:", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
        self.checks_wds = [i.strip() for i in open("dict/checks.txt", encoding="utf-8", mode="r") if i.strip()]
        self.departments_wds = [i.strip() for i in open("dict/departments.txt", encoding="utf-8", mode="r") if i.strip()]
        self.diseases_wds = [i.strip() for i in open("dict/diseases.txt", encoding="utf-8", mode="r") if i.strip()]
        self.drugs_wds = [i.strip() for i in open("dict/drugs.txt", encoding="utf-8", mode="r") if i.strip()]
        self.foods_wds = [i.strip() for i in open("dict/foods.txt", encoding="utf-8", mode="r") if i.strip()]
        self.producers_wds = [i.strip() for i in open("dict/producers.txt", encoding="utf-8", mode="r") if i.strip()]
        self.symptoms_wds = [i.strip() for i in open("dict/symptoms.txt", encoding="utf-8", mode="r") if i.strip()]
        self.features_wds = set(self.checks_wds+self.departments_wds+self.diseases_wds+self.drugs_wds+self.foods_wds+self.producers_wds+self.symptoms_wds)
        self.deny_words = [name.strip() for name in open("dict/deny.txt", encoding="utf-8", mode="r") if name.strip()]
 
        # actree 从输入文本中提取出指定分词表中的词
        self.actree = self.build_actree(list(self.features_wds))
 
        # 给每个词创建类型词典(相当慢的操作)
        self.wds_dict = self.build_words_dict()
        # print("给每个词创建类型词典结束:", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
 
        # 问句疑问词
        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.easyget_qwds = ['易感人群', '容易感染', '易发人群', '什么人', '哪些人', '感染', '染上', '得上']
        self.check_qwds = ['检查', '检查项目', '查出', '检查', '测出', '试出']
        self.belong_qwds = ['属于什么科', '属于', '什么科', '科室']
        self.cure_qwds = ['治疗什么', '治啥', '治疗啥', '医治啥', '治愈啥', '主治啥', '主治什么', '有什么用', '有何用', '用处', '用途',
                          '有什么好处', '有什么益处', '有何益处', '用来', '用来做啥', '用来作甚', '需要', '要']
 
    '''构造actree,加速过滤'''
    def build_actree(self, wordlist):
        actree = ahocorasick.Automaton()
        for index, word in enumerate(wordlist):
            actree.add_word(word, (index, word))
        actree.make_automaton()
        return actree
 
    # 构建特征词属性
    def build_words_dict(self):
        words_dict = {}
        check_words = set(self.checks_wds)
        department_words = set(self.departments_wds)
        disease_words = set(self.diseases_wds)
        drug_words = set(self.drugs_wds)
        food_words = set(self.foods_wds)
        producer_words = set(self.producers_wds)
        symptom_words = set(self.symptoms_wds)
 
        for word in self.features_wds:
            words_dict[word] = []
            if word in check_words:
                words_dict[word].append("check")
            if word in department_words:
                words_dict[word].append("department")
            if word in disease_words:
                words_dict[word].append("disease")
            if word in drug_words:
                words_dict[word].append("drug")
            if word in food_words:
                words_dict[word].append("food")
            if word in producer_words:
                words_dict[word].append("producer")
            if word in symptom_words:
                words_dict[word].append("symptom")
 
        return words_dict
 
    # 根据输入返回问题类型
    def classify(self, sent):
        # 最终输入给解析器的字典
        data = {}
        region_words = []
        lists = self.actree.iter(sent)
        for ii in lists:
            cur_word = ii[1][1]
            region_words.append(cur_word)
 
        # {'职业黑变病': ['diseases'], '倒睫': ['diseases', 'symptom']}
        final_dict = {i_name: self.wds_dict.get(i_name) for i_name in region_words}
 
        data['args'] = final_dict
        question_type = "other"
        questions_type = []
 
        # ['diseases', 'diseases', 'symptom']
        type = []
        for i_type in final_dict.values():
            type += i_type
 
        # 判断type中是否有指定类型, 提出的问题是否包含指定的修饰词,给问题定类型
        # 1. 如提问词是否出现状态词语,那就是问某种疾病会出现什么症状
        if self.check_word_exist(self.symptom_qwds, sent) and ('disease' in type):
            question_type = "disease_symptom"
            questions_type.append(question_type)
 
        # 根据症状问疾病
        if self.check_word_exist(self.symptom_qwds, sent) and ('symptom' in type):
            question_type = "symptom_disease"
            questions_type.append(question_type)
 
        # 原因
        if self.check_word_exist(self.cause_qwds, sent) and ('disease' in type):
            question_type = 'disease_cause'
            questions_type.append(question_type)
 
        # 并发症
        if self.check_word_exist(self.acompany_qwds, sent) and ('disease' in type):
            question_type = 'disease_acompany'
            questions_type.append(question_type)
 
        # 推荐食品
        if self.check_word_exist(self.food_qwds, sent) and 'disease' in type:
            deny_status = self.check_word_exist(self.deny_words, sent)
            if deny_status:
                question_type = 'disease_not_food'
            else:
                question_type = 'disease_do_food'
            questions_type.append(question_type)
 
        # 已知食物找疾病
        if self.check_word_exist(self.food_qwds + self.cure_qwds, sent) and 'food' in type:
            deny_status = self.check_word_exist(self.deny_words, sent)
            if deny_status:
                question_type = 'food_not_disease'
            else:
                question_type = 'food_do_disease'
            questions_type.append(question_type)
 
        # 推荐药品
        if self.check_word_exist(self.drug_qwds, sent) and 'disease' in type:
            question_type = 'disease_drug'
            questions_type.append(question_type)
 
        # 药品治啥病
        if self.check_word_exist(self.cure_qwds, sent) and 'drug' in type:
            question_type = 'drug_disease'
            questions_type.append(question_type)
 
        # 疾病接受检查项目
        if self.check_word_exist(self.check_qwds, sent) and 'disease' in type:
            question_type = 'disease_check'
            questions_type.append(question_type)
 
        # 已知检查项目查相应疾病
        if self.check_word_exist(self.check_qwds + self.cure_qwds, sent) and 'check' in type:
            question_type = 'check_disease'
            questions_type.append(question_type)
 
        #  症状防御
        if self.check_word_exist(self.prevent_qwds, sent) and 'disease' in type:
            question_type = 'disease_prevent'
            questions_type.append(question_type)
 
        # 疾病医疗周期
        if self.check_word_exist(self.lasttime_qwds, sent) and 'disease' in type:
            question_type = 'disease_lasttime'
            questions_type.append(question_type)
 
        # 疾病治疗方式
        if self.check_word_exist(self.cureway_qwds, sent) and 'disease' in type:
            question_type = 'disease_cureway'
            questions_type.append(question_type)
 
        # 疾病治愈可能性
        if self.check_word_exist(self.cureprob_qwds, sent) and 'disease' in type:
            question_type = 'disease_cureprob'
            questions_type.append(question_type)
 
        # 疾病易感染人群
        if self.check_word_exist(self.easyget_qwds, sent) and 'disease' in type:
            question_type = 'disease_easyget'
            questions_type.append(question_type)
 
        # 若没有查到相关的外部查询信息,那么则将该疾病的描述信息返回
        if questions_type == [] and 'disease' in type:
            questions_type = ['disease_desc']
 
        # 若没有查到相关的外部查询信息,那么则将该疾病的描述信息返回
        if questions_type == [] and 'symptom' in type:
            questions_type = ['symptom_disease']
 
        # 将多个分类结果进行合并处理,组装成一个字典
        data['question_types'] = questions_type
 
        return data
 
    def check_word_exist(self, word_list, words):
        for item in word_list:
            if item in words:
                return True
 
        return False

3. 类型解析(查询组装)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
class Parse:
 
    def main(self, classify):
        entity = classify['args']
        questions_type = classify['question_types']
        entity_dict = self.entity_transform(entity)
 
        sqls = []
        for question in questions_type:
            sql_dict = {}
            sql_dict["qustion_type"] = question
            sql_dict["sql"] = []
            sql = []
            if question == 'disease_symptom':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'symptom_disease':
                sql = self.sql_transfer(question, entity_dict.get('symptom'))
 
            elif question == 'disease_cause':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'disease_acompany':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'disease_not_food':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'disease_do_food':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'food_not_disease':
                sql = self.sql_transfer(question, entity_dict.get('food'))
 
            elif question == 'food_do_disease':
                sql = self.sql_transfer(question, entity_dict.get('food'))
 
            elif question == 'disease_drug':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'drug_disease':
                sql = self.sql_transfer(question, entity_dict.get('drug'))
 
            elif question == 'disease_check':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'check_disease':
                sql = self.sql_transfer(question, entity_dict.get('check'))
 
            elif question == 'disease_prevent':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'disease_lasttime':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'disease_cureway':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'disease_cureprob':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'disease_easyget':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            elif question == 'disease_desc':
                sql = self.sql_transfer(question, entity_dict.get('disease'))
 
            if sql:
                sql_dict['sql'] = sql
 
                sqls.append(sql_dict)
 
        return sqls
 
    def sql_transfer(self, question_type, entities):
        # 查询语句
        sql = []
        # 查询疾病的原因
        if question_type == 'disease_cause':
            sql = ["MATCH (m:Diseases) where m.name = '{0}' return m.name, m.cause".format(i) for i in entities]
 
        # 查询疾病的防御措施
        elif question_type == 'disease_prevent':
            sql = ["MATCH (m:Diseases) where m.name = '{0}' return m.name, m.prevent".format(i) for i in entities]
 
        # 查询疾病的持续时间
        elif question_type == 'disease_lasttime':
            sql = ["MATCH (m:Diseases) where m.name = '{0}' return m.name, m.cure_lasttime".format(i) for i in entities]
 
        # 查询疾病的治愈概率
        elif question_type == 'disease_cureprob':
            sql = ["MATCH (m:Diseases) where m.name = '{0}' return m.name, m.cured_prob".format(i) for i in entities]
 
        # 查询疾病的治疗方式
        elif question_type == 'disease_cureway':
            sql = ["MATCH (m:Diseases) where m.name = '{0}' return m.name, m.cure_way".format(i) for i in entities]
 
        # 查询疾病的易发人群
        elif question_type == 'disease_easyget':
            sql = ["MATCH (m:Diseases) where m.name = '{0}' return m.name, m.easy_get".format(i) for i in entities]
 
        # 查询疾病的相关介绍
        elif question_type == 'disease_desc':
            sql = ["MATCH (m:Diseases) where m.name = '{0}' return m.name, m.desc".format(i) for i in entities]
 
        # 查询疾病有哪些症状
        elif question_type == 'disease_symptom':
            sql = [
                "MATCH (m:Diseases)-[r:has_symptoms]->(n:Symptoms) 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:Diseases)-[r:has_symptoms]->(n:Symptoms) 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:Diseases)-[r:acompany_with]->(n:Symptoms) where m.name = '{0}' return m.name, r.name, n.name".format(
                    i) for i in entities]
            sql2 = [
                "MATCH (m:Diseases)-[r:acompany_with]->(n:Symptoms) where n.name = '{0}' return m.name, r.name, n.name".format(
                    i) for i in entities]
            sql = sql1 + sql2
        # 查询疾病的忌口
        elif question_type == 'disease_not_food':
            sql = ["MATCH (m:Diseases)-[r:not_eat]->(n:Foods) 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:Diseases)-[r:do_eat]->(n:Foods) where m.name = '{0}' return m.name, r.name, n.name".format(i)
                for i in entities]
            sql2 = [
                "MATCH (m:Diseases)-[r:recomment_eat]->(n:Foods) 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:Diseases)-[r:not_eat]->(n:Foods) 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:Diseases)-[r:do_eat]->(n:Foods) where n.name = '{0}' return m.name, r.name, n.name".format(i)
                for i in entities]
            sql2 = [
                "MATCH (m:Diseases)-[r:recomment_eat]->(n:Foods) 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:Diseases)-[r:common_drug]->(n:Drugs) where m.name = '{0}' return m.name, r.name, n.name".format(
                    i) for i in entities]
            sql2 = [
                "MATCH (m:Diseases)-[r:recommand_drug]->(n:Drugs) 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:Diseases)-[r:common_drug]->(n:Drugs) where n.name = '{0}' return m.name, r.name, n.name".format(
                    i) for i in entities]
            sql2 = [
                "MATCH (m:Diseases)-[r:recommand_drug]->(n:Drugs) 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:Diseases)-[r:need_check]->(n:Checks) 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:Diseases)-[r:need_check]->(n:Checks) where n.name = '{0}' return m.name, r.name, n.name".format(
                    i) for i in entities]
 
        return sql
 
    def entity_transform(self, entity):
        entity_dict = {}
        for args, types in entity.items():
            for type in types:
                if type in entity_dict:
                    entity_dict[type] = [args]
                else:
                    entity_dict[type] = []
                    entity_dict[type].append(args)
        return entity_dict

4. 数据查询(回答组装)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
from py2neo import Graph, Node
 
class Answer:
    def __init__(self):
        self.neo4j = Graph('bolt://localhost:7687', auth=('neo4j', 'beiqiaosu123456'))
        self.num_limit = 20
 
    def main(self, question_parse):
        answers_final = []
        for item in question_parse:
            question_type = item['qustion_type']
            sqls = item['sql']
            answer = []
            for sql in sqls:
                data = self.neo4j.run(sql)
                answer+=data.data()
 
            final_answer = self.answer_prettify(question_type, answer)
            if final_answer:
                answers_final.append(final_answer)
 
        return answers_final
 
    '''根据对应的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]
            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_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_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]))
 
        return final_answer

 

写在最后

        以上就是这个医疗知识问答机器人的全部代码了,从上面的问答里也能看出,回答得还是很生硬。因为这就只是一个程序化得思维导图,所以修改完善空间还是很大,这个就要后期用深度学习得方式对分类解析部分进行改动。

 

相关博文:
阅读排行:
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· 上周热点回顾(2.17-2.23)
点击右上角即可分享
微信分享提示