知识图谱的节点和关系实现(python)

本文当中所涉及到的代码来源仍然是前一篇博文当中提到的刘老师架构的智能问答机器人中知识图谱部分,上一篇内容主要关于前期数据搜集和处理的内容,而在本期当中则会学习如何架构一个真实的知识图谱,并且在阅读完成之后,我也会自己进行尝试写一个小型的知识图谱来练习一下,请大家监督。

知识图谱基础代码构建(医疗向)_chen_nnn的博客-CSDN博客医疗知识图谱构建过程https://blog.csdn.net/chen_nnn/article/details/123410433

目录

build_medicalgraph.py

MedicalGraph类:

 read_nodes():

create_node():

create_diseases_nodes():

create_graphnodes():

create_relationship(): 

create_graphrels():

export_data():

结语

build_medicalgraph.py

import os
import json
from py2neo import Graph,Node


class MedicalGraph:


if __name__ == '__main__':
    handler = MedicalGraph()
    print("step1:导入图谱节点中")
    handler.create_graphnodes()
    print("step2:导入图谱边中")      
    handler.create_graphrels()

很明显的库函数调用,值得注意的是py2neo是Neo4j数据库的python驱动。neo4j里面最重要的两个数据结构就是节点和关系,即Node和Relationship,可以通过Node或Relationship对象创建。而在该代码文件中则是引入了Graph类和Node类。具体可以参照此篇博客Neo4j简介及Py2Neo的用法_yayun_kg的博客-CSDN博客_py2neoNeo4j是一个世界领先的开源图形数据库,由Java编写。图形数据库也就意味着它的数据并非保存在表或集合中,而是保存为节点以及节点之间的关系。Neo4j的数据由下面3部分构成:节点边属性Neo4j除了顶点(Node)和边(Relationship),还有一种重要的部分——属性。无论是顶点还是边,都可以有任意多的属性。属性的存放类似于一个HashMap,Key为一个字符串,而Value必须...https://blog.csdn.net/for_yayun/article/details/105494652

MedicalGraph类:

class MedicalGraph:
    def __init__(self):
        cur_dir = '/'.join(os.path.abspath(__file__).split('/')[:-1])
        self.data_path = os.path.join(cur_dir, 'data/medical.json')
        self.g = Graph(
            host="127.0.0.1",  # neo4j 搭载服务器的ip地址,ifconfig可获取到
            http_port=7474,  # neo4j 服务器监听的端口号
            user="lhy",  # 数据库user name,如果没有更改过,应该是neo4j
            password="lhy123")

复习一下,在上篇博文中提到了,在cur_dir中获得了当前运行程序的绝对路径,然后在后面加上数据库的路径得到data_path。然后利用py2neo当中的Graph类,在查找几篇文章之后,此处的作用是连接neo4j数据库。这个图形类表示的Neo4j图形数据库内的图数据的存储空间。使用URI和(或)单个设置提供连接详细信息。而关于Graph类的详细情况,可以参照此篇博客python使用Neo4j图数据库——py2neo详解(2)_Elenstone的博客-CSDN博客_graph py2neo目录0 前言1 py2neo.database-Graph Databases2 GraphService3 Graph0 前言python使用Neo4j图数据库——py2neo详解(1)1 py2neo.database-Graph Databasespy2neo.database包包含与Neo4j服务器交互所需的类和方法。为方便起见,这些类中的许多类也通过top-level包公开py2neo。提供的最有用的类是Graph,表示一个Neo4j图形数据库实例并提供对大部分最常用py2neo APIhttps://blog.csdn.net/Elenstone/article/details/106456449

 read_nodes():

    def read_nodes(self):
        # 共7类节点
        drugs = [] # 药品
        foods = [] # 食物
        checks = [] # 检查
        departments = [] #科室
        producers = [] #药品大类
        diseases = [] #疾病
        symptoms = []#症状

        disease_infos = []#疾病信息

        # 构建节点实体关系
        rels_department = [] # 科室-科室关系
        rels_noteat = [] # 疾病-忌吃食物关系
        rels_doeat = [] # 疾病-宜吃食物关系
        rels_recommandeat = [] # 疾病-推荐吃食物关系
        rels_commonddrug = [] # 疾病-通用药品关系
        rels_recommanddrug = [] # 疾病-热门药品关系
        rels_check = [] # 疾病-检查关系
        rels_drug_producer = [] # 厂商-药物关系

        rels_symptom = [] #疾病症状关系
        rels_acompany = [] # 疾病并发关系
        rels_category = [] # 疾病与科室之间的关系


        count = 0
        for data in open(self.data_path):
            disease_dict = {}
            count += 1
            print(count)
            data_json = json.loads(data)
            disease = data_json['name']
            disease_dict['name'] = disease
            diseases.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 'easy_get' in data_json:
                disease_dict['easy_get'] = data_json['easy_get']

            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_department
                departments += cure_department

            if '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_drug

            if 'recommand_drug' in data_json:
                recommand_drug = data_json['recommand_drug']
                drugs += recommand_drug
                for 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_eat
                do_eat = data_json['do_eat']
                for _do in do_eat:
                    rels_doeat.append([disease, _do])

                foods += do_eat
                recommand_eat = data_json['recommand_eat']

                for _recommand in recommand_eat:
                    rels_recommandeat.append([disease, _recommand])
                foods += recommand_eat

            if 'check' in data_json:
                check = data_json['check']
                for _check in check:
                    rels_check.append([disease, _check])
                checks += check
            if '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 += producer
            disease_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(药品)、foods(食物)、checks(检查)、departments(科室)、producers(药品大类)、diseases(疾病)、symptoms(症状)。然后是节点之间和节点与其他部分信息的关系。然后是读取存储在medical.json中的数据内容,而在上一篇博文中提到了该json文件中的数据存储的格式,这里放一张图便于理解。

