Complete inductive knowledge graph inference method based on adaptive rule mode migration

Abstract

The invention discloses a complete inductive knowledge graph inference method based on adaptive rule pattern migration, which belongs to the field of knowledge graph inference, and comprises the following steps: extracting transferable structural features from two aspects of entities and relationships by mining and utilizing logic rule information in a knowledge graph, and the reasoning capability of the model in a new entity and new relationship scene is effectively improved. Based on the known triple data in the original knowledge graph, the high-confidence multi-hop logic rules are automatically mined, and the rules are converted into a unified symbolic representation form, so that accurate knowledge reasoning can still be realized through rule migration in the face of a new knowledge graph.

Description

Technical Field

[0001] The present invention belongs to the field of knowledge graph reasoning, and in particular relates to a fully inductive knowledge graph reasoning method based on adaptive rule pattern migration. Background Art

[0002] Knowledge graphs (KGs) represent various entities and their relationships in the real world in a structured manner using triples (head entity, relationship, tail entity). They possess excellent knowledge organization and representation capabilities and have been widely used in multiple artificial intelligence tasks, such as question-answering systems, information retrieval, and recommendation systems. However, practically constructed knowledge graphs are often incomplete, meaning they contain a large amount of missing factual knowledge, which severely impacts their effectiveness in downstream tasks. To alleviate this problem, researchers have proposed the Knowledge Graph Reasoning (KGR) method, which aims to infer unknown triples based on known facts, thereby improving the completeness and intelligence of the graph.

[0003] While some inductive methods have achieved some success in processing novel entities, they often rely on a known set of relations during training and are unable to cope with the more complex and common real-world scenarios where new entities and relations appear simultaneously during reasoning. Consequently, the academic community has begun to focus on a more challenging reasoning setting: fully inductive knowledge graph reasoning (KGR). In this setting, entities and relations in the test graph may have never appeared during training, posing a significant challenge to the model's generalization capabilities. There is an urgent need to design new reasoning frameworks with transfer and generalization capabilities. Summary of the Invention

[0004] To solve the above technical problems, the present invention provides a fully inductive knowledge graph reasoning method based on adaptive rule pattern migration, including:

[0005] Based on the known triple data in the original knowledge graph, multi-hop logic rules are mined and grouped according to the rule confidence to form a structured rule group representation;

[0006] According to the one-hot vector representation of the relationship contained in the structured rule group representation, a parameter-free message passing model is used to propagate path information from the query entity to other entities to obtain an entity path representation;

[0007] Calculating a matching score based on the similarity between the entity path representation and the rule group, and extracting transferable entity features;

[0008] Obtaining reasoning pattern features of the relationship according to the structured rule group representation, obtaining co-occurrence pattern features according to adjacency statistics, and fusing the reasoning pattern features and the co-occurrence pattern features to extract transferable relationship features;

[0009] The transferable entity features and the transferable relationship features are input into a graph neural network based on path aggregation for propagation and integration, and the reasoning score of the target triple is output.

[0010] Preferably, the logic rule comprises a closed path rule, and the rule body consists of a number of relationships constituting a path from a head entity to a tail entity.

[0011] Preferably, the logic rule mining process includes:

[0012] Select a target relationship in the knowledge graph, construct a closed path rule body consisting of multiple other relationships for the target relationship, and calculate the standard confidence score of each rule, where the standard confidence is equal to the number of instances that meet the rule structure divided by the number of occurrences of the rule body;

[0013] All rules are arranged in descending order according to the confidence scores, and the rules are divided into multiple rule groups based on a set threshold or grouping number, each rule group serving as a basic unit for subsequent path feature matching.

[0014] Preferably, the process of forming a structured rule group representation includes:

[0015] After converting the relations contained in each rule body into one-hot vectors, a high-dimensional vector group is formed through splicing operations;

[0016] All rule body vectors in a rule group are combined into a unified rule group vector by concatenation, weighting or averaging, so as to generate the structured rule group representation.

[0017] Preferably, the operation process of the parameter-free message passing model includes:

