Neighborhood aggregation knowledge graph entity alignment method based on types

Abstract

The invention discloses a neighborhood aggregation knowledge graph entity alignment method based on types, which comprises the following steps of: preparing a triple data set which comprises entities, relationships and aligned entity pair seed information, and preprocessing data; semantic information and structure information of the entity are embedded, and a semantic embedding vector and a structure embedding vector of the entity are constructed. Specifically, the neighbor nodes of each central entity are classified according to three different perspectives of semantic similarity, spatial information and topological structure to identify and distinguish potential contributions of different neighbor nodes to central entity representation. Type information is introduced for each classified neighbor node, and the information is used as a basis for distinguishing different neighbor nodes and is used for enhancing the representation of the central entity. Classification information is fused into a neighborhood aggregation process, so that weighting can be performed according to importance and correlation of neighbor nodes in the aggregation process, and structure information in a knowledge graph is more effectively captured and utilized. And further coding local structure information of the entity by using a graph convolutional network, and updating entity embedding and parameters through a hierarchical network. According to the method provided by the invention, the entity alignment performance can be effectively improved, especially in a cross-language knowledge graph scene.

Description

Technical Field

[0001] This study belongs to the field of knowledge graph entity alignment, and uses a type-based neighborhood aggregation mechanism and a graph convolutional network to implement an entity alignment method. Background Art

[0002] Knowledge graphs (KGs) are structured representations of knowledge that capture the relationships between real-world concepts. KGs are widely used in AI-driven tasks such as question-answering systems, information extraction, and recommendation systems. Different KGs are built independently, derived from various data sources, and are usually complementary. Entity alignment (EA) aims to link entities with equivalent semantic meanings from different KGs and has received increasing attention in recent years because it can facilitate the integration of knowledge.

[0003] Embedding-based methods have become the mainstream approach for entity alignment in recent years. These methods encode entities and relations into a latent vector space and calculate the distance between entity vectors as evidence of alignment. To enhance the learning of knowledge graph embeddings, methods such as GCN-Align utilize graph convolutional networks (GCNs) to capture the information of structure and neighboring entities. RAGA treats relations as reflection actions and integrates reflection into the graph attention network (GAT). All of these methods attempt to aggregate the information of neighbor nodes to enrich the semantic representation. Although these methods can effectively improve the alignment performance by aggregating neighborhood information, they rarely consider the diversity of neighbor nodes. That is, most methods tend to treat each neighbor node as equally important without distinguishing the differences between them. Summary of the invention

[0004] Most existing entity alignment methods, namely embedding-based methods, usually enhance the contextual representation of entities by performing neighborhood aggregation to support more accurate entity alignment. However, the traditional aggregation process simply treats each neighbor as equally important and fails to distinguish the differences between neighbors, which is very limited. To solve this problem, this paper proposes a type-based neighborhood aggregation method for entity alignment.

[0005] To achieve the above object, the technical solution adopted by the present invention is:

[0006] A type-based neighborhood aggregation knowledge graph entity alignment method includes the following steps:

[0007] Step 1: Prepare the triple dataset DBP15K, which contains multiple pairs of cross-lingual knowledge graphs, each of which includes 15,000 aligned entity pairs.

[0008] In step 1, our dataset contains three pairs of cross-lingual graphs: ZH-EN, JA-EN, and FR-EN. Most entity alignment studies using the DBP15K dataset use a simplified version that excludes many irrelevant entities and relations. Similarly, our experiments are conducted on a simplified version of DBP15K.

[0009] Step 2: construct an initial feature vector for each entity and its connected relations, and use the average aggregation method to calculate the feature vector of the neighbor relationship.

[0010] In step 2, the entity feature vector , as the average connection formula of the head and tail entity feature vectors of its connection is as follows: For each relationship r i ∈R1∪R2, we construct its feature vector As the average connection of the feature vectors of the head and tail entities of its connection:

[0011]

[0012] where {(e h ,r i ,e t )∈T1∪T2} is an inclusion relation r i The set of all triples of and Entity e h and e t For each entity e i ∈E1∪E2, construct its average adjacent relationship feature vector as:

[0013]

[0014] Where N r (e i ) is entity e i The set of one-hop neighbor relations.

[0015] Step 3: Define three types of neighbor nodes of the central entity, and classify them from the following three perspectives: semantic similarity, spatial information, and topological structure. By calculating the semantic similarity between the central entity and its one-hop relationship, adjust the influence weight of the relationship information on the entity embedding. Consider not only the one-hop neighbors but also the two-hop neighbors, and introduce a one-dimensional learnable variable to represent the one-hop and two-hop neighbors. Based on the number and type of one-hop neighbors and connection relationships of the entity, the topological structure is divided into different categories, and a learnable variable is defined to represent the structure type.

