Graph embedding retrieval enhanced large model mapping knowledge domain question and answer method

Abstract

The invention discloses a graph embedding retrieval enhanced large model knowledge graph question and answer method, and belongs to the field of large language models. According to the method, a small graph model is utilized to enhance the inference capability of incomplete KG. According to the method, a natural language problem is analyzed into a structured logic form by using LLMs, elements are aligned to a KG through an entity link based on TF-IDF, and an efficient graph model is used for implicit reasoning. The reasoning complexity of the efficient graph reasoning model is equivalent to that of a traditional document retrieval method. Experimental results on a real data set show that the RAKGQA always obtains the most advanced performance when a question on an incomplete knowledge graph is answered.

Description

Technical Field

[0001] This invention relates to the field of large prophecy models, specifically to a large model knowledge graph question answering method with graph embedding retrieval enhancement. Background Technology

[0002] In recent years, large language models (LLMs) have demonstrated impressive performance across a variety of tasks. Despite these advancements, their practical reliability is often compromised by several key shortcomings, including a tendency to generate illusions, reliance on outdated information, and a lack of domain-specific understanding. A primary approach to addressing these limitations is Retrieval-Enhanced Generation (RAG), which augments the output of LLMs by integrating information from external knowledge bases.

[0003] While text-based RAGs have shown considerable promise, graph-based representations offer a richer paradigm for organizing knowledge. The inherent properties of graphs—such as their ability to explicitly model relationships, minimize redundant information, and support dynamic updates—provide unique advantages. In light of this, recent research has begun to explore the use of knowledge graphs (KGs) as external resources in the RAG process, i.e., KG-RAG, and knowledge graph question answering has become a mainstream task for assessing the extent to which LLMs absorb knowledge from KGs.

[0004] However, almost all currently popular KGQA datasets, such as MetaQA, Webqsp, and SimpleQA, are built on the assumption of knowledge completeness, meaning that all the knowledge required to answer a question is explicitly stored as triples in its corresponding knowledge graph. This is due to their dataset generation process. Take Webqsp as an example. First, there is a set of SPARQL queries in the Freebase knowledge graph, then these queries are executed to retrieve the answer from Freebase, and finally, these SPARQL queries are translated into natural language. Therefore, each natural language question can be mapped to a SPARQL query subgraph within the Freebase KG. Nearly 100% accuracy can be achieved on these datasets using only path traversal or subgraph matching. In other words, as long as this embodiment can retrieve all the necessary triples from the KG, LLM does not need to perform any reasoning work.

[0005] However, this setup is impractical in the real world. Constructing a completely complete knowledge graph that explicitly stores knowledge for any problem is virtually impossible. Therefore, true reasoning capability of LLM is necessary—the ability to derive new knowledge from existing knowledge. Unfortunately, multiple studies have shown that LLM struggles to effectively understand graphs. Even very basic tasks, such as recalling an edge in a graph or calculating the degree of a node, are beyond the capabilities of LLM. Fortunately, graph models are widely considered effective for understanding and reasoning about graphs. Naturally, why doesn't this embodiment leverage the capabilities of graph models to achieve true reasoning in a KG-RAG system? Therefore, this embodiment proposes a framework that leverages the reasoning capabilities of small graph models to supplement the reasoning capabilities of LLMs on knowledge graphs, termed RAKGQA (Reasoning-Enhanced Knowledge Graph Question Answering). To enable small graph models to understand natural language questions, this embodiment considers utilizing the powerful understanding capabilities of LLMs to parse questions into a structured logical form, containing only elements—entities and relations in the knowledge graph (KG). However, LLMs are unaware of the elements present in the KG. To bridge the gap between the internal knowledge of LLMs and the internal knowledge of the KG, this embodiment formalizes the relations in the KG into documents and utilizes document retrieval-enhanced generation techniques to assist LLMs in constructing logical forms using existing relations in the KG. To prevent illusions in LLMs and discrepancies between entities in the question and entities in the KG, a TF-IDF text similarity search algorithm is employed to search the relation and entity corpora of the KG, ultimately mapping all elements in the logical form to the KG. Summary of the Invention