然后定义一个disease_dict字典变量进行存储。json.loads使存储在json文件中的每一条内容重组成一个字典格式。然后将该条内容中保存的疾病的名称存入到disease_dict字典和diseases列表中。然后在disease_dict字典中定义好所有可能会用到的键名。
利用if语句进行判断,判断该条疾病讯息当中是否有关于症状的内容,如果有的话将其存储的symptoms列表当中,也在相应的关系列表中将疾病名称和症状之间匹配起来;连接疾病与并发症之间的关系;在disease_dict中保存疾病的描述信息、预防措施、成因、患病几率、易感人群、治疗方式、用药时间、治愈概率、常用药物、推荐服药的信息;然后是对就诊科室进行处理,如果就诊科室下只有一个科室,那么就在关系列表中将该疾病和该科室关联,如果有两个科室的话,说明会有一个大科室下面包含一个小科室,将大科室和小科室关联,再将该疾病与小科室之间建立关系,然后将其保存到disease_dict字典和departments列表中;

建立疾病和常用药物、疾病和推荐服药之间的关系;建立疾病和忌口食物、疾病和宜吃食物、疾病和推荐食谱之间的关系,并将所有出现过的食物名称都保存在foods列表下;建立疾病和化验项目之间的关系,并将化验项目保存到check列表下;建立药品和生产商之间的关系,并将所有的药品生产商保存,推测是因为每一项疾病有关的药品过多,所以不建立疾病与药品之间的关系,至于使用的语法为什么和前文不同,则和数据库中数据保存的形式有关:

最后将建立好的该疾病字典保存到disease_infos列表当中,并将该函数中保存好的各项列表值作为返回值返回。

create_node():

    def create_node(self, label, nodes):
        count = 0
        for node_name in nodes:
            node = Node(label, name=node_name)
            self.g.create(node)
            count += 1
            print(count, len(nodes))
        return

该函数功能虽然简单,但是乍一看会有点抽象,我们通过在后面代码中的使用来分析:self.create_node('Drug', Drugs)。因此我们可以得知,该函数来构建图中的各个节点,同时每一个节点都会有一个属性值,然后有一个键值对保存对应的名称。

