从零实现基于医疗知识图谱的问答系统(二)-Neo4j构建知识图谱

文章目录
  1. 1. Neo4j的基本操作
    1. 1.1. 在Python代码中设置Neo4j的连接
    2. 1.2. Neo4j创建节点
    3. 1.3. Neo4j删除节点
    4. 1.4. Neo4j删除label
    5. 1.5. Neo4j创建节点之间的关系
    6. 1.6. Neo4j删除节点之间的关系
      1. 1.6.1. 仅删除关系,保留节点
      2. 1.6.2. 删除节点及其关系
  2. 2. 构建医疗知识图谱
    1. 2.1. 设定初始化
    2. 2.2. 构建节点和关系
    3. 2.3. 在知识图谱中创建节点
    4. 2.4. 创建实体关系边

这篇开始知识图谱的生成,其中也包括Neo4j的使用和其他数据的处理。

Python下面通过py2neo这个库来控制Neo4j的操作,但是操作Neo4j之前需要在本地先配置好Neo4j。
由于很久之前我就已经装好了Neo4j了(但是拖到现在才开始学图谱操作,我反省),所以这里不再赘述安装过程,放一个安装参考链接:
Neo4j安装参考

先讲一下Neo4j的相关操作吧.

Neo4j的基本操作

首先启动Neo4j。
cmd进入Windows Neo4j所在的文件夹下面,执行命令:

1
bin\neo4j console

输入相应的网址:localhost:7474

这个样子Neo4j就算是安装成功了。

在Python代码中设置Neo4j的连接

-host:主机名称
-http_port:端口号
-user:用户名
-password:密码
用户名和密码如果没改过的话则统一都是neo4j,这里是本机控制的neo4j,所以是127.0.0.1,7474是neo4j的默认端口。
如果忘了设置的密码,就进入/data/dbms文件夹下面删除auth后重新启动再次设置密码即可。

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/env python
# coding:utf-8

from py2neo import Graph, Node

g = Graph(
host='127.0.0.1',
http_port=7474,
user='neo4j',
password='123456')

运行代码,成功则不显示任何消息。

Neo4j创建节点

Node函数的第一个参数是label,其余参数是节点属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/env python
# coding:utf-8

from py2neo import Graph, Node

g = Graph(
host='127.0.0.1',
http_port=7474,
user='neo4j',
password='123456')

# 创建节点
node1=Node('Bayern',name='thomas',id='25',location='Munich')
node2=Node('Bayern',name='lewy',id='09',location='Munich')
node3=Node('Bayern',name='javi',id='08',location='Munich')

g.create(node1)
g.create(node2)
g.create(node3)

运行上面代码,查看Neo4j web端界面,可以看到Node Lable这里多出了之前床前的Bayern这个操作。

点击其中的一个节点,可以看到节点的属性:

Neo4j删除节点

打开Nwo4j的Web页面,执行命令。
Bayern:label
name:节点属性

1
MATCH (n:Bayern{name:'lewy'}) DELETE n;

同样也可以执行这样一条命令来定位到需要删除的节点:

1
MATCH (n:Bayern{id:'08'}) DELETE n;

也就是说,通过节点标签和属性来定位可以删掉指定的节点(Node)。

Neo4j删除label

上述命令中通过Bayern标签创建了三个节点,这次直接删除Bayern节点:

1
MATCH (e: Bayern) DELETE e

Neo4j创建节点之间的关系

首先建立节点,在通过Relationship来定义两个节点间的关系,最后通过g添加到图中。

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
#!/usr/bin/env python
# coding:utf-8

from py2neo import Graph, Node,Relationship

g = Graph(
host='127.0.0.1',
http_port=7474,
user='neo4j',
password='123456')

# 创建节点
node1=Node('Bayern',name='thomas',id='25',location='Munich')
node2=Node('Bayern',name='lewy',id='09',location='Munich')
node3=Node('Bayern',name='javi',id='08',location='Munich')

g.create(node1)
g.create(node2)
g.create(node3)

teammate1=Relationship(node1,'teammate',node2)
teammate2=Relationship(node2,'teammate',node3)

g.create(teammate1)
g.create(teammate2)

实现效果图如下:

Neo4j删除节点之间的关系

仅删除关系,保留节点

执行命令:

1
MATCH (n:Bayern{name:'javi'}) –[r]- () DELETE r;

效果如图所示:

删除节点及其关系