[0006] To address the aforementioned shortcomings in existing technologies, this invention provides a large-scale knowledge graph question answering method with graph embedding retrieval enhancement.

[0007] To achieve the above-mentioned objectives, the technical solution adopted by this invention is as follows: A graph embedding retrieval-enhanced question answering method for large-scale knowledge graph models includes the following steps: S1. Parse natural language problems into structured logical forms; S2. Align the elements in the logical form to the entities and relations in the knowledge graph; S3. Use a graph embedding model to reason about the aligned elements and generate candidate answer entities; S4. Combine the retrieved evidence and candidate answers to generate the final answer.

[0008] Furthermore, step S1 specifically includes the following steps: S11. Use large-scale language models to convert natural language problems into S-expression logical forms; S12. Extract the surface strings of entities and relations from the S-expression.

[0009] Furthermore, step S2 includes the following sub-steps: S21. Use the TF-IDF algorithm to calculate the similarity between the surface string and the knowledge graph entity and relation corpus; S22. Canonical identifiers for mapping surface strings to knowledge graphs based on similarity.

[0010] Furthermore, step S3 includes the following sub-steps: S31. Use graph embedding models to learn vector representations of entities and relations in knowledge graphs; S32. Perform implicit reasoning based on vector representation to generate a pool of candidate answer entities.

[0011] Furthermore, the graph embedding model in S31 adopts an enhanced TransE model, whose scoring function is:

[0012] In the formula, Indicates the head entity. Indicates a relationship. Indicates the tail entity. Represents an embedding vector. It represents a metric in the embedded space.

[0013] Furthermore, step S32 includes the following steps: S321. Calculate the composite embedding vector for each relation-entity pair in the logical form; S322. Generate candidate entities by decoding and combining the embedding vectors in the entity embedding space through k-nearest neighbor search.

[0014] Furthermore, the specific calculation method for the combined embedding vector in S321 is as follows:

[0015] In the formula, This indicates forward traversal, that is... As the head entity This indicates backward traversal, i.e. As a tail entity; Let them represent the j-th aligned entity and relation, respectively. Its corresponding embedding vector; It is a combined vector based on directional markers.

[0016] Furthermore, step S4 includes the following steps: S41. Retrieve evidence triples related to aligned entities and relations from the knowledge graph; S42. Construct a hint that includes the question, evidence, candidate answers, and logical form; S43. Use a large language model to generate answers and perform consistency verification.

[0017] Furthermore, the specific method for constructing the prompt containing the question, evidence, candidate answers, and logical form in S42 is as follows:

[0018] In the formula, Q represents the natural language problem. This represents the evidence triples retrieved. Represents the candidate entity pool. This represents the logical form of an S-expression.

[0019] The present invention has the following beneficial effects: This invention addresses the open-world gap by transforming the problem into a well-typed S-expression, aligning surface strings to the KG namespace using TF-IDF, and elevating the implicit completion of the KG model to explicit priors for constraint generation. Specifically, it uses an enhanced TransE with consistency regularization to generate combinatorial predictions, and... Decode into a bounded candidate pool This candidate pool—along with the evidence retrieved from the text—provides the basis for the LLM's answer. This coupling reduces unconstrained semantic guessing from both the knowledge graph structure and the text. Empirically, RAKGQA achieves state-of-the-art Hits@1 on WebQSP and SimpleQA with significant KG incompleteness, and its graph reasoning module exhibits sub-millisecond reasoning capabilities, matching the actual latency of lightweight vector retrieval. Ablation studies further demonstrate that while text retrieval contributes meaningful gains, the efficient reasoning graph module is the primary driver of robustness in the absence of triples, validating the design of connection symbol alignment and learned geometric priors in this embodiment. Attached Figure Description

[0020] Figure 1 This is a schematic diagram of the flowchart of the large-scale knowledge graph question answering method with graph embedding retrieval enhancement of the present invention.