[0016] In step 3, after obtaining the average adjacent relationship feature vector of each entity through step 2, for each entity e i∈E1∪E2, we construct its average adjacency feature vector as:

[0017]

[0018] Where R t is a randomly initialized learnable variable. Next, consider the multi-hop neighbor information of the aggregation center entity, let N2(e i ) is the set of two-hop neighbor entities of a given entity. Initialize two one-dimensional learnable variables t1 and t2. After combining the multi-hop information of the entity, we have:

[0019]

[0020] In addition, we divide the single-hop topological structure of the entity into n different categories according to the difference in the out-degree and in-degree of each entity, and define a learnable variable S t Get Finally, we add the subgraph type to it:

[0021]

[0022] Step 4: Combined with the local structural information obtained from the previous step, a two-layer graph convolutional network (GCN) is used to encode the entities in the knowledge graph. Highway Networks are used layer by layer to control the information balance between the entity itself and the neighboring entities to obtain the final entity embedding representation.

[0023] In step 4, the final entity embedding representation structure is as follows:

[0024]

[0025] T(X (l) )=σ(X (l) W (l) +b (l) )

[0026] X (l+1) =T(X (l) )·X (l+1) +(1-T(X (l) ))·T(X (l) )

[0027] The input X (l) is the collection of entity embeddings A is the adjacency matrix of the graph and I is the identity matrix. yes The degree matrix of . BRIEF DESCRIPTION OF THE DRAWINGS

[0028] Figure 1It is the overall structure diagram of the model in the present invention; DETAILED DESCRIPTION

[0029] The present invention will be further explained below in conjunction with the accompanying drawings in the embodiments of the present invention.

[0030] A type-based neighborhood aggregation knowledge graph entity alignment method of the present invention comprises the following steps:

[0031] Step 1: Prepare the triple dataset DBP15K, which contains multiple pairs of cross-lingual knowledge graphs, each of which includes 15,000 aligned entity pairs.

[0032] Step 2: construct an initial feature vector for each entity and its connected relations, and use the average aggregation method to calculate the feature vector of the neighbor relationship.

[0033] Step 3 defines three types of neighbor nodes of the central entity, which are classified from the following three perspectives: semantic similarity, spatial information, and topological structure. By calculating the semantic similarity between the central entity and its one-hop relationship, the influence weight of the relationship information on the entity embedding is adjusted. Not only the one-hop neighbors but also the two-hop neighbors are considered, and a one-dimensional learnable variable is introduced to represent the one-hop and two-hop neighbors. Based on the number and type of one-hop neighbors and connection relationships of the entity, the topological structure is divided into different categories, and a learnable variable is defined to represent the structure type.

[0034] Step 4: Combined with the local structural information obtained from the previous step, a two-layer graph convolutional network (GCN) is used to encode the entities in the knowledge graph. Highway Networks are used layer by layer to control the information balance between the entity itself and the neighboring entities to obtain the final entity embedding representation.

[0035] In step 1, our dataset contains three pairs of cross-lingual graphs: ZH-EN, JA-EN, and FR-EN. Most entity alignment studies using the DBP15K dataset use a simplified version that excludes many irrelevant entities and relations. Similarly, our experiments are conducted on a simplified version of DBP15K.

[0036] In step 2, the entity feature vector The average connection formula of the head and tail entity feature vectors as their connection is as follows: i ∈R1∪R2, we construct its feature vector As the average connection of the feature vectors of the head and tail entities of its connection:

[0037]

[0038] where {(e h,r i ,e t )∈T1∪T2} is an inclusion relation r i The set of all triples of and Entity e h and e i For each entity e i ∈E1∪E2, construct its average adjacent relationship feature vector as:

[0039]

[0040] Where N r (e i ) is entity e i The set of one-hop neighbor relations.

[0041] In step 3, the overall structure of the central entity to obtain the embedded representation can be found in Figure 1 , its overall structure is as follows:

[0042]

[0043] After obtaining the average adjacent relationship feature vector of each entity, for each entity e i ∈E1∪E2, we construct its average adjacency feature vector. t is a randomly initialized learnable variable. Next, consider the multi-hop neighbor information of the aggregation center entity, let N2(e i ) is the set of two-hop neighbor entities of a given entity. Initialize two one-dimensional learnable variables t1 and t2. After combining the multi-hop information of the entity, we have:

[0044]

[0045] In addition, we divide the single-hop topological structure of the entity into n different categories according to the difference in the out-degree and in-degree of each entity, and define a learnable variable S t Get Finally, we add the subgraph type to it:

[0046]

[0047] In step 4, the final entity embedding representation structure is as follows:

[0048]