create_diseases_nodes():

    def create_diseases_nodes(self, disease_infos):
        count = 0
        for disease_dict in disease_infos:
            node = Node("Disease", name=disease_dict['name'], desc=disease_dict['desc'],
                        prevent=disease_dict['prevent'] ,cause=disease_dict['cause'],
                        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 += 1
            print(count)
        return

该函数功用和上面的函数十分的相似,只不过作为函数中心节点所包含的信息更多,至于具体的信息如何显示等我搞明白之后再回来解释。

create_graphnodes():

    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

该函数算是对前面代码内容的一个汇总,利用read_nodes中读取到的信息然后进行所有节点的构建。

create_relationship(): 

    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))  
        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 += 1
                print(rel_type, count, all)
            except Exception as e:
                print(e)
        return

 同样是使用该函数的使用方式来进行宏观的把控:self.create_relationship('Disease', 'Food', rels_doeat, 'do_eat', '宜吃')。可以分析看到首先是我们这条边的起始节点,然后是终止节点,然后由于前面只规定了起始节点和终止节点的性质,通过edges将该关系具体化,然后是对关系进行说明。join是string(字符串)的方法,函数参数是一个由字符串组成的列表比如['a','b','c'],作用是用字符串把这个字符串列表里的字符串连接起来,比如:a='-',则a.join(['a','b','c'])='a-b-c'。然后统计不重复的边的总数。在for循环内做该函数的主要功能,split() 通过指定分隔符对字符串进行切片,如果参数 num 有指定值,则分隔 num+1 个子字符串,得到p是对应的疾病,q是对应的食物,核心是query语句,猜测该语句是一种可以被py2neo识别的一种格式,我们做一下细细解读。首先是将p和start_node,q和end_node进行性质配对,然后对这两个节点进行命名,最后建立这两个节点之间的由p指向q的边关系,关系的名称由于是使用python书写所以必须是英文,但是现实出来是却可以使用中文,因此会有两个相似的变量名。之后使用try语句尝试构建该边关系,失败则打印出失败原因。

create_graphrels():

    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', '所属科室')

 使用前文中书写好的函数,批量构建边关系。

export_data():

    def export_data(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()
        f_drug = open('drug.txt', 'w+')
        f_food = open('food.txt', 'w+')
        f_check = open('check.txt', 'w+')
        f_department = open('department.txt', 'w+')
        f_producer = open('producer.txt', 'w+')
        f_symptom = open('symptoms.txt', 'w+')
        f_disease = open('disease.txt', 'w+')

        f_drug.write('\n'.join(list(Drugs)))
        f_food.write('\n'.join(list(Foods)))
        f_check.write('\n'.join(list(Checks)))
        f_department.write('\n'.join(list(Departments)))
        f_producer.write('\n'.join(list(Producers)))
        f_symptom.write('\n'.join(list(Symptoms)))
        f_disease.write('\n'.join(list(Diseases)))

        f_drug.close()
        f_food.close()
        f_check.close()
        f_department.close()
        f_producer.close()
        f_symptom.close()
        f_disease.close()

        return

 将该代码中所使用的到的各项节点内容都进行保存。保存时以换行符为间隔进行保存,这样在最后的txt文件中每个元素都占一行。


结语

关于该py文件的解读也已经完成接下来的工作就是将刘老师的工作复现一下,期待我的下一次更新吧!

  • 8
    点赞
  • 76
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
Python 知识图谱的设计与实现是一个复杂的过程,需要综合运用Python的编程知识、数据处理技术和图谱算法。首先,我们需要选择合适的图数据库,比如Neo4j,作为知识图谱的存储和查询引擎。然后,我们需要通过Python编程,设计一个数据获取和清洗的流程,从各种数据源中抽取与知识图谱相关的数据,并且进行预处理和格式化。接着,我们需要使用Python编写代码,将清洗好的数据导入到图数据库中,并且构建节点关系的结构,以及定义节点关系的属性。同时,我们需要编写Python代码实现知识图谱的查询和可视化功能,比如通过输入关键词进行相关实体的检索,或者将知识图谱以图形的形式展现出来。 在实现过程中,需要充分利用Python的各种库和框架,比如pandas进行数据处理,py2neo进行与Neo4j数据库的交互,networkx进行图算法的应用,以及各种可视化库进行图形展示。在整个设计与实现过程中,需要考虑知识图谱的数据结构设计、查询性能优化、实体识别与链接、图谱可视化等方面的技术挑战。同时,需要考虑知识图谱的数据更新和维护问题,以及图谱的可扩展性和可信度的管理。 总的来说,基于Python知识图谱的设计与实现需要综合运用各种技术手段,具有一定的复杂性和挑战性。然而,通过合理的规划和设计,以及灵活的Python编程,可以实现一个功能强大且高效的知识图谱系统。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值