[0021] Figure 2 This is a schematic diagram illustrating the principle of the efficient inference graph model in an embodiment of the present invention.

[0022] Figure 3 This is a comparison result of the ablation of RAKGQA in this embodiment of the invention with the entities of other text retrieval or graph reasoning modules. Detailed Implementation

[0023] The specific embodiments of the present invention are described below to enable those skilled in the art to understand the present invention. However, it should be understood that the present invention is not limited to the scope of the specific embodiments. For those skilled in the art, various changes are obvious as long as they are within the spirit and scope of the present invention as defined and determined by the appended claims. All inventions utilizing the concept of the present invention are protected.

[0024] A graph embedding retrieval-enhanced large-scale knowledge graph question answering method, such as... Figure 1 As shown, it includes the following steps: S1. Parse natural language problems into structured logical forms; In this embodiment, the explanations of the relevant parameter conformities and markings are shown in Table 1: Table 1. Symbols and Explanations for the RAKGQA Framework

[0025] Knowledge graphs (KGs) are formalized as a set of triples. ,in and These represent sets of entities and sets of relations, respectively. A triplet. Specify header entity Through relationships Connected to tail body KG-based RAG is used to build and constrain the output of LLM. Given a query... The model retrieves relevant information from the knowledge graph. Relevant triples are used to generate answers, thus alleviating problems such as illusion and knowledge obsolescence. Entity linking is often the first step in KG-based RAG. Its goal is to identify a set of entities. These entities in These are explicitly mentioned or implicitly referenced. These topic entities serve as anchors for retrieving relevant knowledge from the graph. Knowledge Graph Question Answering (KGQA) represents a prototype reasoning problem based on a knowledge graph, where queries... This is a natural language problem, and its answer is... This corresponds to one or more entities in a knowledge graph that satisfy specific constraints.