[0018] Starting from the query entity, a breadth-first search strategy is adopted to activate its adjacent nodes layer by layer and assign an activation mark to each node;

[0019] When the previous layer node is in an active state, the information is propagated to the next hop, and the propagated information includes the unique hot vector of the current relationship and the path identifier;

[0020] Each entity updates its own state in each hop of propagation and obtains a representation of the path from the query entity to it after multi-hop propagation.

[0021] Preferably, the process of obtaining the entity path representation includes:

[0022] In the propagation process of each layer, the activation state of the entity and the one-hot vector of its incoming edge relationship are combined to construct a path unit representation;

[0023] Superimpose each hop path unit on the node representation to form a complete path representation from the query entity to the target entity;

[0024] The final path representation of each entity is composed of the superposition combination of multi-hop paths.

[0025] Preferably, the process of extracting transferable entity features includes:

[0026] Calculate the similarity between the path representation of each entity and the feature vectors of all rule groups, where the similarity is calculated using cosine similarity, dot product, or other differentiable metrics;

[0027] The similarity score is used as the matching score of each entity under the rule group to generate the transferable entity features of the entity under multiple rule groups.

[0028] Preferably, the operation process of the graph neural network based on path aggregation includes:

[0029] The transferable features of entities and relations are uniformly mapped to the same embedding space dimension through a multi-layer perceptron (MLP);

[0030] In each layer of the graph neural network, based on the node activation state, feature information of neighboring nodes is collected, feature weighting and path context aggregation are performed, and the target node representation is updated;

[0031] The aggregation method uses a point-by-point product operation to fuse neighbor node features and activation mark states, and finally forms a complete entity embedding representation through multi-layer stacking.

[0032] On the other hand, the present invention further provides an electronic device, comprising a memory, a processor, and a computing program stored in the memory and executable on the processor, wherein the method is implemented when the processor executes the computing program.

[0033] On the other hand, the present invention further provides a computer-readable storage medium, wherein the computer-readable storage medium stores a computer program, and the computer program implements the method when executed by a processor.

[0034] Compared with the prior art, the present invention has the following advantages and technical effects:

[0035] By mining and utilizing the logical rule information in the knowledge graph, we extract transferable structural features from both the entity and relationship levels, effectively improving the model's reasoning capabilities in new entity and relationship scenarios. Based on the known triples in the original knowledge graph, we automatically mine high-confidence multi-hop logical rules and convert these rules into a unified symbolic representation, enabling accurate knowledge reasoning through rule transfer even when faced with new knowledge graphs.

[0036] The adaptive rule pattern migration method proposed in this invention can effectively extract more comprehensive transferable knowledge representation, has stronger generalization and reasoning capabilities, and demonstrates strong practical value and technical advantages in dynamic and complex knowledge graph reasoning tasks. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] The accompanying drawings, which constitute part of this application, are intended to provide a further understanding of this application. The exemplary embodiments and descriptions of this application are intended to explain this application and do not constitute an improper limitation on this application. In the accompanying drawings:

[0038] Figure 1 Schematic diagram of a method flow in an embodiment of the present invention. DETAILED DESCRIPTION

[0039] It should be noted that, in the absence of conflict, the embodiments and features of the embodiments in this application can be combined with each other. The present application will be described in detail below with reference to the accompanying drawings and in combination with the embodiments.

[0040] It should be noted that the steps shown in the flowcharts of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and that, although a logical order is shown in the flowcharts, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0041] Example 1

[0042] like Figure 1 As shown, this embodiment provides a completely inductive knowledge graph reasoning method based on adaptive rule pattern migration, including:

[0043] Based on the known triple data in the original knowledge graph, multi-hop logic rules are mined and grouped according to the rule confidence to form a structured rule group representation;

[0044] According to the one-hot vector representation of the relationship contained in the structured rule group representation, a parameter-free message passing model is used to propagate path information from the query entity to other entities to obtain an entity path representation;

[0045] Calculating a matching score based on the similarity between the entity path representation and the rule group, and extracting transferable entity features;

