CN113360286B - 一种基于知识图谱嵌入的链接预测方法 - Google Patents

Abstract

本发明公开了一种基于知识图谱嵌入的链接预测方法，目的是实现大规模知识图谱的快速链接预测。技术方案是先对知识图谱进行分区；然后构建嵌入模型和由N个服务器和共享文件系统组成知识图谱链接预测系统，训练时服务器作为主节点和训练节点，训练时服务器作为查询节点和预测节点，主节点安装有锁服务器进程，训练节点安装有数据加载进程和GPU训练进程；接着多机并行且CPU、GPU并行对嵌入模型进行分布式训练；最后N个服务器加载训练后的嵌入模型，对知识图谱链接进行并行预测；采用本发明既加快了知识图谱嵌入的训练和连接预测，又解决了分区造成的嵌入性能下降问题，能够快速获得高质量的知识图谱嵌入。

Description

一种基于知识图谱嵌入的链接预测方法

技术领域

本发明涉及知识图谱链接预测领域，具体涉及一种基于知识图谱嵌入的链接预测的方法。

背景技术

知识图谱(Knowledge Graph,KG)是真实世界信息的结构化表示，通常表示一个多关系图，即一个包含多种类型的节点和关系的图。KG由三个部分组成，实体集E，即现实世界中的事物，如人、地名、概念、药物、公司等的集合,例如“北京”就是一个实体；关系集R，即实体间的某种联系，例如“首都”关系表示一个实体是另一个实体的首都；三元组集T，表示事实，即实体间存在某种关系，例如三元组(北京，首都，中国)，表示“北京是中国首都”这个事实。

虽然知识图谱包含大量三元组(事实)，但人工输入所有的三元组是不可能的，因此知识图谱往往仍然存在着大量三元组缺失的问题。为了解决这个问题，知识图谱链接预测(linkprediction，LK)任务的目标根据已知的链接(三元组)，自动预测实体之间的丢失链接。举例说明，给定一个缺失三元组(h,r,？)或(？,r,t),问号表示要缺失的实体，对于每一个缺失实体，链接预测任务使用所有的知识图谱中的实体作为候选项对三元组进行补全，然后预测补全后的三元组的有效性。

已有的研究采用知识图谱嵌入来处理链接预测问题。知识图谱嵌入将知识图谱中的每个实体和关系表示为低维向量(即嵌入)，通过计算向量间的得分函数来判断三元组的有效性。嵌入模型的参数由实体嵌入向量和关系嵌入向量(或矩阵)组成，每个实体对应一个向量，每个关系对应一个向量(或矩阵)。

链接预测一般步骤如下：

1.构建嵌入模型。主要分为三步，表示实体、关系，定义得分函数，定义损失函数；表示实体、关系：嵌入模型的参数由实体嵌入和关系嵌入构成，目前已有的模型中，大多采用向量表示实体，使用向量或矩阵表示关系；得分函数：得分函数f(h,r,t)定义了如何使用实体和关系嵌入计算三元组(h,r,t)得分；损失函数：损失函数定义了使用三元组得分计算在训练数据集上的优化目标函数。

2.训练嵌入模型。以知识图谱中的三元组作为训练数据，通过梯度反向传播算法最小化损失函数来优化模型参数，得到嵌入模型；

3.使用嵌入模型进行链接预测。对输入的缺失三元组，使用训练好的嵌入模型快速预测有效三元组；例如：输入缺失三元组(h,r,？)，以实体集E中所有实体作为候选实体，生成候选三元组{(h,r,t’)|t’∈E},计算所有候选三元组得分函数，以得分最高的三元组作为三元组预测结果，对应的{t’}即缺失实体预测结果。

虽然知识图谱嵌入是处理链接预测问题的有效方法，但是却很难直接扩展到工业级的知识图谱上，主要原因是知识图谱的规模越来越大，例如，脸书的知识图谱包含0.5亿实体，5亿三元组；微软的知识图谱包含20亿实体，550亿三元组；谷歌的知识图谱包含10亿实体，700亿三元组；百度的知识图谱包含千亿级三元组。大规模知识图谱的实体数量很大，造成了实体嵌入参数的规模很大，使得使用显卡对嵌入模型进行训练时导致显存不足，且时间过长。

为了解决这两个问题，Facebook提出的PBG(PytorchBigGraph)采取分区训练方法，将知识图谱嵌入模型训练放到多台计算机组成的计算集群上同时进行训练，从而减少对单个训练设备的显存要求同时缩短计算时间。

PBG首先将实体分为P个互不重叠的分区，将三元组按照头实体和尾实体所在分区划分为不同的P²个三元组块。这样整个知识图谱由两部分组成，一部分是实体分区集Partitions＝{Part_k|0≤k<P}(P为分区数量，为正整数)，Part_k表示第k个分区；另一部分是三元组块集Buckets＝{B(i1,j1)|0≤i1,j1<P}中三元组块B(i1,j1)中的任意三元组(h,r,t)，其头实体h来自分区Part_i1，尾实体来自分区Part_j1。训练时，集群中的每个服务器首先加载一个三元组块以及对应的分区实体嵌入到CPU内存进行预处理，然后再加载到GPU上中进行训练，这样对单个节点的内存和显存需求就被大大降低了。以FreeBase为例，它具有8000多万个实体和3亿多条边(三元组)，当嵌入向量长度为400，总的实体嵌入需要120G存储空间，分区数量P＝16时，每个分区的实体数量为500多万，嵌入参数大小为7.5G，为总大小120G的

单个服务器在训练时最大仅需要存储2个分区，两个分区嵌入参数大小为15G，为总大小的

极大的减少了知识图谱嵌入对单个服务器的GPU显存要求；另外，分区还为多个节点的并行训练提供了支持，例如三元组块B(0,1)和三元组块B(2,3)可以同时被不同的服务器进行训练。

但是，PBG知识图谱嵌入框架存在以下问题：1.分区训练时，服务器首先使用CPU进行数据交换和预处理，然后再将嵌入和三元组加载到GPU进行计算，这两个过程是串行的，因此CPU和GPU需要互相等待从而增加整个训练时间；2.因为进行了分区，分区后的三元组块的数据分布和整个知识图谱三元组的数据分布差异很大，因此最终得到的嵌入模型性能会有所下降，实验结果表明，在进行链接预测时，MRR(平均排序倒数，Mean ReciprocalRank)随着分区数的增加而降低；3.只提供了知识图谱的嵌入训练和测试，缺少知识图谱嵌入在分布式集群中的链接预测应用。

发明内容

本发明要解决的技术问题是提出一种基于知识图谱嵌入的链接预测方法，采用CPU、GPU并行以及多机并行的优化方法快速获取工业级知识图谱的嵌入表示，并基于嵌入表示进行快速的链接预测，对知识图谱中缺失的三元组快速判断其有效性，从而实现大规模知识图谱的快速链接预测。

为了实现上述目的，本发明提供如下技术方案：

第一步：对知识图谱进行分区；根据需要确定分区数量P和每个分区的子分区数量PP，将所有的实体分为subP个不重叠的子分区，subP＝P×PP，子分区为实体集E的互不重叠的子集，分区为PP个子分区的并集；将所有的三元组根据其头实体和尾实体所在子分区划分为不同的子三元组块；方法是：

1.1输入知识图谱数据，得到实体集E，关系集R，三元组集T，实体数量num_entities，E中包含num_entities个实体，num_entities为正整数，T中包含num_triples个三元组，num_triples为正整数。例如：输入8个实体，2个关系的知识图谱，则E＝{e₀,e₁,e₂,e₃,e₄,e₅,e₆,e₇}，e₀,e₁,e₂,e₃,e₄,e₅,e₆,e₇均为实体，R＝{r₀,r₁}，r₀,r₁分别为关系，三元组集T＝{(e₁,r₀,e₄),(e₁,r₀,e₆),(e₂,r₁,e₆),(e₂,r₀,e₃)，(e₅,r₀,e₄),(e₆,r₀,e₄),(e₁,r₀,e₇),(e₆,r₁,e₄),(e₇,r₀,e₄),(e₃,r₀,e₇),(e₂,r₁,e₄),(e₄,r₁,e₃),(e₂,r₁,e₄),(e₃,r₀,e₆),(e₄,r₁,e₆),(e₇,r₀,e₃)}，num_entities＝8，num_triples＝16。

1.2设置超参数嵌入向量维度D、分区数量P、每个分区包含的子分区数量PP，得到总的子分区数量subP＝P×PP，计算实体子分区大小subpart_size，subpart_size＝num_entities/subP；其中嵌入向量维度D一般设置为400，P的设置和总实体嵌入大小与GPU显存大小有关，总实体嵌入的大小为num_entities×D×4，P满足：2×总实体嵌入大小/P<GPU显存大小，PP的设置根据经验，为2即可。例如，对于1.1中的举例，设置P＝2，PP＝2，则subP＝4，subpart_size＝8/4＝2。

1.3将实体集E随机打乱，然后按照子分区大小subpart_size将实体分割成subP个子分区集subpart，subpart中共有subP个实体子分区，每个实体子分区中含subpart_size个实体；例如：E＝{e₀,e₁,e₂,e₃,e₄,e₅,e₆,e₇}，随机打乱后得到{e₇,e₄,e₆,e₂,e₅,e₃,e₁,e₀}，经过分割后得到subpart＝{{e₇,e₄},{e₆,e₂},{e₅,e₃},{e₁,e₀}}。

1.4遍历三元组集T所有的三元组，根据三元组头实体和尾实体所属的分区，将三元组划分到对应的子三元组块中，得到subP²个子三元组块组成的子三元组块集合subBuckets，subBuckets＝{subBucket(i2,j2)|1<i2,j2≤subP}，其中(i2,j2)为子三元组块的编号，表示该三元组块中所有三元组的头实体来自第i2实体子分区，尾实体来自第j2实体子分区，subBucket(i2,j2)表示编号为(i2,j2)的子三元组块；例如，对于T中的三元组(e₁,r₀,e₄)，根据1.3中得到的subpart，e₁属于subpart₄,e₄属于subpart₁，因此(e₁,r₀,e₄)被添加到subBucket(4,1)中，此时i2＝4,j2＝1；对于T中的三元组(e₁,r₀,e₆)，根据1.3中得到的subpart，e₁属于subpart₄,e₆属于subpart₂，因此(e₁,r₀,e₆)被添加到subBucket(4,2)中，此时i2＝4,j2＝2；对于T中其余16-2个三元组，都能根据1.3的subpart，得到相应的subBucket(i2,j2)。subP²＝16。方法是：

1.4.1初始化变量k1＝1，初始化子三元组块集合subBuckets,令subBuckets中所有的子三元组块均为空集，即令subBucket(1,1),…,subBucket(i2,j2),…,subBucket(subP,subP)均为空集；

1.4.2从T中取出第k1个三元组(e_h,r,e_t)，0≤h,t≤num_entities-1；根据1.3获得的subpart获取e_h所属子分区序号ih，e_t所属子分区序号it，1≤ih,it≤subP，将三元组(e_h,r,e_t)添加到subBucket(ih,it)中，r∈R；