[0049] T(X (l) )=σ(X (l) W (l )+b (l) )

[0050] X (l+1) =T(X (l) )·X (l+1) +(1-T(X (l) ))·T(X (l) )

[0051] The input X (l) is the collection of entity embeddings A is the adjacency matrix of the graph and I is the identity matrix. yes After obtaining the enhanced entity embedding with type variables, we also utilize a two-layer GCN to explicitly encode the entities in the KG and use a hierarchical network to control the information balance between the entity itself and the neighboring entities.

[0052] In the present invention, this method uses a real cross-language knowledge graph dataset for training, which enhances the practical applicability of the model; in terms of network structure, this study uses a type-based neighborhood aggregation mechanism and a graph convolutional network to dynamically simulate the influence of neighboring nodes and improve the accuracy of entity alignment; in terms of alignment targets, this study selects the alignment of semantically equivalent entities in different knowledge graphs as the target, making the alignment results of this method more accurate and effective. Through experiments, it is found that the model provided by this method can effectively achieve entity alignment, and the final effect shows high accuracy and reliability.

[0053] The above is only a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principle of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention.

Claims

1. A type-based neighborhood aggregation knowledge graph entity alignment method, comprising the following steps: Step 1: Prepare the triple dataset DBP15K, which contains multiple pairs of cross-lingual knowledge graphs, each of which includes 15,000 aligned entity pairs. Step 2: construct an initial feature vector for each entity and its connected relations, and use the average aggregation method to calculate the feature vector of the neighbor relationship. Step 3 defines three types of neighbor nodes of the central entity, which are classified from the following three perspectives: semantic similarity, spatial information, and topological structure. By calculating the semantic similarity between the central entity and its one-hop relationship, the influence weight of the relationship information on the entity embedding is adjusted. Not only the one-hop neighbors but also the two-hop neighbors are considered, and a one-dimensional learnable variable is introduced to represent the one-hop and two-hop neighbors. Based on the number and type of one-hop neighbors and connection relationships of the entity, the topological structure is divided into different categories, and a learnable variable is defined to represent the structure type. Step 4: Combined with the local structural information obtained from the previous step, a two-layer graph convolutional network (GCN) is used to encode the entities in the knowledge graph. Highway Networks are used layer by layer to control the information balance between the entity itself and the neighboring entities to obtain the final entity embedding representation.

2. According to claim 1, a type-based neighborhood aggregation knowledge graph entity alignment method is characterized by: In step 1, we use the DBP15K dataset, which contains three pairs of cross-language graphs: ZH-EN, JA-EN, and FR-EN. Most entity alignment studies using the DBP15K dataset use a simplified version that excludes many irrelevant entities and relations. Similarly, our experiments are conducted on a simplified version of DBP15K.

3. According to claim 1, a type-based neighborhood aggregation knowledge graph entity alignment method is characterized by: In step 2, the entity feature vector xri is used as the average connection formula of the head and tail entity feature vectors connected to it as follows: i ∈R1∪R2, we construct its feature vector As the average connection of the feature vectors of the head and tail entities of its connection: where {(e h ,r i ,e t )∈T1∪T2} is an inclusion relation r i The set of all triples of and Entity e h and e t For each entity e i ∈E1∪E2, construct its average adjacent relationship feature vector as: Where N r (e i ) is entity e i The set of one-hop neighbor relations.

4. According to claim 1, a type-based neighborhood aggregation knowledge graph entity alignment method is characterized by: In step 3, after obtaining the average adjacent relationship feature vector of each entity through step 2, for each entity e i ∈E1∪E2, we construct its average adjacency feature vector as: Where R t is a randomly initialized learnable variable. Next, consider the multi-hop neighbor information of the aggregation center entity, let N2(e i ) is the set of two-hop neighbor entities of a given entity. Initialize two one-dimensional learnable variables t1 and t2. After combining the multi-hop information of the entity, we have: In addition, we divide the single-hop topological structure of the entity into n different categories according to the difference in the out-degree and in-degree of each entity, and define a learnable variable S t Get Finally, we add the subgraph type to it:

5. According to claim 1, a type-based neighborhood aggregation knowledge graph entity alignment method is characterized by: In step 4, after obtaining the enhanced entity embedding with type variables, we also use a two-layer GCN to explicitly encode the entities in the KG, and use a hierarchical network to control the information balance between the entity itself and the adjacent entities. The formula is as follows: T(X (l) )=σ(X (l) W (l) +b (l) ) X (l+1) =T(X (l) )·X (l+1) +(1-T(X (l) ))·T(X (l) ) The input X (l) is the collection of entity embeddings A is the adjacency matrix of the graph and I is the identity matrix. yes The degree matrix of .

Images