[0046] Obtaining reasoning pattern features of the relationship according to the structured rule group representation, obtaining co-occurrence pattern features according to adjacency statistics, and fusing the reasoning pattern features and the co-occurrence pattern features to extract transferable relationship features;

[0047] The transferable entity features and the transferable relationship features are input into a graph neural network based on path aggregation for propagation and integration, and the reasoning score of the target triple is output.

[0048] Furthermore, the logic rule includes a closed path rule, and the rule body is composed of a number of relationships that constitute a path from a head entity to a tail entity.

[0049] Furthermore, the logic rule mining process includes:

[0050] Select a target relationship in the knowledge graph, construct a closed path rule body consisting of multiple other relationships for the target relationship, and calculate the standard confidence score of each rule, where the standard confidence is equal to the number of instances that meet the rule structure divided by the number of occurrences of the rule body;

[0051] All rules are arranged in descending order according to the confidence scores, and the rules are divided into multiple rule groups based on a set threshold or grouping number, each rule group serving as a basic unit for subsequent path feature matching.

[0052] Specifically, for a given knowledge graph, we first mine all possible logical rules for each relationship in the knowledge graph, mainly using closed-path (CP) rules, where the relationships in the rule body can form a complete path from the head entity to the tail entity. h , e n ), this embodiment extracts all possible paths from the head entity to the tail entity, that is, These paths can be regarded as the rule body of the logical rules, so this embodiment can obtain a series of relationships r h This embodiment uses a standard confidence score to measure the quality of the rule, and its calculation formula is:

[0053]

[0054] Among them, the molecule |r h ←r b | represents the number of instances in the knowledge graph that conform to the rule structure, and the denominator |r b | is the frequency of occurrence of the rule body in the knowledge graph.

[0055] Furthermore, the process of forming a structured rule group representation includes:

[0056] After converting the relations contained in each rule body into one-hot vectors, a high-dimensional vector group is formed through splicing operations;

[0057] All rule body vectors in a rule group are combined into a unified rule group vector by concatenation, weighting or averaging, so as to generate the structured rule group representation.

[0058] Logical rules are used as auxiliary knowledge sources, and reasoning is performed by migrating knowledge feature learning paradigms rather than directly using rules. Since the number and confidence of rules corresponding to different knowledge graphs and relationships are significantly different (some relationships may only have a small number of low-confidence rules), it is difficult for traditional methods to effectively construct a unified feature representation across relationships and graphs. To this end, this embodiment proposes a unified processing framework based on rule grouping, which integrates the rules of different relationships through a clustering mechanism. Definition is a set of n-order logical rules for relation r (where the rule body length is n). First, the rules are sorted in descending order according to the confidence λ and divided into M groups. The features of each rule group are composed of the one-hot encoding features of the relations in the rule body, and the calculation formula is expressed as:

[0059]

[0060] in represents the set of rule bodies in the mth group, Representing relationships One-hot encoding of Represents a splicing operation.

[0061] Furthermore, the operation process of the parameter-free message passing model includes:

[0062] Starting from the query entity, a breadth-first search strategy is adopted to activate its adjacent nodes layer by layer and assign an activation mark to each node;

[0063] When the previous layer node is in an active state, the information is propagated to the next hop, and the propagated information includes the unique hot vector of the current relationship and the path identifier;

[0064] Each entity updates its own state in each hop of propagation and obtains a representation of the path from the query entity to it after multi-hop propagation.

[0065] Furthermore, the process of obtaining the entity path representation includes:

[0066] In the propagation process of each layer, the activation state of the entity and the one-hot vector of its incoming edge relationship are combined to construct a path unit representation;

[0067] Superimpose each hop path unit on the node representation to form a complete path representation from the query entity to the target entity;

[0068] The final path representation of each entity is composed of the superposition combination of multi-hop paths.

[0069] Furthermore, the process of extracting transferable entity features includes:

[0070] Calculate the similarity between the path representation of each entity and the feature vectors of all rule groups, where the similarity is calculated using cosine similarity, dot product, or other differentiable metrics;