1.4.3令k1＝k1+1；如果k1≤num_triples，转1.4.2；如果k1>num_triples，表示T中所有三元组均被划分到对应的子三元组块中，得到了子三元组块集合subBuckets，将子三元组块集合中所有的三元组块存储至共享文件系统，转第二步。

第二步：构建嵌入模型。主要分为二步，表示实体、关系；定义得分函数。表示实体、关系：嵌入模型采用嵌入向量表示实体和关系，嵌入模型的参数由实体嵌入向量和关系嵌入向量构成；得分函数：得分函数定义了如何使用实体和关系嵌入计算三元组得分；具体为：

2.1用向量表示实体和关系；方法是：

2.1.1将知识图谱中的每个实体表示为一个实体嵌入向量,实体嵌入向量是一个长度为D的向量，向量的值随机初始化为从标准正态分布的随机数。按照1.3中的子分区集subpart，每个实体子分区包含subpart_size个实体，每个实体有一个实体嵌入向量，共subpart_size个实体嵌入向量，将实体嵌入向量作为实体子分区嵌入矩阵行向量，按照实体子分区内实体顺序组成一个subpart_size行D列的实体子分区嵌入矩阵；subP个实体子分区共组成subP个实体子分区嵌入矩阵，即subEmbs¹,subEmbs²,…,subEmbs^ip,…,subEmbs^subP，subEmbs^ip为第ip个实体子分区subpart_ip的嵌入矩阵，有subpart_size行D列；将subP个实体子分区嵌入矩阵存储至共享文件系统。例如,对于1.3中的E＝{e₀,e₁,e₂,e₃,e₄,e₅,e₆,e₇}，对应的实体嵌入向量为Emb₀,Emb₁,Emb₂,Emb₃,Emb₄,Emb₅,Emb₆,Emb₇，实体子分区subpart₁＝{e₇,e₄}，则subEmbs¹为subpart₁的实体子分区嵌入矩阵，矩阵的第1行为Emb₇,第二行为Emb₄,对每个实体子分区都得到一个实体子分区嵌入矩阵，共得到4个实体子分区嵌入矩阵；

2.1.2将知识图谱中的每个关系表示为一个关系嵌入向量，关系嵌入向量是一个长度为D的向量，向量的值随机初始化为从标准正态分布的随机数，将关系嵌入向量作为关系嵌入矩阵行向量，按照关系集内关系顺序组成关系嵌入矩阵θ，将θ存储至共享文件系统；例如,对于R＝{r₀,r₁}，对应的关系嵌入向量为θ₁,θ₂，得到关系关系嵌入矩阵θ，θ是一个2行D列的矩阵，其行向量分别为θ₁,θ₂。

2.2定义得分函数：

f(triple)＝f(e_h,r,e_t)＝sim(g(Emb_h,θr),g(Emb_d,θr))

其中sim(a,b)为相似度计算函数，用于计算两个向量a,b之间的相似度：

g为关系算子函数，用于计算实体嵌入向量Emb_h经过关系r变换后的向量：

g(Emb_h,θr)＝Emb_h⊙θr

triple＝(e_h,r,e_t)表示一个三元组，Emb_h为实体e_h的嵌入向量，θr为关系r的嵌入向量，⊙表示哈达玛积，

表示a,

的复数点积，

为b的共轭复数。由实体子分区嵌入矩阵、关系嵌入矩阵、得分函数共同组成了嵌入模型。

第三步，构建知识图谱链接预测系统。整个系统由计算集群(包含N个服务器)和共享文件系统组成，N个服务器均包含CPU和GPU(Graphics Processing Unit，图形处理器)，N为正整数。

共享文件系统是计算集群的共享磁盘，负责存储实体子分区嵌入矩阵(见4.2.11.2)、关系嵌入矩阵θ、以及三元组块。共享文件系统至少具备2TB以上的存储空间，具备10Gb/s以上的读写速度。

N个服务器与共享文件系统相连，从共享文件系统获取嵌入模型，负责对嵌入模型进行训练，并对用户输入的要预测的实体缺失的三元组(简称缺失三元组)，使用训练后的嵌入模型进行链接预测，得到预测结果。

对嵌入模型训练时，每个服务器都是一个训练节点，从训练节点中选择一个作为主节点；主节点也是训练节点，除了运行训练节点的所有进程外，还要运行锁服务器进程，训练节点运行数据加载进程和GPU训练进程。数据加载进程负责从共享文件系统中读取和写入实体子分区嵌入矩阵、关系嵌入矩阵；链接预测时，每个服务器作为一个预测节点，从预测节点选择一个作为查询节点(比预测节点多了查询功能)，各预测节点从共享文件系统加载训练后的嵌入模型，从查询节点获取用户输入即要预测的实体缺失的三元组(简称缺失三元组)，然后使用嵌入模型进行预测。

第四步，采用多机并行和CPU、GPU并行对嵌入模型进行分布式训练，将计算集群中的所有N个服务器作为训练节点，训练节点安装有数据加载进程和GPU训练进程，数据加载进程和GPU训练进程配合完成对嵌入模型的训练；从训练节点中任选一个作为主节点，主结点安装有锁服务进程；主节点的锁服务进程按4.1的流程对三元组块进行调度，同时N个训练节点的数据加载进程按4.2的流程进行数据加载，同时N个训练节点的GPU训练进程按4.3的流程进行训练，4.1、4.2、4.3并行进行，完成分布式训练，得到训练后的嵌入模型；方法是：

4.1主节点启动锁服务器进程，锁服务器进程调度每个训练节点(含主节点)进行训练所需的三元组块；调度方法如下：

4.1.1锁服务器进程初始化活动列表active和完成列表done，active和done初始值都为空，active保存正在训练的三元组块编号，done保存已经训练完的三元组块编号；初始化三元组块总数num_buckets＝P²,P为分区数量。

4.1.2锁服务器进程接收N个训练节点发送来的信息，按照先到先得的顺序进行处理；如果信息为开始新的训练周期，转4.1.3；如果信息为请求三元组块，转4.1.4；如果信息为释放三元组块，转4.1.5；如果信息为结束训练，结束锁服务器进程，此时训练阶段已经结束，数据加载进程不再需要锁服务进程的服务，因此此时锁服务器进程结束；

4.1.3新的训练周期开始，清空active和done，生成从分区到子分区的随机映射maps(maps为python字典类型，记录当前各分区分别由哪些子分区组成)，并将maps发送到N个训练节点；转4.1.2；

4.1.4为训练节点生成可训练的三元组块编号，得到可训练三元组编号res_bucket，并更新活动列表active和完成列表done。方法是：

4.1.4.1将所有三元组编号添加到三元组块编号列表acquirable_buckets中，具体方法是：初始化三元组块编号列表acquirable_buckets，列表元素为满足1≤m≤subP，1≤n≤subP的所有二元组(m,n)，m和n分别代表三元组头实体和尾实体所在分区序号；

4.1.4.2若active为空，转4.1.4.4，若active不为空，转4.1.4.3；

4.1.4.3令分区序号集active_part为空集合，从active中取出所有的二元组，将所有二元组中的分区序号添加到active_part中，对于acquirable_buckets中的二元组，如果二元组中任意元素在active_part中，则将该二元组从acquirable_buckets中去除，转4.1.4.4；

4.1.4.4如果done为空，转4.1.4.6；如果done不为空，转4.1.4.5；

4.1.4.5将done列表中的三元组块编号从acquirable_buckets中去除；

4.1.4.6如果acquirable_buckets不为空，转4.1.4.7，如果acquirable_buckets为空，转4.1.4.8；

4.1.4.7随机从acquirable_buckets选择一个三元组块编号，令临时变量res_bucket＝选择的这个三元组块编号，并将res_bucket添加到done和active中；转4.1.4.9；

4.1.4.8令临时变量res_bucket＝None；

4.1.4.9计算未训练三元组块数量remaining＝num_bucket-num_done,num_done为done中元素个数，num_bucket＝P²；将res_bucket和remaining发送给请求训练结点；转4.1.2；

4.1.5将释放三元组块信息中的三元组编号从actitve移除；转4.1.2；

4.2在N台训练节点上启动数据加载进程，N个训练节点的数据加载进程的流程完全相同，以第n个训练节点的流程为例说明，第n个训练节点进行数据加载的方法如下：