[0026] In KG-based QA, LLM retrieves the head entities. and relationships It does not always correspond to the triples that already exist in KG ( This open-world gap leads to LLMs generating information about tail entities solely based on semantics. The illusion. This embodiment addresses this issue by introducing an enhanced TransE component that performs implicit completion: given ( Even if it does not exist ( It will also predict a combined embedding. Then The generated symbol is decoded into the nearest feasible entity in the KG embedding space. The generated symbol acts as a type-consistent and KG-faithful completion prior, which is fed back to the LLM during answer generation in this embodiment. This design transforms the KG model into a bridge between symbol alignment and text generation: it provides the LLM with a concrete, verifiable candidate, thereby reducing reliance on pure semantic guessing and mitigating illusions.

[0027] This embodiment transforms natural language problems into executable S-expression (prefix) logical forms. This tree-structured representation makes the scope of operator-parameters explicit, enabling deterministic resolution, static type checking, and faithful KG execution. In addition to its syntactic clarity, S-expressions allow this embodiment to append node-local metadata (type, confidence) and enable partial evaluation, so that well-founded subtrees can be executed even if other parts remain ambiguous.

[0028] Construction under LLM conditions. Given the problem. With a prepared Relation Corpus (canonical relation names, operator templates, lightweight type / matrix constraints), LLM drafts a candidate:

[0029] The few-sample hints demonstrate mapping paraphrasing to canonical relations, combining multi-hop JOINs, and selecting aggregators (COUNT, ARGMAX / MIN) under quantifiers / superlatives.

[0030] This embodiment uses knowledge graph triples. A combinatorial query language is defined above, where and These represent the head entity and the tail entity, respectively. Representing relationships. The basic operation is JOIN, which performs a traversal of the single-hop graph and returns a set of entities: Search Header Entity Set , Search tail entity set .

[0031] in Representing a knowledge graph, Representing relations The inverse. More complex multi-hop queries are constructed through nested combinations of JOIN operators, where the output entity set of one operation serves as the input for subsequent operations. For example, the natural language query "movies directed by X and released after 2015" is formalized as: (AND (JOIN directed_by X)(FILTER year>2015)). The query language in this embodiment provides AND / OR operators for set-theoretic intersection and union, FILTER for applying attribute-based predicates to entity sets, and COUNT / ARGMAX / ARGMIN for aggregation and selection operations. Crucially, the type system enforces a distinction between entity sets and scalar values, thereby implementing static type checking that can reject malformed expressions before execution.

[0032] Surface string extraction. Given an S-expression generated from natural language. This embodiment systematically extracts all entity and relation mentions through a deterministic parsing process that traverses the expression tree:

[0033] in and The flag and dir represent the surface string representations of the entities and relations appearing in the original expression, respectively. {forward, inverse} encodes the traversal direction for each relation reference. This extraction produces Each symbol-role tuple needs to be mapped to the knowledge graph namespace.

[0034] Namespace alignment via TF-IDF. Extracted surface string. and Typically, due to variations in wording, abbreviations, and aliases, significant lexical mismatches occur between the dictionary and the standardized knowledge graph identifier. To bridge this gap, this embodiment employs TF-IDF-based retrieval on the comprehensive KG dictionary constructed from entity and relation tags, aliases, and descriptive text. Specifically, this embodiment uses standard TF-IDF weighting for each query string. and each KG entry Vectorize and retrieve data based on cosine similarity. Top of the rankings There are 10 candidates. Then, the alignment process selects the candidate with the highest score, mapping each surface string to its corresponding canonical KG identifier:

[0035] in and These represent the entity and relation vocabularies of the knowledge graph, respectively. The resulting format is structured as follows. This process generates a well-typed S-expression that fully implements the knowledge graph namespace. The generated representation preserves the combinatorial structure of the original query while binding all symbolic references to canonical KG identifiers. This implementation ensures that the expression can be reliably executed on the knowledge graph, producing interpretable results with a clear semantic origin.

[0036] S2. Align the elements in the logical form to the entities and relations in the knowledge graph; This embodiment considers a triplet. Knowledge graph (KG), and in the observed subset of facts Training is performed on each entity. and relationships An embedding is assigned .follow The translation assumption states that the score of a triplet is determined by the distance between the translated combination and the target:

[0037] in Represents the metric in the embedding space (e.g., cosine or Euclidean distance). Negative sampling. For each positive example... This embodiment replaces or (and optional) Construct a set of corrupted negative examples. This embodiment extracts replacements uniformly from an entity (or relation) vocabulary, or by perceiving the distribution of frequencies, to suppress trivial, simple negative examples. When using in-batch negative examples, all heads / tails present in a small batch are treated as additional corrupted samples, and the additional cost is negligible.

[0038]

[0039] like Figure 2 As shown, RAKGQA first transforms the problem into a structured combination of non-closed binary atomic formulas. Then, it applies an efficient graph reasoning module and a text retrieval module to generate evidence triples and candidate entities, respectively.

[0040] In this embodiment, for the boundary ranking objective, a boundary ranking hinge is optimized to force a fixed interval between positive examples and their paired negative examples. :

[0041] Intuitively speaking, the true fact must be greater than its damaged counterpart (in... (Below) at least near The hinge will discard pairs that are already well separated and focus updates on difficult cases.

[0042] To explicitly define the forced translation structure and reduce variance in the embedding space, this embodiment introduces a consistency term that directly minimizes the distance between the combined representation and the target entity:

[0043] This regularization term is as The supplementary objective: While the ranking loss ensures a relative ranking among candidates and becomes inactive after the boundary is met, the consistency term explicitly combines the combined vectors. Pull towards real benchmark embedding This provides continuous supervision. This dual-objective design stabilizes training and improves the geometric fidelity of the learned embedding space.

[0044] Overall goals and optimizations. The training objective combines discriminative power and geometric fidelity:

[0045] This embodiment uses the Adam optimizer with a cosine learning rate scheduling plan and applies post-updated normalization of the entity / relation embeddings. Inference with implicit completion is performed. After aligning the surface forms to canonical KG identifiers, this embodiment retrieves the learned embeddings and constructs a combinatorial prediction for each relation-entity pair in the parsed S-expression. For the... right Calculate the combined vector based on directional markers:

[0046] in This indicates forward traversal (i.e.) As the head entity). Indicates backward traversal (i.e.) (as a tail entity). Then, this embodiment embeds the entity in the space. Nearest Neighbor (kNN) search will each Decoded into specific entity candidates. For each combined query, this embodiment performs the following before retrieval: Individual entities and their distances:

[0047] in This represents the distance metric (Euclidean or cosine). The final candidate pool is formed by aggregating candidates from all queries and passing them by a distance threshold. It was constructed by filtering:

[0048] This aggregation ensures that only high-confidence completions (i.e. those that are geometrically close to their respective combined predictions) are forwarded to the LLM to generate the answer.

[0049] S3. Use a graph embedding model to reason about the aligned elements and generate candidate answer entities; S4. Combine the retrieved evidence and candidate answers to generate the final answer.

[0050] In this embodiment, a core challenge in KG-based QA is the open-world gap: even if TF-IDF alignment produces a canonical header... and relationships Triples It may also be in The lack of a semantic component leads the generator to make unconstrained semantic guesses. To mitigate this, this embodiment elevates the combinatorial prediction of the KG model to a first-order constraint: the enhanced TransE generates a potential target. and through entity embedding Decode it to generate a small candidate pool. (For example, before aggregation by each hop / query) (The pool consists of several neighbors and can be optionally filtered by a distance threshold). This pool serves as a well-defined, type-consistent set of hypotheses, limiting the entity search space during generation.

[0051] Evidence retrieval and implementation. This embodiment retrieves textual / structural evidence centered on alignment symbols (e.g., subject entities and relationships) to provide verifiable context:

[0052] in Including with and The matching triples, adjacent facts, and brief descriptions are then used. This embodiment then synthesizes a landing-based suggestion by connecting the user query, retrieved evidence, the candidate pool derived from the KG, and the parsed S-expression.

[0053] Generation and validation. The final answer is generated by LLM and... There are clear implementation plans in China, and the entities involved will be subject to [the changes]. Constraints / Limitations:

[0054] This is followed by a lightweight consistency check to ensure that the selected entities and relationships are consistent with the KG type and Edge compatibility is observed in the process. This process transforms the case of missing triples into a bounded completion task, reducing illusions while maintaining fluency and verifiability.

[0055] This embodiment utilizes two well-known KGQA benchmarks: WebQSP and SimpleQA, both of which use FreeBase as their underlying KG. WebQuestionsSP contains approximately 4,000 questions, including 1-hop and 2-hop queries. SimpleQuestions is a dataset containing over 100,000 simple 1-hop natural language questions. This embodiment uses a subset of SimpleQuestions, which contains all questions that FreeBase can answer; this is also used for WebQuestionsSP, containing 159,638 questions. To reflect the incompleteness of knowledge in reality, the knowledge graph was randomly removed. or The edges. Detailed statistics for the QA dataset and the underlying KG are shown in Tables 2 and 3, respectively.

[0056] This embodiment compares the method of this embodiment with nine baselines on the KGQA task, including five baselines without LLM and three RAG-based baselines: KVMEM relies on a memory table that stores KG facts and uses this table for retrieval.

[0057] GraftNet identifies query-related subgraphs within a knowledge graph and uses graph neural networks to predict answers.

[0058] PullNet uses the shortest path as a supervision signal to train its graph retrieval component, and then uses GraftNet to perform multi-hop inference on the extracted subgraphs.

[0059] EmbedKGQA facilitates multi-hop reasoning by aligning pre-trained entity embeddings with question embeddings derived from RoBERTa. This implementation omits relation matching.

[0060] BiNet jointly processes KGC and multi-hop KGQA, and formalizes it as a multi-task learning problem.

[0061] ToG is a reasoning framework in which LLM agents perform iterative beam searches on a knowledge graph to explore relevant entities and relationships for in-depth and responsible reasoning.

[0062] StructGPT is a general framework that improves the zero-shot inference capability of LLM for structured data through an iterative "call-linearize-generate" process.

[0063] Readi is an LLM-based KG inference method that focuses on optimizing inference efficiency and reliability, addressing uncertainties in KG to ensure reliable inference results.

[0064] Table 2. Statistics of QA Datasets

[0065] Table 3. Knowledge Graph Statistics

[0066] Model performance was evaluated using the Hits@1 metric, following established standard evaluation protocols. Table 4 shows the performance of all baseline methods. and Experimental results on the WebQSP and SimpleQA datasets under the condition of knowledge graph integrity. As shown in Table 4, the sparsity of the background knowledge graph corresponds to a significant decrease in Hits@1 accuracy in all evaluation methods. This observation shows that the quality and integrity of the background knowledge graph have a crucial impact on the performance of the KGQA task, a point currently neglected by KG-RAG methods.

[0067] Table 4 and Hits@1 results for WQSP, SimpleQA, and KGQA on an incomplete knowledge graph

[0068] Table 4 shows that RAKGQA has a clear and consistent advantage across both datasets and both sparse settings. RAKGQA achieved the highest hits in every column. (on Webqsp / SimpleQA for (72.9 / 70.1), in It outperforms the suboptimal method (Readi) in segmentation. At a point, Superior in segmentation One point. Robustness is equally important: when KG from... Further sparsification to At this point, RAKGQA's performance only showed a modest decline (an absolute decrease of -2.2 and -0.9 on Webqsp and SimpleQA, respectively), while several baselines exhibited more degenerate or unstable behavior (e.g., KV-Mem on Webqsp decreased from 50.1 to 25.8). Classical pure graph and subgraph retrieval methods (GraftNet, PullNet, TOG, EmbedKGQA) tend to be uncompetitive under incompleteness, reflecting their reliance on explicitly present triples; in contrast, Readi and RAKGQA—both combining retrieval and constrained reasoning—maintained high accuracy, with RAKGQA consistently providing the optimal trade-off between accuracy and resilience to missing knowledge. This pattern supports the claim of this embodiment that combining LLM-driven surface understanding with an efficient reasoning graph module not only yields higher absolute accuracy but also significantly improves robustness to KG sparsity.

[0069] To investigate the individual contributions of core modules in RAKGQA, this embodiment conducted an ablation study, comparing the complete model with two ablation variants: one utilizing only the text retrieval module (W-Text-Ret), and the other utilizing only the graph reasoning module (W-Graph-Rea). Results are presented in... and Hits@1 measure on incomplete knowledge graphs (KGs), such as Figure 3 As shown, the complete RAKGQA framework consistently achieves top performance under both KG integrity settings. Notably, the graph reasoning module (W-Graph-Rea) contributes more to overall performance than the text retrieval module (W-Text-Ret), as removing it results in a more significant performance drop. This underscores the crucial role of efficient reasoning graph models in handling the inherent incompleteness of real-world KGs. However, the superior performance of the ensemble model confirms that the text retrieval and graph reasoning modules are complementary, and their synergy is essential for robust question answering.

[0070] This embodiment demonstrates RAKGQA, an inference-enhanced KGQA framework that transforms small, efficient graph models into first-class partners of LLMs. The method addresses the open-world gap by (i) transforming the problem into a well-typed S-expression, (ii) aligning surface strings to the KG namespace via TF-IDF, and (iii) elevating the implicit completion of the KG model to explicit priors for constraint generation. Specifically, enhanced TransE with consistency regularization generates combinatorial predictions and, through… Decode into a bounded candidate pool This candidate pool—along with the evidence retrieved from the text—provides the basis for the LLM answer. This coupling reduces unconstrained semantic guessing from both the knowledge graph structure and the text. Empirically, RAKGQA achieves state-of-the-art Hits@1 on WebQSP and SimpleQA with significant KG incompleteness, and its graph reasoning module has sub-millisecond reasoning capabilities, matching the actual latency of lightweight vector retrieval. Ablation studies further demonstrate that while text retrieval contributes meaningful gains, the efficient reasoning graph module is the main driver of robustness when triples are missing, validating the design of connection symbol alignment and learned geometric priors in this embodiment.

[0071] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0072] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0073] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0074] Specific embodiments have been used to illustrate the principles and implementation methods of this invention. The descriptions of the embodiments above are only for the purpose of helping to understand the method and core ideas of this invention. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this invention. Therefore, the content of this specification should not be construed as a limitation of this invention.

[0075] Those skilled in the art will recognize that the embodiments described herein are intended to help the reader understand the principles of the invention, and should be understood that the scope of protection of the invention is not limited to such specific statements and embodiments. Those skilled in the art can make various other specific modifications and combinations based on the technical teachings disclosed in this invention without departing from the spirit of the invention, and these modifications and combinations are still within the scope of protection of this invention.

Claims

1. A large-scale knowledge graph question answering method with graph embedding retrieval enhancement, characterized in that, Includes the following steps: S1. Parse natural language problems into structured logical forms; S2. Align the elements in the logical form to the entities and relations in the knowledge graph; S3. Use a graph embedding model to reason about the aligned elements and generate candidate answer entities; S4. Combine the retrieved evidence and candidate answers to generate the final answer.

2. The graph embedding retrieval enhancement method for large-scale knowledge graph question answering according to claim 1, characterized in that, S1 specifically includes the following steps: S11. Use large-scale language models to convert natural language problems into S-expression logical forms; S12. Extract the surface strings of entities and relations from the S-expression.

3. The graph embedding retrieval enhancement method for large-scale knowledge graph question answering according to claim 1, characterized in that, S2 includes the following sub-steps: S21. Use the TF-IDF algorithm to calculate the similarity between the surface string and the knowledge graph entity and relation corpus; S22. Canonical identifiers for mapping surface strings to knowledge graphs based on similarity.

4. The graph embedding retrieval enhancement method for large-scale knowledge graph question answering according to claim 1, characterized in that, S3 includes the following sub-steps: S31. Use graph embedding models to learn vector representations of entities and relations in knowledge graphs; S32. Perform implicit reasoning based on vector representation to generate a pool of candidate answer entities.

5. The graph embedding retrieval enhancement method for large-scale knowledge graph question answering according to claim 4, characterized in that, The graph embedding model in S31 adopts an enhanced TransE model, and its scoring function is: In the formula, Indicates the head entity. Indicates a relationship. Indicates the tail entity. Represents an embedding vector. It represents a metric in the embedded space.

6. The graph embedding retrieval enhancement method for large-scale knowledge graph question answering according to claim 4, characterized in that, S32 includes the following steps: S321. Calculate the composite embedding vector for each relation-entity pair in the logical form; S322. Generate candidate entities by decoding and combining the embedding vectors in the entity embedding space through k-nearest neighbor search.

7. The graph embedding retrieval enhancement method for large-scale knowledge graph question answering according to claim 6, characterized in that, The specific calculation method for the combined embedding vector in S321 is as follows: In the formula, This indicates forward traversal, that is... As the head entity This indicates backward traversal, i.e. As a tail entity; Let them represent the j-th aligned entity and relation, respectively. Its corresponding embedding vector; It is a combined vector based on directional markers.

8. The graph embedding retrieval enhancement method for large-scale knowledge graph question answering according to claim 1, characterized in that, S4 includes the following steps: S41. Retrieve evidence triples related to aligned entities and relations from the knowledge graph; S42. Construct a hint that includes the question, evidence, candidate answers, and logical form; S43. Use a large language model to generate answers and perform consistency verification.

9. The graph embedding retrieval enhancement method for large-scale knowledge graph question answering according to claim 8, characterized in that, The specific method for constructing a prompt containing a question, evidence, candidate answers, and logical form in S42 is as follows: In the formula, Q represents the natural language problem. This represents the evidence triples retrieved. Represents the candidate entity pool. This represents the logical form of an S-expression.

Images