[0071] The similarity score is used as the matching score of each entity under the rule group to generate the transferable entity features of the entity under multiple rule groups.

[0072] To leverage logical rules to learn transferable entity representations, a feasible approach is to learn a path representation from the query entity to each entity in the KG, and then match each entity's path representation with the mined rules. However, directly searching for all possible paths between the target entity and the query entity is challenging because the number of paths grows exponentially with the length of the path. To address this issue, this paper proposes a parameter-free message passing method to learn entity path representations.

[0073] For knowledge graphs Query in (e q , T q ,? ), the relations in the knowledge graph are represented as one-hot vectors. In order to learn q To represent the paths to other entities, this embodiment adopts a breadth-first message passing strategy to propagate information layer by layer from the query node. To achieve this, this embodiment iteratively activates adjacent nodes layer by layer starting from the query node and uses an indicator to mark whether each node is active. Only information from activated nodes will be propagated to the next layer. Definition For entity e i The activation flag at level n, Represents entity e i is the query entity e q First, in the initial state, the activation flag of the query entity is set to The activation states of other entities are all 0. Then the activation state of each entity is updated layer by layer using the graph neural network. The update formula is:

[0074]

[0075] The path of each node can be represented by the node activation state of each layer. The formula is as follows:

[0076]

[0077] in, It is entity e i Representation at the nth layer. By superimposing N layers of message passing, this embodiment can obtain a path representation of the hops from the query node to each node. This embodiment calculates the similarity between these path representations and the logical rules as the transferable features of the node:

[0078]

[0079] The methods for obtaining the reasoning pattern features of the relationship include:

[0080] The unique hot vector of each relationship is used as the query vector, and similarity matching is performed with the sub-vectors in the rule group features in turn;

[0081] The matching results of each sub-vector are combined to form the inference pattern feature representation of the relationship, and the sub-vector is a one-hot fragment or an intermediate pattern segment in the rule group.

[0082] For relations, this embodiment considers two transferable features, namely, reasoning pattern features and co-occurrence pattern features.

[0083] Reasoning pattern features: The logical rules in the knowledge graph involve valuable reasoning patterns, which can be used to extract transferable features of relational reasoning. Therefore, this embodiment uses logical rules to learn reasoning pattern features for each relation. Specifically, this embodiment represents the n-hop reasoning rule Divide into n sub-vectors, that is Then, the similarity between the relation vector and these rule sub-vectors is calculated as the inference pattern feature. The calculation formula is:

[0084]

[0085] Co-occurrence pattern features: In addition to reasoning patterns, co-occurrence patterns also provide valuable reasoning clues for knowledge reasoning. For example, given a query relation, there are many relations in the knowledge graph that share the same head or tail entity. These co-occurrence relations usually imply similar semantic information and can be used to assist model reasoning. Taking the Nationality relation as an example, one of its co-occurrence patterns is This relationship pattern is called the tail-to-head (t2h) pattern in this embodiment. Through this relationship pattern, this embodiment can infer that the tail entity of the relationship Nationality and the head entity of the relationship Capital have similar semantic types. This information is very valuable for relationship reasoning. In order to make full use of this co-occurrence pattern feature, this embodiment defines four different co-occurrence patterns, namely tail-to-head (t2h), tail-to-tail (t2t), head-to-head (h2h), and head-to-head (h2h). Relation r k The calculation formula of the co-occurrence pattern features is as follows:

[0086]

[0087] in Indicates the frequency of occurrence of the t2h relationship pattern, |r k | represents the relationship r k Frequency of occurrence.

[0088] Furthermore, the operation process of the graph neural network based on path aggregation includes:

[0089] The transferable features of entities and relations are uniformly mapped to the same embedding space dimension through a multi-layer perceptron (MLP);

[0090] In each layer of the graph neural network, based on the node activation state, feature information of neighboring nodes is collected, feature weighting and path context aggregation are performed, and the target node representation is updated;

[0091] The aggregation method uses a point-by-point product operation to fuse neighbor node features and activation mark states, and finally forms a complete entity embedding representation through multi-layer stacking.