删除所有节点。如果节点有关系,也删除关系,执行命令:

1
MATCH (n) DETACH DELETE n;

这个命令比较狠,直接就把我Neo4j里面所有的数据全删了,幸好都是测试的,这个命令要慎用。

构建医疗知识图谱

上述内容中讲到了如何操作Neo4j以及用Python创建节点及其关系,下面回到刘老师的代码中来实现知识图谱的构建。

定义一个 class Medical 类来管理KG的构建。

设定初始化

首先设置初始化:

1
2
3
4
5
6
7
8
9
10
# 图数据库初始化设置
def __init__(self):
cur_dir='/'.join(os.path.abspath('__file__').split('//')[:-1])
self.data_path=os.path.join(cur_dir,'./data/medical.json')
# 配置Neo4j
self.g=Graph(
host='127.0.0.1',
http_port=7474,
user='neo4j',
password='123456')

构建节点和关系

下面细说关于从medical.json中读取文件的细节,首先,刘老师用的是直接读取的办法:

1
2
for data in open(self.data_path):
data_json = json.loads(data)

self.data_path就是先前得到的medical.json,但是这样运行的话会报错:
UnicodeDecodeError: ‘gbk’ codec can’t decode byte 0xaf in position 81: illegal multibyte sequence

这个问题比较好解决,下面给出我折腾NLP文件期间常用的解决大法,readline(),下面这个test_json.py是我写来测试读取文件的:

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/env python
#coding:utf-8

import json

file=open('./data/medical.json',encoding='utf-8')
data=file.readline()
count=0
while data:
print(json.loads(data)['name'])
data=file.readline()
count+=1
print(count)

首先进行 utf-8 的编码,再将读取出来的结果使用readline(),这里的file.readline()得到的结果就类似于一个指针,它会自动往后移,到达文件末尾的时候停止,妥。

回到刘老师读取文件的过程,即 def read_nodes。
首先定义节点的类型,一共有八类节点:

1
2
3
4
5
6
7
8
9
# 共8类节点
drugs=[] # 药品
foods=[] # 食物
checks=[] # 检查
departments=[] #科室
producers=[] #药品大类
diseases=[] # 疾病
symptoms=[] # 症状
disease_infos=[] # 疾病信息

再定义节点间的关系:

1
2
3
4
5
6
7
8
9
10
11
12
# 构建节点实体关系
rels_department=[] # 科室-科室关系
rels_noteat=[] # 疾病-忌吃食物关系
rels_doeat=[] # 疾病-宜吃食物关系
rels_recommandeat = [] # 疾病-推荐吃食物关系
rels_commonddrug = [] # 疾病-通用药品关系
rels_recommanddrug = [] # 疾病-热门药品关系
rels_check=[] # 疾病-检查关系
rels_drug_producer=[] # 厂商-药物关系
rels_symptom=[] # 疾病症状关系
rels_acompany=[] # 疾病并发关系
rels_category=[] # 疾病与科室之间的关系

根据medical.json中的疾病信息进入循环构建节点及其关系,其中定义了一个dict类型的数据:disease_dict[],里面包含了疾病名称,疾病描述,疾病预防,疾病成因,易感人群,治疗科室,治疗方法,治疗周期,疾病症状,治愈概率几个字段。
这里我觉得老师好像写漏了一点东西,在构建disease_dict过程中应该存储好对应的字段,再将disease_dict加入到disease_info中,但是其中并没有添加disease_dict[‘symptom’],老师只是在symptoms的list中加入了症状,所以这里在这个关系中我给补上对应的字段:

1
2
3
4
5
6
# 构建疾病和症状的关系
if 'symptom' in data_json:
symptoms+=data_json['symptom']
disease_dict['symptom']=data_json['symptom'] # 补上的
for symptom in data_json['symptom']:
rels_symptom.append([disease,symptoms])

其中构建关系的方式是,一种疾病对应其症状,治疗方法等字段,类似于这样:

1
2
3
4
# 构建疾病和并发症关系
if 'acompany' in data_json:
for acompany in data_json['acompany']:
rels_acompany.append([disease,acompany])

其他的关系构建大同小异,害,问题不大。

注意,这里有一个点我一定要说清楚,在刘老师构建的知识图谱中,有一个东西叫做recommand_eat,这个字段并不是所有的疾病中都包含,我在测试第一个疾病的时候就发现其中没有这个字段,所以在运行过程中会导致报错,OK,我们加try&Exception就可以搞定:

