[knowledge atlas] practice -- Practice of question and answer system based on medical knowledge atlas (Part5 end): information retrieval and result assembly

Preface article ：

1. 【 Knowledge map 】 Practice chapter —— Practice of question answering system based on medical knowledge map （Part1）： Project introduction and environmental preparation
2. 【 Knowledge map 】 Practice chapter —— Practice of question answering system based on medical knowledge map （Part2）： Atlas data preparation and import
3. 【 Knowledge map 】 Practice chapter —— Practice of question answering system based on medical knowledge map （Part3）： Rule based problem classification
4. 【 Knowledge map 】 Practice chapter —— Practice of question answering system based on medical knowledge map （Part4）： Problem analysis and retrieval statement generation combined with problem classification

background

In the previous modules, we have completed the problem classification 、 Problem analysis and the generation of information retrieval statements required by the problem . Now let's string these modules , Then assemble the results .

Result assembly

Result assembly is to output corresponding results according to different types of problems , The specific implementation is as follows ：

KGQAMedicine\answer_search\raw_answer_search.py

from utils.config import SysConfig
from py2neo import Graph


class RawAnswerSearcher(object):

    def __init__(self):
        self.graph = Graph(SysConfig.NEO4J_HOST + ":" + str(SysConfig.NEO4J_PORT), auth=(SysConfig.NEO4J_USER,
                                                                                         SysConfig.NEO4J_PASSWORD))
        self.num_limit = 20

    def search(self, sql_list: list):
        final_answers = []
        for sql in sql_list:
            question_kind = sql['question_kind']
            answers = []
            for query in sql['sql']:
                query_result = self.graph.run(query).data()
                answers += query_result
            final_answer = self._answer_standard(question_kind, answers)
            if final_answer:
                final_answers.append(final_answer)
        return final_answers

    def _answer_standard(self, question_kind, answers):
        final_answer = []
        if not answers:
            return ''
        if question_kind == 'disease_symptom':
            desc = [i['n.name'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} Symptoms include ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'symptom_disease':
            desc = [i['m.name'] for i in answers]
            subject = answers[0]['n.name']
            final_answer = ' symptoms {0} Possible diseases are ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_cause':
            desc = [i['m.cause'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} Possible causes are ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_prevent':
            desc = [i['m.prevent'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} Preventive measures include ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_lasttime':
            desc = [i['m.cure_lasttime'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} The possible duration of treatment is ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_cureway':
            desc = [';'.join(i['m.cure_way']) for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} Try the following treatment ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_cureprob':
            desc = [i['m.cured_prob'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} The probability of cure is （ For reference only ）：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_easyget':
            desc = [i['m.easy_get'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} The susceptible groups include ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_desc':
            desc = [i['m.desc'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0}, Be familiar with it. ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == '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} Symptoms include ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_not_food':
            desc = [i['n.name'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} Taboo foods include ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_do_food':
            do_desc = [i['n.name'] for i in answers if i['r.name'] == ' Suitable for eating ']
            recommand_desc = [i['n.name'] for i in answers if i['r.name'] == ' Recommended recipes ']
            subject = answers[0]['m.name']
            final_answer = '{0} Edible foods include ：{1}\n Recommended recipes include ：{2}'.format(subject, ';'.join(list(set(do_desc))[:self.num_limit]),
                                                                 ';'.join(list(set(recommand_desc))[:self.num_limit]))

        elif question_kind == 'food_not_disease':
            desc = [i['m.name'] for i in answers]
            subject = answers[0]['n.name']
            final_answer = ' suffer from {0} You'd better not eat it {1}'.format(';'.join(list(set(desc))[:self.num_limit]), subject)

        elif question_kind == 'food_do_disease':
            desc = [i['m.name'] for i in answers]
            subject = answers[0]['n.name']
            final_answer = ' suffer from {0} People suggest trying more {1}'.format(';'.join(list(set(desc))[:self.num_limit]), subject)

        elif question_kind == 'disease_drug':
            desc = [i['n.name'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} Commonly used drugs include ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'drug_disease':
            desc = [i['m.name'] for i in answers]
            subject = answers[0]['n.name']
            final_answer = '{0} The main diseases are {1}, You can try '.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'disease_check':
            desc = [i['n.name'] for i in answers]
            subject = answers[0]['m.name']
            final_answer = '{0} It can usually be checked in the following ways ：{1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        elif question_kind == 'check_disease':
            desc = [i['m.name'] for i in answers]
            subject = answers[0]['n.name']
            final_answer = ' Usually it can be done by {0} The diseases detected are {1}'.format(subject, ';'.join(list(set(desc))[:self.num_limit]))

        return final_answer

Module assembly and question and answer class construction

This module will pipline Assemble the modules in . As follows ：

KGQAMedicine\chatbot.py

from question_classify.rule_question_classify import RuleQuestionClassifier
from question_parser.rule_question_parser import RuleQuestionParser
from answer_search.raw_answer_search import RawAnswerSearcher


class ChatBot(object):

    def __init__(self):
        self.classifier = RuleQuestionClassifier()
        self.parser = RuleQuestionParser()
        self.answer_generate = RawAnswerSearcher()
        self.common_answer = " Hello! , I'm kopi Ziju's medical personal assistant , I hope I can answer for you . If the answer is not satisfactory , Can pass ：https://github.com/Htring  Contact me . I wish you good health , Stay away from me ！"

    def answer(self, question):
        question_classify = self.classifier.classify(question)
        if not question_classify:
            return self.common_answer
        res_sql = self.parser.parser(question_classify)
        final_answers = self.answer_generate.search(res_sql)
        if not final_answers:
            return self.common_answer
        else:
            return "\n".join(final_answers)


if __name__ == '__main__':
    chat_bot = ChatBot()
    while True:
        question = input(" user ：")
        answer = chat_bot.answer(question)
        print(" Coreopsis ：", answer)

Effect display ：

summary

In general , This project uses knowledge maps QA Some of the processes are introduced quite clearly , But in the process of completing the question and answer, the technology is relatively old , But the effect is still good . The source code has been put into my github On ：https://github.com/Htring/KGQAMedicine, If you are interested, you can download and run it , There is operation introduction on it .

In order to further improve the effect, many new technologies can be introduced . For example, the problem classification method based on deep learning can be introduced in the problem classification link , During problem analysis , Deep learning based NER Entity recognition method and further entity alignment , There is no further development here .

besides , The construction of knowledge map needs to be combined with business needs , That is, when receiving the business and analyzing the existing data, then building a business based schema, Then build the knowledge map through the related technology of natural language processing . In the original project , Use crawler to crawl data , It can also be used NLP Relevant basis , Optimize the extracted data and so on .

Xiongguan road is like iron , Now we are going to start again . Just getting started , A new start . In the future, we will add more content based on deep learning algorithm to the construction of knowledge map , Application etc. .