[0092] Through the above steps, this embodiment can obtain the migratable entity and relationship features, which are respectively expressed as and Using these features, this embodiment can use graph neural networks to perform reasoning in the knowledge graph. First, a multi-layer perceptron (MLP) is used to convert entity and relationship features into the same dimension:

[0093]

[0094] Then, a graph neural network based on path aggregation is used to learn the representation of the iterative updated entity. The update formula is:

[0095]

[0096] Among them, ⊙ represents the point-by-point multiplication operation, W u and Wr are trainable parameters, is the lth layer node e j , so that path-based entity information can be collected layer by layer.

[0097] By stacking L layers of graph neural networks based on path aggregation, the final entity representation can be obtained:

[0098]

[0099] After obtaining the entity representation, we can calculate the score of each candidate triple:

[0100]

[0101] Where σ is the sigmoid activation function. Finally, this embodiment uses the cross entropy loss function to train the parameters in the model, and the calculation formula is:

[0102]

[0103] Finally, the Adam optimization method is used to update the parameters in the model by minimizing the above loss function.

[0104] In order to fully evaluate the performance and generalization ability of the AdaRPT model proposed in this example in the fully inductive knowledge graph reasoning task, this example first pre-trained the model on a mixed set of three mainstream knowledge graph datasets, including FB15k-237, WN18RR, and CoDEx-medium. Based on this pre-trained model, this example reports the reasoning results in two modes: one is the "Pre-train" version, which directly applies the pre-trained model to the target task without fine-tuning; the other is the "Finetune" version, which fine-tunes the model on the target dataset to further improve performance. This setting not only verifies the robustness and transferability of AdaRPT in zero-shot and fine-tuning scenarios, but also demonstrates its wide adaptability and superior performance in handling fully inductive knowledge graph reasoning problems.

[0105] To comprehensively evaluate AdaRPT's performance in fully inductive reasoning scenarios, this example used 13 challenging sub-datasets provided by InGram for experiments. These datasets cover three domains: FB (Freebase), NL (NELL), and WK (Wikidata). They are divided into 0, 25, 50, 75, and 100 proportions of new relations in the test phase, respectively. This means that 0%, 25%, 50%, 75%, and 100% of the relations in the test set are new relations not present in the training set, and all test entities are new. These datasets are named FB-25, FB-50, FB-75, FB-100, NL-0, NL-25, NL-50, NL-75, NL-100, WK-25, WK-50, WK-75, and WK-100, covering a wide range of new relation proportions, from low to high. See Table 1-2.

[0106] Table 1

[0107]

[0108]

[0109] Table 2

[0110]

[0111] Experimental results show that the performance of the AdaRPT model proposed in this embodiment in the full-induction knowledge graph reasoning task was systematically evaluated across multiple public datasets, demonstrating significant technical results. Experiments were conducted on 13 of the most challenging full-induction datasets currently available and compared with a variety of representative baseline models. The results show that under the Hits@10 metric, the fine-tuned version of AdaRPT (AdaRPTfinetune) achieved optimal performance on all datasets; under the MRR (Mean Reciprocal Rank) metric, AdaRPTfinetune outperformed the current top-performing baseline model, KG-ICLfinetune, on most datasets, demonstrating superior reasoning capabilities. Overall, both fine-tuning and zero-shot modes of AdaRPT demonstrated superior transfer reasoning results. In addition, compared to all supervised SOTA models, AdaRPT achieved significant performance improvements on all datasets and consistently surpassed the representative model ULTRA based on relational graph modeling in all tasks. The above experimental results fully verify that the adaptive rule pattern migration method proposed in this embodiment can effectively extract a more comprehensive transferable knowledge representation, has stronger generalization and reasoning capabilities, and demonstrates strong practical value and technical advantages in dynamic and complex knowledge graph reasoning tasks.

[0112] On the other hand, this embodiment further provides an electronic device, comprising a memory, a processor, and a computing program stored in the memory and executable on the processor, wherein the method is implemented when the processor executes the computing program.