4.2.1在内存中创建4个PP×subpart_size行D列的矩阵Embs₁,Embs₂,Embs₃,Embs₄，矩阵元素值初始化为0，令实体嵌入矩阵列表Embs＝[Embs₁,Embs₂,Embs₃,Embs₄],令空闲矩阵序号列表free_idxs＝[0,1,2,3]；创建2个int类型进程间共享变量lock₁＝0，lock₂＝0(进程间共享变量，以及get_lock()、acquire()、release()等方法，见https:// docs.python.org/3.7/library/multiprocessing.html)；创建2个三元组编号curB₁＝(0,0),curB₂＝(0,0)，例如(1,2)表示三元组块(1,2)；创建2个实体嵌入矩阵序号列表EmbsIdx₁，EmbsIdx₂,分别初始化为长度为P的列表，列表元素均为0；创建2个三元组列表Triples₁,Triples₂,初始化为空；创建进程间传输管道conn，用于进程间数据传输,其数据类型为Pipe(见https://docs.python.org/3.7/library/multiprocessing.html)，创建训练标记is_training，初始化为True，类型为bool(即布尔型)；创建共享参数列表shared_paras，shared_paras中包含两组共享参数，令shared_paras＝[(lock₁,curB₁,EmbsIdx₁,Triples₁),(lock₂,curB₂,EmbsIdx₂,Triples₂)]；

4.2.2从共享文件系统中读取关系嵌入矩阵θ，在第n个训练节点中启动参数服务器(见文献“Scaling distributed machine learning with the parameter server”11thUSENIX Conference on Operating Systems Design and Implementation,OSDI’14,pp.583–598)，参数服务器负责将关系嵌入矩阵θ在N个训练节点之间进行同步；

4.2.3令当前训练周期数epoch＝1，获取用户定义的总训练周期数num_epoch(一般设为30)；

4.2.4如果epoch≤num_epoch，转4.2.5，否则转4.2.21；

4.2.5如果第n个训练节点为主结点，向锁服务器进程发送开始新的训练周期信息，转4.2.6；如果第n个训练节点不是主结点，直接转4.2.6；

4.2.6判断是否从锁服务器进程接收到分区到子分区的映射关系maps，若接收到maps，转4.2.7；若未收到maps，转4.2.6继续等待；

4.2.7第n个训练节点开始第epoch轮训练周期的训练，初始化第epoch轮训练周期三元组块编号cur_b＝None,next_b＝None,old_b＝None,next_arg_idx＝0；cur_b是第epoch轮正在训练的三元组块编号，next_b是待加载的三元组块编号，old_b是已经训练完成的三元组块编号，next_arg_idx是用于加载的共享参数在shared_paras中的序号；

4.2.8从共享参数列表中取出第next_arg_idx+1个元素(即用于加载的共享参数)：令lock,curB,EmbsIdx,Triples＝shared_paras[next_arg_idx]；使用get_lock()函数对输入为lock时获取临时变量L，使用acquire()函数对输入为L时获取是否成功标记is_success，详见https://docs.python.org/3.7/library/multiprocessing.html# multiprocessing.Value,如果is_success＝True，转4.2.9，否则转4.2.8；

4.2.9判断lock的值是否为0，如果是0，说明此时GPU训练进程已完成，共享参数享参数curB,EmbsIdx,Triples没有被GPU训练进程使用，可以进行数据加载，转4.2.10；否则，使用get_lock()函数对输入为lock时获取临时变量L，使用release()函数对输入为L时进行进程锁释放，转4.2.8；

4.2.10向锁服务器进程发送获取三元组块请求，从主节点得到res_bucket和remaining；如果res_bucket为None且remaining为0，转4.2.17；如果res_bucket为None且remaining不为0，转4.2.10；如果res_bucket不为None，更新old_b＝cur_b，cur_b＝next_b，next_b＝res_bucket，转4.2.11；

4.2.11在内存和共享文件系统之间采用嵌入数据交换方法对next_b和old_b进行分区嵌入矩阵数据交换，方法是：

4.2.11.1如果next_b不等于None，更新cur_B＝next_b,转4.2.11.2；否则转4.2.11.3；

4.2.11.2加载next_b中分区嵌入向量：next_b的值为(Parth,Partt)，对于二元组(Parth,Partt)中的任一元素p，从free_idx弹出idx，idx表示空闲矩阵的序号，EmbsIdx[p]表示实体嵌入矩阵序号列表EmbsIdx的第p个元素，令EmbsIdx[p]＝idx；由4.1.3中的映射maps得到maps[p]＝[sp1,sp2,…spPP]，即分区p由子分区sp1,sp2,…spPP组成，从共享文件系统分别读取对应的实体子分区嵌入矩阵subEmbs^sp1,subEmbs^sp2,…，subEmbs^spPP拼接并保存至Embs[idx]；

4.2.11.3如果old_b不等于None，转4.2.11.4；否则转4.2.12；

4.2.11.4保存old_b中的分区嵌入向量：old_b的值为(Parth,Partt)，对于二元组(Parth,Partt)中的任一元素p，令idx＝EmbsIdx[p]，将idx放回从free_idxs；由4.1.3中的映射maps得到maps[p]＝[sp1,sp2,…spPP]，按照[sp1,sp2,…,spPP]各子分区大小，将分区嵌入矩阵Embs[idx]按行切分为subEmbs^sp1,subEmbs^sp2,…，subEmbs^spPP,并将subEmbs^sp1,subEmbs^sp2,…，subEmbs^spPP保存到共享文件系统中；向锁服务器进程发送释放old_b信息；

4.2.12从共享文件系统中加载next_b三元组到内存。Parth,Partt分别为三元组编号next_b的第1个和第2个整数，从maps获取分区Parth和Parth对应的子分区：maps[Parth]＝[sh1,sh2,…shPP]，maps[Partt]＝[st1,st2,…,stPP]；从共享文件系统中加载子分区对应的子三元组块{subBuckets[i3,j3]|i3∈maps[Parth],j3∈maps[Partt]}，并重组为next_b三元组块Bucket,将Bucket保存至Triples；更新共享参数cur_B＝next_b；

4.2.13令lock＝1,令next_arg_idx＝(next_arg_idx+1)％2；

4.2.14使用get_lock()函数对输入为lock时获取临时变量L，使用release()函数对输入为L时进行进程锁释放；4.2.15第n个训练节点从conn中接收训练完成信息；

4.2.16转4.2.8；

4.2.17更新old_b＝cur_b，cur_b＝next_b，next_b＝None，使用4.2.11中的嵌入数据交换方法对更新后next_b,old_b进行嵌入数据交换；

4.2.18第n个训练节点从conn中接收训练完成信息，更新old_b＝cur_b，cur_b＝next_b,next_b＝None，使用4.2.11中的嵌入数据交换方法对更新后next_b,old_b进行嵌入数据交换；

4.2.19如果第n个训练节点是主结点，将关系嵌入矩阵θ存储至共享文件系统，转4.2.20；如果第n个训练节点不是主结点，直接转4.2.20；

4.2.20第epoch轮训练结束，令epoch＝epoch+1，转4.2.4；

4.2.21说明第n个训练节点已进行了num_epoch轮训练，得到了训练完成的知识图谱嵌入模型，令训练标记is_training＝False；如果当前节点是主节点，则向锁服务器发送训练结束信息，转第五步，否则直接转第五步。

4.3启动GPU训练进程，在数据加载完成的三元组块上进行模型训练，直至数据加载进程完成所有训练周期的数据加载。N个训练节点的GPU训练进程的工作完全相同，以第n个训练节点的执行过程为例说明，第n个训练节点对分区嵌入向量进行训练的具体方法如下：

4.3.1第n个训练节点进行GPU训练进程的初始化：将is_training，关系嵌入矩阵θ,实体嵌入矩阵列表Embs，和共享参数列表share_paras以及进程间传输管道conn，作为参数传入GPU训练进程的初始化函数中，初始化当前参数序号cur_arg_idx＝0,初始化batch_size＝5000；

4.3.2定义损失函数：

其中，S′_triple是由triple通过负采样得到的三元组集合，λ是超参数，一般设置为0.1，f是2.2中的得分函数。

4.3.3如果is_training为True，转4.3.4；如果is_training为False，则此时训练阶段已经结束，GPU训练进程已经完成任务，因此此时，GPU训练进程结束；

4.3.4令lock,cur_B,EmbsIdx,Triples＝shared_paras[cur_arg_idx],输入lock使用get_lock()函数获取临时变量l，对输入l使用acquire()函数获取是否成功标记is_success，详见https://docs.python.org/3.7/library/multiprocessing.html# multiprocessing.Value,如果is_success＝True，转4.3.5，否则转4.3.4；

4.3.5判断lock的值是否为1，如果是1，说明数据加载进程已经完成相关数据的加载，可以进行训练，转4.3.6，否则使用get_lock()函数对输入为lock时获取临时变量L，对使用release()函数对输入L进行进程锁释放，转4.3.4；

4.3.6令cur_B＝(parth,partt),idxh＝EmbsIdx[parth],idxt＝EmbsIdx[partt],将子三元组列表Triples以及Embs[idxh],Embs[idxt]加载到GPU，Embs[idxh],Embs[idxt]分别表示Embs中第idxh、idxt个矩阵；令已训练三元组的数量triple_idx＝0,令num_triples为Triples的长度。

4.3.7如果triple_idx<num_triples,转4.3.8；否则转4.3.9；

4.3.8令T_batch＝Triples[triple_idx:triple_idx+batch_size]，T_batch表示三元组列表Triples中从第triple_idx个三元组开始到第triple_idx+batch_size个三元组为止的所有三元组组成的列表；从Embs[idxh],Embs[idxt]读取实体嵌入向量，从θ读取关系嵌入向量，计算loss，采用随机梯度下降方法更新Embs[idxh],Embs[idxt],θ；triple_idx＝triple_idx+batch_size；转4.3.7；

4.3.9将训练完的Embs[idxh],Embs[idxt]加载回cpu内存中，通过conn发送训练完成信息给数据加载进程，通知数据加载进程当前三元组块训练完成，可以进行嵌入矩阵的保存；令lock＝0,使用get_lock()函数对输入为lock时获取临时变量L，使用release()函数对输入为L时进行进程锁释放；令cur_arg_idx＝(cur_arg_idx+1)％2，转4.3.3。

第五步，计算集群加载训练后的嵌入模型，基于训练后的嵌入模型进行知识图谱链接预测；方法是：

5.1将N个服务器作为预测节点，选择任意一个服务器(为描述简单，假设为第1个服务器)作为查询节点；将第四步训练后的嵌入模型(即共享文件系统中的实体子分区嵌入矩阵和关系嵌入矩阵)加载到服务器中；具体方法如下：

5.1.1在查询节点中，根据集群中服务器数量N，从共享文件系统中读取subP个实体子分区嵌入矩阵subEmbs¹,subEmbs²,…,subEmbs^ip,…,subEmbs^subP；

5.1.2查询结点将子分区集subpart中的subP个集合，按照subpart中的顺序拼接成实体集E，将对应的subP实体子分区嵌入矩阵在行方向上拼接成实体嵌入矩阵Embs_all，Embs_all为一个num_entities行D列的矩阵；例如：1.3中subpart＝{{e₇,e₄},{e₆,e₂},{e₅,e₃},{e₁,e₀}}重新组合为实体集E＝{e₇,e₄,e₆,e₂,e₅,e₃,e₁,e₀}，subEmbs为4个2行D列矩阵，拼接为一个4×2行D列的实体嵌入矩阵Embs_all。

5.1.3查询结点将实体集E中的元素按照当前顺序均匀分割为N个实体分区Parts₁,…,Parts_N，将实体嵌入矩阵Embs_all在行方向上均匀分割为N个实体分区嵌入矩阵Embs¹,Embs²,…,Embs^N；例如：N＝2，E＝{e₇,e₄,e₆,e₂,e₅,e₃,e₁,e₀}划分为Parts＝{{e₇,e₄,e₆,e₂},{e₅,e₃,e₁,e₀}},Embs_all被划分为2个4行D列的矩阵Embs¹,Embs²；查询节点将实体分区Parts₁,…,Parts_N和实体分区嵌入矩阵Embs¹,Embs²,…,Embs^N分别发送给相应节点，即查询节点将第1个分区Parts_n1和第1个分区嵌入矩阵Embs¹发送给第1个服务器，…，将第n个分区Parts_n和第n个分区嵌入矩阵Embsⁿ发送给第n个服务器，…，将第N个分区Parts_N和第N个分区嵌入矩阵Embs^N发送给第N个服务器；

5.1.4 N台服务器从共享文件系统读取关系嵌入矩阵θ，将θ加载到N台服务器的内存中：以第n个服务器为例，第n个服务器从共享文件系统读取关系嵌入矩阵θ；

5.2进行链接预测，方法是：

5.2.1查询节点接收用户从终端输入的缺失三元组(e_hh,rr,？)，查询节点从矩阵Embs_all读取e_hh的嵌入向量emb_hh，并发送给N个预测节点；

5.2.3 N个服务器并行预测,N个服务器并行预测方法相同，以第n台服务器的预测过程是：

5.2.3.1第n台服务器从分区Part_n取出所有的实体和实体e_hh组成三元组，得到三元组集{(e_hh,rr,e_tt′)|e_tt′∈Part_n}，例如，Part₀＝{{e₇,e₄,e₆,e₂}，得到三元组集{(e_hh,rr,e₇),(e_hh,rr,e₄),(e_hh,rr,e₆),(e_hh,rr,e₂)}。

5.2.3.2按照嵌入模型中的得分函数，计算三元组集中所有三元组的得分，并按照得分对三元组集{(e_hh,rr,e_tt′)|e_tt′∈Part_n}中的元素进行排序，选取{(e_hh,rr,e_tt′)|e_tt′∈Part_n}中得分最大的C(C根据用户需要的返回结果数量设置，一般设置为50)个三元组作为候选三元组集合CT_n,对应的得分集为Score_n,得分集Score_n中的元素为候选三元组集合CT_n中三元组的得分。

5.2.3.3将候选三元组集合CT_n及Score_n发送给查询节点；

5.2.4查询节点接受N个预测节点发送的候选三元组集和得分集，得到CT₁,CT₂,…,CT_n，…，CT_N和Score₁,Score₂,…,Score_n,…Score_N,将CT₁,CT₂,…,CT_n，…，CT_N合并为CT，Score₁,Score₂,…,Score_n,…Score_N合并为Score，CT为C×N个候选三元组，Score为C×N个三元组的得分，按照得分Score对CT进行排序，再次选择出最大的C个候选三元组{(e_hh,rr,e_it)|0≤it<C},e_it表示得分最大的C个候选三元组中第it个三元组组对应的尾实体，C个候选三元组对应的实体集{e_it|0≤it<C}作为链接预测的最终结果，为缺失三元组(e_hh,rr,？)的中缺失实体“？”的候选实体集。例如：用户输入缺失三元组(中国,直辖市,？)查询中国直辖市有哪些，经过以上过程，最终返回候选实体集{北京，上海，天津，重庆，深圳，…，兰州}等50个结果，前四个结果即是用户需要的正确结果。

采用本发明可以达到以下技术效果：

1.快速训练知识图谱嵌入模型。在第四步模型训练过程中，采用多机并行的训练方式，多个服务器同时在不同的三元组上进行嵌入模型训练；在单个服务器内部，使用了基于流水线的数据加载方法，将CPU数据加载和GPU计算并行的方法，有效减少知识图谱分区训练过程中因数据加载造成的时间开销，提高了GPU利用率。通过多机并行训练和流水线数据加载，缩短了知识图谱嵌入的训练时间；由于知识图谱预测方法均要采用嵌入模型，而模型训练占用了预测过程的大部分时间，训练时间缩短可大大减少预测时间。

2.快速获取链接预测的查询结果。第五步通过将知识图谱嵌入模型分别部署到多台服务器中，对于输入的缺失三元组，将候选三元组的得分函数计算分配到多台服务器上进行并行预测，缩短了链接预测的时间；

3.提高了分区训练的嵌入质量。大规模知识图谱训练中，存在分区造成的嵌入性能下降问题。在第四步模型训练过程中，每次开始新的训练周期，锁服务器生成分区到子分区的随机映射，从而将子分区组合成分区，在不同训练周期之间生成不同的分区组合，提高了训练数据的随机性，从而最终提高了嵌入的质量；

总之，本发明既加快了大规模知识图谱链接预测，又解决了分区造成的嵌入性能下降问题，能够快速获得高质量的知识图谱嵌入，实现了基于知识图谱嵌入的高效连接预测。

附图说明：

图1为本发明整体流程图；

图2为本发明训练时知识图谱链接预测系统逻辑结构图(为了显示清楚，图中只标注了第n个训练节点与主节点的数据传输，其他训练节点与第n个节点的数据传输完全相同)；

图3为本发明预测时知识图谱链接预测系统逻辑结构图(为了显示清楚，图中只标注了第n个预测节点与查询节点的数据传输，其他预测节点与第n个节点的数据传输完全相同)；

图4为本发明第四步在不同服务器数量下的训练时间和PBG方法的训练时间对比图；

图5为本发明在fb15k数据集上进行链接预测的测试结果和PBG方法的对比图。

具体实施方式：

如图1所示，本发明包括以下步骤：

第一步：对知识图谱进行分区；根据需要确定分区数量P和每个分区的子分区数量PP，将所有的实体分为subP个不重叠的子分区，subP＝P×PP，子分区为实体集E的互不重叠的子集，分区为PP个子分区的并集；将所有的三元组根据其头实体和尾实体所在子分区划分为不同的子三元组块；方法是：

1.1输入知识图谱数据，得到实体集E，关系集R，三元组集T，实体数量num_entities，E中包含num_entities个实体，num_entities为正整数，T中包含num_triples个三元组，num_triples为正整数。例如：输入8个实体，2个关系的知识图谱，则E＝{e₀,e₁,e₂,e₃,e₄,e₅,e₆,e₇}，e₀,e₁,e₂,e₃,e₄,e₅,e₆,e₇均为实体，R＝{r₀,r₁}，r₀,r₁分别为关系，三元组集T＝{(e₁,r₀,e₄),(e₁,r₀,e₆),(e₂,r₁,e₆),(e₂,r₀,e₃)，(e₅,r₀,e₄),(e₆,r₀,e₄),(e₁,r₀,e₇),(e₆,r₁,e₄),(e₇,r₀,e₄),(e₃,r₀,e₇),(e₂,r₁,e₄),(e₄,r₁,e₃),(e₂,r₁,e₄),(e₃,r₀,e₆),(e₄,r₁,e₆),(e₇,r₀,e₃)}，num_entities＝8，num_triples＝16。

1.2设置超参数嵌入向量维度D、分区数量P、每个分区包含的子分区数量PP，得到总的子分区数量subP＝P×PP，计算实体子分区大小subpart_size，subpart_size＝num_entities/subP；其中嵌入向量维度D设置为400，P的设置和总实体嵌入大小与GPU显存大小有关，总实体嵌入的大小为num_entities×D×4，P满足：2×总实体嵌入大小/P<GPU显存大小，PP为2。

1.3将实体集E随机打乱，然后按照子分区大小subpart_size将实体分割成subP个子分区集subpart，subpart中共有subP个实体子分区，每个实体子分区中含subpart_size个实体。

1.4遍历三元组集T所有的三元组，根据三元组头实体和尾实体所属的分区，将三元组划分到对应的子三元组块中，得到subP²个子三元组块组成的子三元组块集合subBuckets，subBuckets＝{subBucket(i2,j2)|1<i2,j2≤subP}，其中(i2,j2)为子三元组块的编号，表示该三元组块中所有三元组的头实体来自第i2实体子分区，尾实体来自第j2实体子分区，subBucket(i2,j2)表示编号为(i2,j2)的子三元组块；方法是：

1.4.1初始化变量k1＝1，初始化子三元组块集合subBuckets,令subBuckets中所有的子三元组块均为空集，即令subBucket(1,1),…,subBucket(i2,j2),…,subBucket(subP,subP)均为空集；

1.4.2从T中取出第k1个三元组(e_h,r,e_t)，0≤h,t≤num_entities-1；根据1.3获得的subpart获取e_h所属子分区序号ih，e_t所属子分区序号it，1≤ih,it≤subP，将三元组(e_h,r,e_t)添加到subBucket(ih,it)中，r∈R；

1.4.3令k1＝k1+1；如果k1≤num_triples，转1.4.2；如果k1>num_tripkes，表示T中所有三元组均被划分到对应的子三元组块中，得到了子三元组块集合subBuckets，将子三元组块集合中所有的三元组块存储至共享文件系统，转第二步。

第二步：构建嵌入模型。主要分为二步，表示实体、关系；定义得分函数。表示实体、关系：嵌入模型采用嵌入向量表示实体和关系，嵌入模型的参数由实体嵌入向量和关系嵌入向量构成；得分函数：得分函数定义了如何使用实体和关系嵌入计算三元组得分；具体为：

2.1用向量表示实体和关系；方法是：

2.1.1将知识图谱中的每个实体表示为一个实体嵌入向量,实体嵌入向量是一个长度为D的向量，向量的值随机初始化为从标准正态分布的随机数。按照1.3中的子分区集subpart，每个实体子分区包含subpart_size个实体，每个实体有一个实体嵌入向量，共subpart_size个实体嵌入向量，将实体嵌入向量作为实体子分区嵌入矩阵行向量，按照实体子分区内实体顺序组成一个subpart_size行D列的实体子分区嵌入矩阵；subP个实体子分区共组成subP个实体子分区嵌入矩阵，即subEmbs¹,sunEmbs²,…,subEmbs^ip,…,sunEmbs^subP，sunEmbs^ip为第ip个实体子分区subpart_ip的嵌入矩阵，有subpart_size行D列；将subP个实体子分区嵌入矩阵存储至共享文件系统。例如,对于1.3中的E＝{e₀,e₁,e₂,e₃,e₄,e₅,e₆,e₇}，对应的实体嵌入向量为Emb₀,Emb₁,Emb₂,Emb₃,Emb₄,Emb₅,Emb₆,Emb₇，实体子分区subpart₁＝{e₇,e₄}，则subEmb¹为subpart₁的实体子分区嵌入矩阵，矩阵的第1行为Emb₇,第二行为Emb₄,对每个实体子分区都得到一个实体子分区嵌入矩阵，共得到4个实体子分区嵌入矩阵；

2.1.2将知识图谱中的每个关系表示为一个关系嵌入向量，关系嵌入向量是一个长度为D的向量，向量的值随机初始化为从标准正态分布的随机数，将关系嵌入向量作为关系嵌入矩阵行向量，按照关系集内关系顺序组成关系嵌入矩阵θ，将θ存储至共享文件系统；例如,对于R＝{r₀,r₁}，对应的关系嵌入向量为θ₁,θ₂，得到关系关系嵌入矩阵θ，θ是一个2行D列的矩阵，其行向量分别为θ₁,θ₂。

2.2定义得分函数：

f(triple)＝f(e_h,r,e_t)＝sim(g(Emb_h,θr),g(Emb_d,θr))

其中sim(a,b)为相似度计算函数，用于计算两个向量a,b之间的相似度：

g为关系算子函数，用于计算实体嵌入向量Emb_h经过关系r变换后的向量：

g(Emb_h,θr)＝Emb_h⊙θr

triple＝(e_h,r,e_t)表示一个三元组，Emb_h为实体e_h的嵌入向量，θr为关系r的嵌入向量，⊙表示哈达玛积，

表示a,

的复数点积，

为b的共轭复数。由实体子分区嵌入矩阵、关系嵌入矩阵、得分函数共同组成了嵌入模型。

第三步，构建知识图谱链接预测系统。整个系统在训练时的逻辑图如图2所示，在预测时的逻辑图如图3所示由计算集群(包含N个服务器)和共享文件系统组成，N个服务器均包含CPU和GPU，N为正整数。

共享文件系统是计算集群的共享磁盘，负责存储实体子分区嵌入矩阵、关系嵌入矩阵θ、以及三元组块。共享文件系统至少具备2TB以上的存储空间，具备10Gb/s以上的读写速度。

N个服务器与共享文件系统相连，从共享文件系统获取嵌入模型，负责对嵌入模型进行训练，并对用户输入的要预测的实体缺失的三元组(简称缺失三元组)，使用训练后的嵌入模型进行链接预测，得到预测结果。

对嵌入模型训练时，每个服务器都是一个训练节点，从训练节点中选择一个作为主节点；主节点也是训练节点，除了运行训练节点的所有进程外，还要运行锁服务器进程，训练节点运行数据加载进程和GPU训练进程。数据加载进程负责从共享文件系统中读取和写入实体子分区嵌入矩阵、关系嵌入矩阵；链接预测时，每个服务器作为一个预测节点，从预测节点选择一个作为查询节点(比预测节点多了查询功能)，各预测节点从共享文件系统加载训练后的嵌入模型，从查询节点获取用户输入即要预测的实体缺失的三元组(简称缺失三元组)，然后使用嵌入模型进行预测。

第四步，采用多机并行和CPU、GPU并行对嵌入模型进行分布式训练，将计算集群中的所有N个服务器作为训练节点，训练节点安装有数据加载进程和GPU训练进程，数据加载进程和GPU训练进程配合完成对嵌入模型的训练；从训练节点中任选一个作为主节点，主结点安装有锁服务进程；主节点的锁服务进程按4.1的流程对三元组块进行调度，同时N个训练节点的数据加载进程按4.2的流程进行数据加载，同时N个训练节点的GPU训练进程按4.3的流程进行训练，4.1、4.2、4.3并行进行，完成分布式训练，得到训练后的嵌入模型；训练时知识图谱链接预测系统逻辑结构图如图2所示；方法是：

4.1主节点启动锁服务器进程，锁服务器进程调度每个训练节点(含主节点)进行训练所需的三元组块；调度方法如下：

4.1.1锁服务器进程初始化活动列表active和完成列表done，active和done初始值都为空，active保存当前正在训练的三元组块编号，done保存已经训练完的三元组块编号；初始化三元组块总数num_buckets＝P²,P为分区数量。

4.1.2锁服务器进程接收N个训练节点发送来的信息，按照先到先得的顺序进行处理；如果信息为开始新的训练周期，转4.1.3；如果信息为请求三元组块，转4.1.4；如果信息为释放三元组块，转4.1.5；如果信息为结束训练，结束锁服务器进程，此时训练阶段已经结束，数据加载进程不再需要锁服务进程的服务，因此此时锁服务器进程结束；

4.1.3新的训练周期开始，清空active和done，生成从分区到子分区的随机映射maps，并将maps发送到N个训练节点；转4.1.2；

4.1.4为训练节点生成可训练的三元组块编号，得到可训练三元组编号res_bucket，并更新活动列表active和完成列表done。具体方法是：

4.1.4.1将所有三元组编号添加到三元组块编号列表acquirable_buckets中，具体方法是：初始化三元组块编号列表acquirable_buckets，列表元素为满足1≤m≤subP，1≤n≤subP的所有二元组(m,n)，m和n分别代表三元组头实体和尾实体所在分区序号；

4.1.4.2若active为空，转4.1.4.4，若active不为空，转4.1.4.3；

4.1.4.3令分区序号集active_part为空集合，从active中取出所有的二元组，将所有二元组中的分区序号添加到active_part中，对于acquirable_buckets中的二元组，如果二元组中任意元素在active_part中，则将该二元组从acquirable_buckets中去除，转4.1.4.4；

4.1.4.4如果done为空，转4.1.4.6；如果done不为空，转4.1.4.5；

4.1.4.5将done列表中的三元组块编号从acquirable_buckets中去除；

4.1.4.6如果acquirable_buckets不为空，转4.1.4.7，如果acquirable_buckets为空，转4.1.4.8；

4.1.4.7随机从acquirable_buckets选择一个三元组块编号，令临时变量res_bucket＝选择的这个三元组块编号，并将res_bucket添加到done和active中；转4.1.4.9；

4.1.4.8令临时变量res_bucket＝None；

4.1.4.9计算未训练三元组块数量remaining＝num_bucket-num_done,num_done为done中元素个数，num_bucket＝P²；将res_bucket和remaining发送给请求训练结点；转4.1.2；

4.1.5将释放三元组块信息中的三元组编号从active移除；转4.1.2；

4.2在N台训练节点上启动数据加载进程，N个训练节点的数据加载进程的流程完全相同，以第n个训练节点的流程为例说明，第n个训练节点进行数据加载的方法如下：

4.2.1在内存中创建4个PP×subpart_size行D列的矩阵Embs₁,Embs₂,Embs₃,Embs₄，矩阵元素值初始化为0，令实体嵌入矩阵列表Embs＝[Embs₁,Embs₂,Embs₃,Embs₄],令空闲矩阵序号列表free_idxs＝[0,1,2,3]；创建2个int类型进程间共享变量lock₁＝0，lock₂＝0；创建2个三元组块编号curB₁＝(0,0),curB₂＝(0,0)；创建2个实体嵌入矩阵序号列表EmbsIdx₁，EmbsIdx₂,分别初始化为长度为P的列表，列表元素均为0；创建2个三元组列表Triples₁,Triples₂,初始化为空；创建进程间传输管道conn，用于进程间数据传输,其数据类型为Pipe，创建训练标记is_training，初始化为True，类型为bool；创建共享参数列表shared_paras，shared_paras中包含两组共享参数，令shared_paras＝[(lock₁,curB₁,EmbsIdx₁,Triples₁),(lock₂,curB₂,EmbsIdx₂,Triples₂)]；

4.2.2从共享文件系统中读取关系嵌入矩阵θ，在第n个训练节点中启动参数服务器，参数服务器负责将关系嵌入矩阵θ在N个训练节点之间进行同步；

4.2.3令当前训练周期数epoch＝1，获取用户定义的总训练周期数num_epoch(设为30)；

4.2.4如果epoch≤num_epoch，转4.2.5，否则转4.2.21；

4.2.5如果第n个训练节点为主结点，向锁服务器进程发送开始新的训练周期信息，转4.2.6；如果第n个训练节点不是主结点，直接转4.2.6；

4.2.6判断是否从锁服务器进程接收到分区到子分区的映射关系maps，若接收到maps，转4.2.7；若未收到maps，转4.2.6继续等待；

4.2.7第n个训练节点开始第epoch轮训练周期的训练，初始化第epoch轮训练周期三元组块编号cur_b＝None,next_b＝None,old_b＝None，next_arg_idx＝0；cur_b是第epoch轮正在训练的三元组块编号，next_b是待加载的三元组块编号，old_b是已经训练完成的三元组块编号，next_arg_idx是用于加载的共享参数shared_paras的序号；

4.2.8从共享参数列表中取出第next_arg_idx+1个元素(即用于加载的共享参数)：令lock,curB,EmbsIdx,Triples＝shared_paras[next_arg_idx]；使用get_lock()函数对输入为lock时获取临时变量L，使用acquire()函数对输入为L时获取是否成功标记is_success,如果is_success＝True，转4.2.9，否则转4.2.8；

4.2.9判断lock的值是否为0，如果是0，说明此时GPU训练进程已完成，共享参数curB,EmbsIdx,Triples没有被GPU训练进程使用，可以进行数据加载，转4.2.10；否则，使用get_lock()函数对输入为lock时获取临时变量L，使用release()函数对输入为L时进行进程锁释放，转4.2.8；

4.2.10向锁服务器进程发送获取三元组块请求，从主节点得到res_bucket和remaining；如果res_bucket为None且remaining为0，转4.2.17；如果res_bucket为None且remaining不为0，转4.2.10；如果res_bucket不为None，更新old_b＝cur_b，cur_b＝next_b，next_b＝res_bucket，转4.2.11；

4.2.11在内存和共享文件系统之间采用嵌入数据交换方法对next_b和old_b进行分区嵌入矩阵数据交换，方法是：

4.2.11.1如果next_b不等于None，更新cur_B＝next_b,转4.2.11.2；否则转4.2.11.3；

4.2.11.2加载next_b中的分区嵌入向量：next_b的值为(Parth,Partt)，对于二元组(Parth,Partt)中的任一元素p，从free_idxs弹出idx，idx表示空闲矩阵的序号，EmbsIdx[p]表示实体嵌入矩阵序号列表EmbsIdx的第p个元素，令EmbsIdx[p]＝idx；由4.1.3中的映射maps得到maps[p]＝[sp1,sp2,…spPP]，即分区p由子分区sp1,sp2,…spPP组成，从共享文件系统分别读取对应的实体子分区嵌入矩阵subEmbs^sp1,subEmbs^sp2,…，subEmbs^spPP拼接并保存至Embs[idx]；

4.2.11.3如果old_b不等于None，转4.2.11.4；否则转4.2.12；

4.2.11.4保存old_b中的分区嵌入向量：old_b的值为(Parth,Partt)，对于二元组(Parth,Partt)中的任一元素p，令idx＝EmbsIdx[p]，将idx放回从free_idxs；由4.1.3中的映射maps得到maps[p]＝[sp1,sp2,…spPP]，按照[sp1,sp2,…,spPP]各子分区大小，将分区嵌入矩阵Embs[idx]按行切分为subEmbs^sp1,subEmbs^sp2,…，subEmbs^spPP,并将subEmbs^sp1,subEmbs^sp2,…，subEmbs^spPP保存到共享文件系统中；向锁服务器进程发送释放三元组块old_b信息；

4.2.12从共享文件系统中加载next_b三元组块到内存。Parth,Partt分别为三元组编号next_b的第1个和第2个整数，从maps获取分区Parth和Parth对应的子分区：maps[Parth]＝[sh1,sh2,…shPP]，maps[Partt]＝[st1,st2,…,stPP]；从共享文件系统中加载子分区对应的子三元组块{subBuckets[i3,j3]|i3∈maps[Parth],j3∈maps[Partt]}，并重组为next_b三元组块Bucket,将Bucket保存至Triples；更新共享参数cur_B＝next_b；

4.2.13令lock＝1,令next_arg_idx＝(next_arg_idx+1)％2；

4.2.14使用get_lock()函数对输入为lock时获取临时变量L，使用release()函数对输入为L时进行进程锁释放；

4.2.15第n个训练节点从conn中接收训练完成信息；

4.2.16转4.2.8；

4.2.17更新old_b＝cur_b，cur_b＝next_b,next_b＝None，使用4.2.11中的嵌入数据交换方法对更新后next_b,old_b进行嵌入数据交换；

4.2.18第n个训练节点从conn中接收训练完成信息，更新old_b＝cur_b，cur_b＝next_b，next_b＝None，使用4.2.11中的嵌入数据交换方法对更新后next_b,old_b进行嵌入数据交换；

4.2.19如果第n个训练节点是主结点，将关系嵌入矩阵θ存储至共享文件系统，转4.2.20；如果第n个训练节点不是主结点，直接转4.2.20；

4.2.20第epoch轮训练结束，令epoch＝epoch+1，转4.2.4；

4.2.21说明第n个训练节点已进行了num_epoch轮训练，得到了训练完成的知识图谱嵌入模型，令训练标记is_training＝False；如果当前节点是主节点，则向锁服务器发送训练结束信息，转第五步，否则直接转第五步。

4.3启动GPU训练进程，在数据加载完成的三元组块上进行模型训练，直至数据加载进程完成所有训练周期的数据加载。N个训练节点的GPU训练进程的工作完全相同，以第n个训练节点的执行过程为例说明，第n个训练节点对分区嵌入向量进行训练的具体方法如下：

4.3.1第n个训练节点进行GPU训练进程的初始化：将is_training，关系嵌入矩阵θ,实体嵌入矩阵列表Embs，和共享参数列表share_paras以及进程间传输管道conn，作为参数传入GPU训练进程的初始化函数中，初始化当前参数序号cur_arg_idx＝0,初始化batch_size＝5000；

4.3.2定义损失函数：

其中，S_t′_riple是由triple通过负采样得到的三元组集合，λ是超参数，一般设置为0.1，f是2.2中的得分函数。

4.3.3如果is_training为True，转4.3.4；如果is_training为False，则此时训练阶段已经结束，GPU训练进程已经完成任务，因此此时，GPU训练进程结束；

4.3.4令lock,cur_B,EmbsIdx,Triples＝shared_paras[cur_arg_idx],输入lock使用get_lock()函数获取临时变量l，对输入l使用acquire()函数获取是否成功标记is_success，详见https://docs.python.org/3.7/library/multiprocessing.html# multiprocessing.Value,如果is_success＝True，转4.3.5，否则转4.3.4；

4.3.5判断lock的值是否为1，如果是1，说明数据加载进程已经完成相关数据的加载，可以进行训练，转4.3.6，否则使用get_lock()函数对输入为lock时获取临时变量L，对使用release()函数对输入L进行进程锁释放，转4.3.4；

4.3.6令(parth,partt)＝cur_B,idxh＝EmbsIdx[parth],idxt＝EmbsIdx[partt],将子三元组列表Triples以及Embs[idxh],Embs[idxt]加载到GPU，Embs[idxh],Embs[idxt]分别表示Embs中第idxh、idxt个矩阵；令已训练三元组的数量triple_idx＝0,令num_triples为Triples的长度。

4.3.7如果triple_idx<num_triples,转4.3.8；否则转4.3.9；

4.3.8令T_batch＝Triples[triple_idx:triple_idx+batch_size]，T_batch表示三元组列表Triples中从第triple_idx个三元组开始到第triple_idx+batch_size个三元组为止的所有三元组组成的列表；从Embs[idxh],Embs[idxt]读取实体嵌入向量，从θ读取关系嵌入向量，计算loss，采用随机梯度下降方法更新Embs[idxh],Embs[idxt],θ；triple_idx＝triple_idx+batch_size；转4.3.7；

4.3.9将训练完的Embs[idxh],Embs[idxt]加载回cpu内存中，通过conn发送训练完成信息给数据加载进程，通知数据加载进程当前三元组块训练完成，可以进行嵌入矩阵的保存；令lock＝0,使用get_lock()函数对输入为lock时获取临时变量L，使用release()函数对输入为L时进行进程锁释放；令cur_arg_idx＝(cur_arg_idx+1)％2，转4.3.3。

第五步，计算集群加载训练后的嵌入模型，基于训练后的嵌入模型进行知识图谱链接预测；此时知识图谱链接预测系统的逻辑结构图如图3所示，方法是：

5.1将N个服务器作为预测节点，选择任意一个服务器(为描述简单，假设为第1个服务器)作为查询节点；将第四步训练后的嵌入模型(即共享文件系统中的实体子分区嵌入矩阵和关系嵌入矩阵)加载到服务器中；具体方法如下：

5.1.1在查询节点中，根据集群中服务器数量N，从共享文件系统中读取subP个实体子分区嵌入矩阵subEmbs¹,subEmbs²,…,subEmbs^ip,…,subEmbs^subP；

5.1.2查询结点将子分区集subpart中的subP个集合，按照subpart中的顺序拼接成实体集E，将对应的subP实体子分区嵌入矩阵在行方向上拼接成实体嵌入矩阵Embs_all，Embs_all为一个num_entities行D列的矩阵；

5.1.3查询结点将实体集E中的元素按照当前顺序均匀分割为N个实体分区Parts₁,…,Parts_N，将实体嵌入矩阵Embs_all在行方向上均匀分割为N个实体分区嵌入矩阵Embs¹,Embs²,…,Embs^N；查询节点将实体分区Parts₁,…,Parts_N和实体分区嵌入矩阵Embs¹,Embs²,…,Embs^N分别发送给相应节点，即查询节点将第1个分区Parts₁和第1个分区嵌入矩阵Embs¹发送给第1个服务器，…，将第n个分区Parts_n和第n个分区嵌入矩阵Embsⁿ发送给第n个服务器，…，将第N个分区Parts_N和第N个分区嵌入矩阵Embs^N发送给第N个服务器；

5.1.4 N台服务器从共享文件系统读取关系嵌入矩阵θ，将θ加载到N台服务器的内存中：以第n个服务器为例，第n个服务器从共享文件系统读取关系嵌入矩阵θ；

5.2进行链接预测，方法是：

5.2.1查询节点接收用户从终端输入的缺失三元组(e_hh,rr,？)，查询节点从矩阵Embs_all读取e_hh的嵌入向量emb_hh，并发送给N个预测节点；

5.2.3 N个服务器并行预测,N个服务器并行预测方法相同，以第n台服务器的预测过程是：

5.2.3.1第n台服务器从分区Part_n取出所有的实体和实体e_hh组成三元组，得到三元组集{(e_hh,rr,e_tt′)|e_tt′∈Part_n}，例如，Part₀＝{{e₇,e₄,e₆,e₂}，得到三元组集{(e_hh,rr,e₇),(e_hh,rr,e₄),(e_hh,rr,e₆),(e_hh,rr,e₂)}。

5.2.3.2按照嵌入模型中的得分函数，计算三元组集中所有三元组的得分，并按照得分对三元组集{(e_hh,rr,e_tt′)|e_tt′∈Part_n}中的元素进行排序，选取{(e_hh,rr,e_tt′)||e_tt′∈Part_n}中得分最大的C(C根据用户需要的返回结果数量设置，一般设置为50)个三元组作为候选三元组集合CT_n,对应的得分集为Score_n,得分集Score_n中的元素为候选三元组集合CT_n中三元组的得分。

5.2.3.3将候选三元组集合CT_n及Score_n发送给查询节点；

5.2.4查询节点接受N个预测节点发送的候选三元组集和得分集，得到CT₁,CT₂,…,CT_n，…，CT_N和Score₁,Score₂,…,Score_n,…Score_N,将CT₁,CT₂,…,CT_n，…，CT_N合并为CT，Score₁,Score₂,…,Score_n,…Score_N合并为Score，CT为C×N个候选三元组，Score为C×N个三元组的得分，按照得分Score对CT进行排序，再次选择出最大的C个候选三元组{(e_hh,rr,e_it)|0≤it<C},e_it表示得分最大的C个候选三元组中第it个三元组组对应的尾实体，C个候选三元组对应的实体集{e_it|0≤it<C}作为链接预测的最终结果，为缺失三元组(e_hh,rr,？)的中缺失实体“？”的候选实体集。

采用本发明可以加快知识图谱嵌入模型的训练速度，缩短模型训练时间。为验证本发明的效果，进行以下实验：在由4台服务器组成的集群上进行，每台机器每台配置1颗Intel Xeon 2650v4处理器，1块NVIDIA Tesla P100 GPU加速卡，共享文件系统可用容量为500G，读写速度为10Gb/s。图4是本发明第三步模型训练时间和PBG方法对比图，横轴为系统中的服务器数量N，纵轴为训练时间，阴影表示PBG方法，空白表示本发明，定义训练加速比为本发明比PBG方法减少的训练时间与PBG方法训练时间的比值，可以看到在使用1、2、3、4台服务器进行训练的情况下，本发明相对于PBG方法的加速比分别为35％，47％，41％，40％。比，本发明在不同服务器数量的使用场景下均有效缩短了训练时间。

同时，该实验还验证了本发明可有效提升嵌入模型进行链接预测的准确性，本发明在不同分区数量下对fb15k数据集中的测试集进行连接预测结果，hit@10表示前10个预测结果包含正确结果的概率，对于测试集中的每一个三元组，分别使用头实体和关系预测尾实体，使用尾实体和关系预测头实体,统计所有预测中前10个预测结果包含正确结果的概率，即hit@10。图5为预测结果图，横轴表示分区数量(即第一步中的P)，纵轴表示hit@10，因为分区重组可以解决分区训练中数据分布变化导致的模型性能下降问题，本发明相对于PBG方法有效提升了链接预测的精度，当分区数量为1，即不进行分区时，本发明和PBG方法效果基本相同，但是在实际应用中，因为工业知识图谱的实体数量极大，分区是进行模型训练的必要选择，所以往往分区数量大于1，在分区数量大于1的情况下，本发明相对于PBG具有明显的提升效果。

Claims (10)

1.一种基于知识图谱嵌入的链接预测方法，其特征在于包括以下步骤：

第一步：对知识图谱进行分区；根据需要确定分区数量P和每个分区的子分区数量PP，将所有的实体分为subP个不重叠的子分区，subP＝P×PP，子分区为实体集E的互不重叠的子集，分区为PP个子分区的并集；将所有的三元组根据其头实体和尾实体所在子分区划分为不同的子三元组块；方法是：

步骤1.1输入知识图谱数据，得到实体集E，关系集R，三元组集T，实体数量num_entities，E中包含num_entities个实体，num_entities为正整数，T中包含num_triples个三元组，num_triples为正整数；

步骤1.2设置超参数嵌入向量维度D、分区数量P、每个分区包含的子分区数量PP，得到总的子分区数量subP＝P×PP，计算实体子分区大小subpart_size，subpart_size＝num_entities/subP；

步骤1.3将实体集E随机打乱，然后按照子分区大小subpart_size将实体分割成subP个子分区集subpart，subpart中共有subP个实体子分区，每个实体子分区中含subpart_size个实体；

步骤1.4遍历三元组集T所有的三元组，根据三元组头实体和尾实体所属的分区，将三元组划分到对应的子三元组块中，得到subP²个子三元组块组成的子三元组块集合subBuckets，subBuckets＝{subBucket(i2，j2)|1＜i2，j2≤subP}，其中(i2，j2)为子三元组块的编号，表示该三元组块中所有三元组的头实体来自第i2实体子分区，尾实体来自第j2实体子分区，subBucket(i2，j2)表示编号为(i2，j2)的子三元组块，将子三元组块集合中所有的三元组块存储至共享文件系统；

第二步：构建嵌入模型；方法是先表示实体、关系：嵌入模型采用嵌入向量表示实体和关系，将实体嵌入向量作为实体子分区嵌入矩阵行向量，将关系嵌入向量作为关系嵌入矩阵行向量，嵌入模型的参数由实体嵌入向量和关系嵌入向量构成；再定义得分函数：得分函数定义了如何使用实体和关系嵌入计算三元组得分；由实体子分区嵌入矩阵、关系嵌入矩阵、得分函数共同组成嵌入模型；

第三步，构建知识图谱链接预测系统；知识图谱链接预测系统由包含N个服务器的计算集群和共享文件系统组成，N个服务器均包含CPU和GPU，N为正整数；

共享文件系统是计算集群的共享磁盘，负责存储实体子分区嵌入矩阵、关系嵌入矩阵θ、以及三元组块；

N个服务器与共享文件系统相连，从共享文件系统获取嵌入模型，负责对嵌入模型进行训练，并对用户输入的要预测的实体缺失的三元组即缺失三元组，使用训练后的嵌入模型进行链接预测，得到预测结果；

对嵌入模型训练时，每个服务器都是一个训练节点，从训练节点中选择一个作为主节点；主节点也是训练节点，除了运行训练节点的所有进程外，还要运行锁服务器进程，训练节点运行数据加载进程和GPU训练进程；数据加载进程负责从共享文件系统中读取和写入实体子分区嵌入矩阵、关系嵌入矩阵；链接预测时，每个服务器作为一个预测节点，从预测节点选择一个作为查询节点，各预测节点从共享文件系统加载训练后的嵌入模型，从查询节点获取用户输入的缺失三元组，然后使用嵌入模型进行预测；

第四步，采用多机并行和CPU、GPU并行对嵌入模型进行分布式训练，将计算集群中的所有N个服务器作为训练节点，训练节点安装有数据加载进程和GPU训练进程，数据加载进程和GPU训练进程配合完成对嵌入模型的训练；从训练节点中任选一个作为主节点，主结点安装有锁服务进程；主节点的锁服务进程按步骤4.1的流程对三元组块进行调度，同时N个训练节点的数据加载进程按步骤4.2的流程进行数据加载，同时N个训练节点的GPU训练进程按步骤4.3的流程进行训练，步骤4.1、步骤4.2、步骤4.3并行进行，完成分布式训练，得到训练后的嵌入模型；方法是：

步骤4.1主节点启动锁服务器进程，锁服务器进程调度每个训练节点进行训练所需的三元组块；调度方法如下：

步骤4.1.1锁服务器进程初始化活动列表active和完成列表done，active和done初始值都为空，active保存当前正在训练的三元组块编号，done保存已经训练完的三元组块编号；初始化三元组块总数num_buckets＝P²，P为分区数量；

步骤4.1.2锁服务器进程接收N个训练节点发送来的信息，按照先到先得的顺序进行处理；如果信息为开始新的训练周期，转步骤4.1.3；如果信息为请求三元组块，转步骤4.1.4；如果信息为释放三元组块，转步骤4.1.5；如果信息为结束训练，结束锁服务器进程；

步骤4.1.3新的训练周期开始，清空active和done，生成从分区到子分区的随机映射maps，并将maps发送到N个训练节点；转步骤4.1.2；

步骤4.1.4为训练节点生成可训练的三元组块编号，得到可训练三元组编号res_bucket，并更新活动列表active和完成列表done；

步骤4.1.5将释放三元组块信息中的三元组编号从active移除；转步骤4.1.2；

步骤4.2在N台训练节点上启动数据加载进程，N个训练节点的数据加载进程的流程完全相同，第n个训练节点进行数据加载的方法如下：

步骤4.2.1在内存中创建4个PP×subpart_size行D列的矩阵Embs₁，Embs₂，Embs₃，Embs₄，矩阵元素值初始化为0，令实体嵌入矩阵列表Embs＝[Embs₁，Embs₂，Embs₃，Embs₄]，令空闲矩阵序号列表free_idxs＝[0，1，2，3]；创建2个int类型进程间共享变量lock₁＝0，lock₂＝0；创建2个三元组编号curB₁＝(0，0)，curB₂＝(0，0)；创建2个实体嵌入矩阵序号列表EmbsIdx₁，EmbsIdx₂，分别初始化为长度为P的列表，列表元素均为0；创建2个三元组列表Triples₁，Triples₂，初始化为空；创建进程间传输管道conm，用于进程间数据传输，其数据类型为Pipe，创建训练标记is_training，初始化为True，类型为bool；创建共享参数列表shared_paras，shared_paras中包含两组共享参数，令shared_paras＝[(lock₁，curb₁，EmbsIdx₁，Triples₁)，(lock₂，curB₂，EmbsIdx₂，Triples₂)]；

步骤4.2.2从共享文件系统中读取关系嵌入矩阵θ，在第n个训练节点中启动参数服务器，参数服务器负责将关系嵌入矩阵θ在N个训练节点之间进行同步；

步骤4.2.3令当前训练周期数epoch＝1，获取用户定义的总训练周期数hum_epoch，num_epoch为正整数；

步骤4.2.4如果epoch≤hum_epoch，转步骤4.2.5，否则转步骤4.2.21；

步骤4.2.5如果第n个训练节点为主结点，向锁服务器进程发送开始新的训练周期信息，转步骤4.2.6；如果第n个训练节点不是主结点，直接转步骤4.2.6；

步骤4.2.6判断是否从锁服务器进程接收到分区到子分区的映射关系maps，若接收到maps，转步骤4.2.7；若未收到maps，转步骤4.2.6继续等待；

步骤4.2.7第n个训练节点开始第epoch轮训练周期的训练，初始化第epoch轮训练周期三元组块编号cur_b＝None，next_b＝None，old_b＝None，next_arg_idx＝0；cur_b是第epoch轮正在训练的三元组块编号，next_b是待加载的三元组块编号，old_b是已经训练完成的三元组块编号，next_arg_idx是用于加载的共享参数在shared_paras中的序号；

步骤4.2.8从共享参数列表中取出第next_arg_idx+1个元素：令lock，curB，EmbsIdx，Triples＝shared_paras[next_arg_idx]＝shared_paras[next_arg_idx]；使用get_lock()函数对输入为lock时获取临时变量L，使用acquire()函数对输入为L时获取是否成功标记is_success，如果is_success＝True，转步骤4.2.9，否则转步骤4.2.8；

步骤4.2.9判断lock的值是否为0，如果是0，转步骤4.2.10；否则，使用get_lock()函数对输入为lock时获取临时变量L，使用release()函数对输入为L时进行进程锁释放，转步骤4.2.8；

步骤4.2.10向锁服务器进程发送获取三元组块请求，从主节点得到res_bucket和未训练三元组块数量remaining；如果res_bucket为None且remaining为0，转步骤4.2.17；如果res_bucket为None且remaining不为0，转步骤4.2.10；如果res_bucket不为None，更新old_b＝cur_b，cur_b＝next_b，next_b＝res_bucket，转步骤4.2.11；

步骤4.2.11在内存和共享文件系统之间采用嵌入数据交换方法对next_b和old_b进行分区嵌入矩阵数据交换；

步骤4.2.12从共享文件系统中加载next_b三元组到内存；Parth，Partt分别为三元组编号next_b的第1个和第2个整数，从maps获取分区Parth和Parth对应的子分区：maps[Parth]＝[sh1，sh2，...shPP]，maps[Partt]＝[st1，st2，...，stPP]；从共享文件系统中加载子分区对应的子三元组块{subBuckets[i3，j3]|i3∈maps[Parth]，j3∈maps[Partt]}，并重组为next_b三元组块Bucket，将Bucket保存至Triples；更新共享参数cur_B＝next_b；

步骤4.2.13令lock＝1，令next_arg_idx＝(next_arg_idx+1)％2；

步骤4.2.14使用get_lock()函数对输入为lock时获取临时变量L，使用release()函数对输入为L时进行进程锁释放；

步骤4.2.15第n个训练节点从conn中接收训练完成信息；

步骤4.2.16转步骤4.2.8；

步骤4.2.17更新old_b＝cur_b，cur_b＝next_b，next_b＝None，使用步骤4.2.11中的嵌入数据交换方法对更新后next_b，old_b进行嵌入数据交换；

步骤4.2.18第n个训练节点从conn中接收训练完成信息，更新old_b＝cur_b，cur_b＝next_b，next_b＝None，使用步骤4.2.11中的嵌入数据交换方法对更新后next_b，old_b进行嵌入数据交换；

步骤4.2.19如果第n个训练节点是主结点，将关系嵌入矩阵θ存储至共享文件系统，转步骤4.2.20；如果第n个训练节点不是主结点，直接转步骤4.2.20；

步骤4.2.20第epoch轮训练结束，令epoch＝epoch+1，转步骤4.2.4；

步骤4.2.21说明第n个训练节点已进行了num_epoch轮训练，得到了训练完成的知识图谱嵌入模型，令训练标记is_training＝False；如果当前节点是主节点，则向锁服务器发送训练结束信息，转第五步，否则直接转第五步；

步骤4.3启动GPU训练进程，在数据加载完成的三元组块上进行模型训练，直至数据加载进程完成所有训练周期的数据加载；第n个训练节点的GPU训练进程首先尝试获取内存中数据加载进程完成加载的三元组块以及相应的实体分区嵌入矩阵，然后将训练节点内存中的实体嵌入矩阵列表Embs中的矩阵加载到GPU上进行训练，训练完成后将加载到GPU上的矩阵传回内存，并通知数据加载进程三元组块训练结束，由数据加载进程将训练完成的分区嵌入矩阵存储至共享文件系统；

第五步，计算集群加载训练后的嵌入模型，基于训练后的嵌入模型进行知识图谱链接预测；方法是：

步骤5.1将N个服务器作为预测节点，选择任意一个服务器作为查询节点；将第四步训练后的嵌入模型即共享文件系统中的实体子分区嵌入矩阵和关系嵌入矩阵加载到服务器中；具体方法如下：

步骤5.1.1在查询节点中，根据集群中服务器数量N，从共享文件系统中读取subP个实体子分区嵌入矩阵subEmbs¹，subEmbs²，...，subsEmb^ip，...，subEmbs^subP；

步骤5.1.2查询结点将子分区集subpart中的subP个集合，按照subpart中的顺序拼接成实体集E，将对应的subP实体子分区嵌入矩阵在行方向上拼接成实体嵌入矩阵Embs_all，Embs_all为一个num_entities行D列的矩阵；

步骤5.1.3查询结点将实体集E中的元素按照当前顺序均匀分割为N个实体分区Parts₁，...，Parts_N，将实体嵌入矩阵Embs_all在行方向上均匀分割为N个实体分区嵌入矩阵Embs¹，Embs²，...，Embs^N；查询节点将第1个分区Parts_n1和第1个分区嵌入矩阵Embs¹发送给第1个服务器，…，将第n个分区Parts_n和第n个分区嵌入矩阵Embsⁿ发送给第n个服务器，…，将第N个分区Parts_N和第N个分区嵌入矩阵Embs^N发送给第N个服务器；

步骤5.1.4N台服务器从共享文件系统读取关系嵌入矩阵θ，将θ加载到N台服务器的内存中；

步骤5.2进行链接预测，方法是：

步骤5.2.1查询节点接收用户从终端输入的缺失三元组(e_hh，rr，？)，查询节点从矩阵Embs_all读取e_hh的嵌入向量emb_hh，并发送给N个预测节点；

步骤5.2.3N个服务器并行预测，第n台服务器的预测过程是：

步骤5.2.3.1第n台服务器从分区Part_n取出所有的实体和实体e_hh组成三元组，得到三元组集{(e_hh，rr，e_tt′)|，e_tt′∈Part_n}；

步骤5.2.3.2按照嵌入模型中的得分函数，计算三元组集中所有三元组的得分，并按照得分对三元组集{(e_hh，rr，e_tt′)|e_tt′∈Part_n}中的元素进行排序，选取{(e_hh，rr，e_tt′)|e_tt′∈Part_n}中得分最大的C个三元组作为候选三元组集合CT_n，对应的得分集为Score_n，得分集Score_n中的元素为候选三元组集合CT_n中三元组的得分，C为正整数；

步骤5.2.3.3将候选三元组集合CT_n及Score_n发送给查询节点；

步骤5.2.4查询节点接受N个预测节点发送的候选三元组集和得分集，得到CT₁，CT₂，...，CT_n，...，CT_N和Score₁，Score₂，...，Score_n，...Score_N，将CT₁，CT₂，...，CT_n，...，CT_N合并为CT，Score₁，Score₂，...，Score_n，...Score_N合并为Score，CT为C×N个候选三元组，Score为C×N个三元组的得分，按照得分Score对CT进行排序，再次选择出最大的C个候选三元组{(e_hh，rr，e_it)|0≤it＜C}，e_it表示得分最大的C个候选三元组中第it个三元组对应的尾实体，C个候选三元组对应的实体集{e_it|0≤it＜C}作为链接预测的最终结果，为缺失三元组(e_hh，rr，？)的中缺失实体“？”的候选实体集。

2.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于步骤1.2所述嵌入向量维度D设置为400，P的设置和总实体嵌入大小与GPU显存大小有关，总实体嵌入的大小为num_entities×D×4，P满足：2×总实体嵌入大小/P＜GPU显存大小，PP设置为2。

3.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于步骤1.4所述遍历三元组集T所有的三元组，将三元组划分到对应的子三元组块中的方法是：

步骤1.4.1初始化变量k1＝1，初始化子三元组块集合subBuckets，令subBuckets中所有的子三元组块均为空集，即令subBucket(1，1)，...，subBucket(i2，j2)，...，subBucket(subP，subP)均为空集；

步骤1.4.2从T中取出第k1个三元组(e_h，r，e_t)，0≤h，t≤num_entities-1；根据步骤1.3获得的subpart获取e_h所属子分区序号ih，e_t所属子分区序号it，1≤ih，it≤subP，将三元组(e_h，r，e_t)添加到subBucket(ih，it)中，r∈R；

步骤1.4.3令k1＝k1+1；如果k1≤num_triples，转步骤1.4.2；如果k1＞num_triples，表示T中所有三元组均被划分到对应的子三元组块中，得到了子三元组块集合subBuckets，结束。

4.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于第三步所述共享文件系统要求具备2TB以上的存储空间，具备10Gb/s以上的读写速度。

5.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于第二步所述构建嵌入模型的方法是：

步骤2.1用向量表示实体和关系；方法是：

步骤2.1.1将知识图谱中的每个实体表示为一个实体嵌入向量，实体嵌入向量是一个长度为D的向量，向量的值随机初始化为从标准正态分布的随机数；按照子分区集subpart，每个实体子分区包含subpart_size个实体，每个实体有一个实体嵌入向量，subpart_size个实体共有subpart_size个实体嵌入向量，将实体嵌入向量作为实体子分区嵌入矩阵行向量，按照实体子分区内实体顺序组成一个subpart_size行D列的实体子分区嵌入矩阵；subP个实体子分区共组成subP个实体子分区嵌入矩阵即subEmbs¹，subEmbs²，...，subEmbs^ip，...，subEmbs^subP，subEmbs^ip为第ip个实体子分区subpart_ip的嵌入矩阵，有subpart_size行D列；将subP个的实体子分区嵌入矩阵存储至共享文件系统；

步骤2.1.2将知识图谱中的每个关系表示为一个关系嵌入向量，关系嵌入向量是一个长度为D的向量，向量的值随机初始化为从标准正态分布的随机数，将关系嵌入向量作为关系嵌入矩阵行向量，按照关系集内关系顺序组成关系嵌入矩阵θ，将θ存储至共享文件系统；

步骤2.2定义得分函数：

f(triple)＝f(e_h，r，e_t)＝sim(g(Emb_h，θr)，g(Emb_d，θr))

其中sim(a，b)为相似度计算函数，用于计算两个向量a，b之间的相似度：

g为关系算子函数，用于计算实体嵌入向量Emb_h经过关系r变换后的向量：

g(Emb_h，θr)＝Emb_h⊙θr

triple＝(e_h，r，e_t)表示一个三元组，Emb_h为实体e_h的嵌入向量，θr为关系r的嵌入向量，⊙表示哈达玛积，

表示a，

的复数点积，

为b的共轭复数；由实体子分区嵌入矩阵、关系嵌入矩阵、得分函数共同组成了嵌入模型。

6.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于第四步所述maps为python字典类型，记录当前各分区分别由哪些子分区组成。

7.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于步骤4.1.4所述为训练节点生成可训练的三元组块的方法是：

步骤4.1.4.1将所有三元组编号添加到三元组块编号列表acquirable_buckets中，具体方法是：初始化三元组块编号列表acquirable_buckets，列表元素为满足1≤m≤subP，1≤n≤subP的所有二元组(m，n)，m和n分别代表三元组头实体和尾实体所在分区序号；

步骤4.1.4.2若active为空，转步骤4.1.4.4，若active不为空，转步骤4.1.4.3；

步骤4.1.4.3active中所有三元组块编号的分区序号集active_part，对于acquirable_buckets中的二元组，如果二元组中任意元素在active_part中，则将该二元组从acquirable_buckets中去除，转步骤4.1.4.4；

步骤4.1.4.4如果done为空，转步骤4.1.4.6；如果done不为空，转步骤4.1.4.5；

步骤4.1.4.5将done列表中的三元组块编号从acquirable_buckets中去除；

步骤4.1.4.6如果acquirable_buckets不为空，转步骤4.1.4.7，如果acquirable_buckets为空，转步骤4.1.4.8；

步骤4.1.4.7随机从acquirable_buckets选择一个三元组块编号，令临时变量res_bucket＝选择的这个三元组块编号，并将res_bucket添加到done和active中；转步骤4.1.4.9；

步骤4.1.4.8令临时变量res_bucket＝None；

步骤4.1.4.9计算未训练三元组块数量remaining＝num_bucket-num_done，num_done为done中元素个数，num_bucket＝P²；将res_bucket和remaining发送给请求训练结点。

8.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于步骤4.2.3所述总训练周期数num_epoch设为30；第五步所述C根据用户需要的返回结果数量设置为50。

9.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于步骤4.2.11所述在内存和共享文件系统之间采用嵌入数据交换方法对next_b和old_b进行实体分区嵌入矩阵数据交换的方法是：

步骤4.2.11.1如果next_b不等于None，更新cur_B＝next_b，转步骤4.2.11.2；否则转步骤4.2.11.3；

步骤4.2.11.2加载next_b中分区嵌入向量：next_b的值为(Parth，Partt)，对于二元组(Parth，Partt)中的元素p，从free_idxs弹出idx，idx表示空闲矩阵的序号，EmbsIdx[p]表示实体嵌入矩阵序号列表EmbsIdx的第p个元素，令EmbsIdx[p]＝idx；由映射maps得到maps[p]＝[sp1，sp2，...spPP]，即分区p由子分区sp1，sp2，...spPP组成，从共享文件系统分别读取对应的实体子分区嵌入矩阵subEmbs^sp1，subEmbs^sp2，...，subEmbs^spPP拼接并保存至Embs[idx]；

步骤4.2.11.3如果old_b不等于None，转步骤4.2.11.4；否则结束；

步骤4.2.11.4保存old_b中的分区嵌入向量：old_b的值为(Parth，Partt)，对于分区p∈(Parth，Partt)，令idx＝EmbsIdx[p]，将idx放回free_idxs；由映射maps得到maps[p]＝[sp1，sp2，...spPP]，按照[sp1，sp2，...，spPP]各子分区大小，将分区嵌入矩阵Embs[idx]按行切分为subEmbs^sp1，subEmbs^sp2，...，subEmbs^spPP，并将subEmbs^sp1，subEmbs^sp2，...，subEmbs^spPP保存到共享文件系统中；向锁服务器进程发送释放old_b信息。

10.如权利要求1所述的一种基于知识图谱嵌入的链接预测方法，其特征在于步骤4.3所述第n个训练节点对分区嵌入向量进行训练的方法是：

步骤4.3.1第n个训练节点进行GPU训练进程的初始化：将is_training，关系嵌入矩阵θ，实体嵌入矩阵列表Embs，和共享参数列表share_paras以及进程间传输管道conm，作为参数传入GPU训练进程的初始化函数中，初始化当前参数序号cur_arg_idx＝0，初始化batch_size＝5000；

步骤4.3.2定义损失函数：

其中，S′_triple是由triple通过负采样得到的三元组集合，λ是超参数，设置为0.1，f是2.2中的得分函数；

步骤4.3.3如果is_training为True，转4.3.4；如果is_training为False，GPU训练进程结束；

步骤4.3.4令lock，cur_B，EmbsIdx，Triples＝shared_paras[cur_arg_idx]，输入lock使用get_lock()函数获取临时变量l，对输入l使用acquire()函数获取是否成功标记is_success，如果is_success＝True，转步骤4.3.5，否则转步骤4.3.4；

步骤4.3.5判断lock的值是否为1，如果是1，说明数据加载进程已经完成相关数据的加载，可以进行训练，转步骤4.3.6，否则使用get_lock()函数对输入为lock时获取临时变量L，对使用release()函数对输入L进行进程锁释放，转步骤4.3.4；

步骤4.3.6令cur_B＝(parth，partt)，idxh＝EmbsIdx[parth]，idxt＝EmbsIdx[partt]，将子三元组列表Triples以及Embs[idxh]，Embs[idxt]加载到GPU，Embs[idxh]，Embs[idxt]分别表示Embs中第idxh、idxt个矩阵；令已训练三元组的数量triple_idx＝0，令num_triples为Triples的长度；

步骤4.3.7如果triple_idx＜num_triples，转步骤4.3.8；否则转步骤4.3.9；

步骤4.3.8令T_batch＝Triples[triple_idx：triple_idx+batch_size]，T_batch表示三元组列表Triples中从第triple_idx个三元组开始到第triple_idx+batch_size个三元组为止的所有三元组组成的列表；计算loss，采用随机梯度下降方法更新Embs[idxh]，Embs[idxt]；triple_idx＝triple_idx+batch_size；转步骤4.3.7；

步骤4.3.9通过conn发送训练完成信息给数据加载进程，通知数据加载进程当前三元组块训练完成，可以进行嵌入矩阵的保存；令lock＝0，令cur_arg_idx＝(cur_arg_idx+1)％2，转步骤4.3.3。

Images