1
2
3
4
5
6
7
8
9
10
11
# 存储推荐食物
try:
if 'recommand_eat' in data_json['recommand_eat']:
recommand_eat = data_json['recommand_eat']
for _recommand in recommand_eat:
# 构建推荐食物和疾病间的关系
rels_recommandeat.append([disease, _recommand])
# 食物中加入推荐食物
foods += recommand_eat
except Exception as e:
print(e)

在知识图谱中创建节点

即def create_graphnodes(),首先通过上述中提到的read_nodes获取相关信息:

1
2
3
4
5
# 获取数据
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()

(字段太多了我要昏古七了…

继续,创建疾病节点,操作就和上半部分中的Node创建是一模一样的。

1
2
3
4
5
6
7
8
9
10
11
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)

继续,创建其他节点(药品,食物,检查信息等),label就是药品,或者食物这些。

1
2
3
4
5
6
7
8
9
# 建立节点
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

创建实体关系边

同样,还是需要read_nodes来获取需要的信息。
创建完成后进行关系创建:

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
def create_relationship(self, start_node, end_node, edges, rel_type, rel_name):
'''
:param start_node: 开始节点
:param end_node: 结束节点
:param edges: 关系边
:param rel_type: 关系类型
:param rel_name: 关系名称
:return:
'''
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]
# neo4j语法
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

创建调用方式如下,害,问题不大。
注意,在调用这里,必须注释掉症状这个构建,因为这条会报错,但是报错原因排查后无效,甚至出现Memory问题,所以这里暂时只能放弃这个构建。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 创建实体关系边
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', '所属科室')

完整的构建知识图谱build_medicalgraph.py如下:

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
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
#!/usr/bin/env python
# coding:utf-8

import os
import json
from py2neo import Graph, Node


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')
# 配置Neo4j
self.g = Graph(
host='127.0.0.1',
http_port=7474,
user='neo4j',
password='123456')

# 读取节点
def read_nodes(self):
# 共8类节点
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
file = open(self.data_path, encoding='utf-8')
data = file.readline()
while data:
disease_dict = {}
count += 1
print(count)
# 根据json文件加载进来的数据
data_json = json.loads(data)
disease = data_json['name']
disease_dict['name'] = 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']
disease_dict['symptom'] = data_json['symptom']
for symptom in data_json['symptom']:
rels_symptom.append([disease, symptoms])

# 构建疾病和并发症关系
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

# 存储宜食食物
if 'do_eat' in data_json:
do_eat = data_json['do_eat']
for _do in do_eat:
# 构建宜食食物和疾病的关系
rels_doeat.append([disease, _do])
# 食物中加入宜食食物
foods += do_eat

# 存储推荐食物
try:
if 'recommand_eat' in data_json['recommand_eat']:
recommand_eat = data_json['recommand_eat']
for _recommand in recommand_eat:
# 构建推荐食物和疾病间的关系
rels_recommandeat.append([disease, _recommand])
# 食物中加入推荐食物
foods += recommand_eat
except Exception as e:
print(e)

# 存储检查结果
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)
data = file.readline()
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

# 建立节点
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

# 创建知识图谱中心疾病的节点
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)

# 创建知识图谱实体节点类型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_relationship(self, start_node, end_node, edges, rel_type, rel_name):
'''
:param start_node: 开始节点
:param end_node: 结束节点
:param edges: 关系边
:param rel_type: 关系类型
:param rel_name: 关系名称
:return:
'''
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]
# neo4j语法
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

# 创建实体关系边
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', '所属科室')

# 导出数据
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('./dict/drug.txt', 'w+')
f_food = open('./dict/food.txt', 'w+')
f_check = open('./dict/check.txt', 'w+')
f_department = open('./dict/department.txt', 'w+')
f_producer = open('./dict/producer.txt', 'w+')
f_symptom = open('./dict/symptoms.txt', 'w+')
f_disease = open('/dict/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


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

导入的时间比较长,需要等一会,等待的时间里,可以划水,摸鱼(划掉

当我们划完水,摸完鱼之后(划掉

打开localhost:7474就可以看到已经生成好的知识图谱(觉得图谱颜色丑的话可以在浏览器端调色-w-):

同时,在./data文件夹下,也可以看到相应的生成文件:

后面会花大概两篇博客的长度来写问答系统部分,妥。