[0113] On the other hand, this embodiment further provides a computer-readable storage medium, wherein the computer-readable storage medium stores a computer program, and the computer program implements the method when executed by a processor.

[0114] The above are merely preferred embodiments of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of the present application. Therefore, the scope of protection of the present application should be based on the scope of protection of the claims.

Claims

1. A fully inductive knowledge graph reasoning method based on adaptive rule pattern migration, characterized by: include: Based on the known triple data in the original knowledge graph, multi-hop logic rules are mined and grouped according to the rule confidence to form a structured rule group representation; According to the one-hot vector representation of the relationship contained in the structured rule group representation, a parameter-free message passing model is used to propagate path information from the query entity to other entities to obtain an entity path representation; Calculating a matching score based on the similarity between the entity path representation and the rule group, and extracting transferable entity features; Obtaining reasoning pattern features of the relationship according to the structured rule group representation, obtaining co-occurrence pattern features according to adjacency statistics, and fusing the reasoning pattern features and the co-occurrence pattern features to extract transferable relationship features; The transferable entity features and the transferable relationship features are input into a graph neural network based on path aggregation for propagation and integration, and the reasoning score of the target triple is output.

2. The method according to claim 1, characterized in that The logic rule includes a closed path rule, and the rule body is composed of a number of relationships that constitute a path from a head entity to a tail entity.

3. The method according to claim 1, characterized in that The mining process of the logic rules includes: Select a target relationship in the knowledge graph, construct a closed path rule body consisting of multiple other relationships for the target relationship, and calculate the standard confidence score of each rule, where the standard confidence is equal to the number of instances that meet the rule structure divided by the number of occurrences of the rule body; All rules are arranged in descending order according to the confidence scores, and the rules are divided into multiple rule groups based on a set threshold or grouping number, each rule group serving as a basic unit for subsequent path feature matching.

4. The method according to claim 1, wherein The process of forming a structured rule group representation includes: After converting the relations contained in each rule body into one-hot vectors, a high-dimensional vector group is formed through splicing operations; All rule body vectors in a rule group are combined into a unified rule group vector by concatenation, weighting or averaging, so as to generate the structured rule group representation.

5. The method according to claim 1, wherein The operation process of the parameter-free message passing model includes: Starting from the query entity, a breadth-first search strategy is adopted to activate its adjacent nodes layer by layer and assign an activation mark to each node; When the previous layer node is in an active state, the information is propagated to the next hop, and the propagated information includes the unique hot vector of the current relationship and the path identifier; Each entity updates its own state in each hop of propagation and obtains a representation of the path from the query entity to it after multi-hop propagation.

6. The method according to claim 1, characterized in that The process of obtaining the entity path representation includes: In the propagation process of each layer, the activation state of the entity and the one-hot vector of its incoming edge relationship are combined to construct a path unit representation; Superimpose each hop path unit on the node representation to form a complete path representation from the query entity to the target entity; The final path representation of each entity is composed of the superposition combination of multi-hop paths.

7. The method according to claim 1, characterized in that The process of extracting transferable entity features includes: Calculate the similarity between the path representation of each entity and the feature vectors of all rule groups, where the similarity is calculated using cosine similarity, dot product, or other differentiable metrics; The similarity score is used as the matching score of each entity under the rule group to generate the transferable entity features of the entity under multiple rule groups.

8. The method according to claim 1, characterized in that The operation process of the graph neural network based on path aggregation includes: The transferable features of entities and relations are uniformly mapped to the same embedding space dimension through a multi-layer perceptron (MLP); In each layer of the graph neural network, based on the node activation state, feature information of neighboring nodes is collected, feature weighting and path context aggregation are performed, and the target node representation is updated; The aggregation method uses a point-by-point product operation to fuse neighbor node features and activation mark states, and finally forms a complete entity embedding representation through multi-layer stacking.

9. An electronic device comprising a memory, a processor, and a computing program stored in the memory and executable on the processor, wherein: When the processor executes the computing program, the method according to any one of claims 1 to 8 is implemented.

10. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the method according to any one of claims 1 to 8 is implemented.

Images