Knowledge graph reasoning method and system based on large model

Abstract

The present invention belongs to the field of data processing technology. A knowledge graph reasoning method and system based on a large model is proposed, which realizes interpretable reasoning question and answer for the knowledge graph. In terms of problem processing, the character-level and semantic-level collaboration is firstly adopted to obtain the main entity completely and efficiently, and then the large model Agent is used to reason on the graph. The atomic method is adopted so that the large model has multiple tools to fully search for answers on the graph, which solves the problem that traditional knowledge graph reasoning can only be single-step and single-path. At the same time, the reasoning process is very transparent and traceable, and has strong interpretability.

Description

Technical Field

[0001] The present invention relates to the field of data processing technology, and in particular to a knowledge graph reasoning method and system based on a large model. Background Art

[0002] The statements in this section merely provide background art related to the present invention and do not necessarily constitute prior art.

[0003] As a structured data representation method, knowledge graphs are widely used in question-answering systems, recommendation systems, search engines and other fields. Knowledge graphs organize entities and their relationships in the form of nodes and edges. Through the structured representation of knowledge, computers can understand and reason about complex knowledge relationships, thereby providing intelligent support in tasks such as information query and knowledge mining. However, traditional knowledge graph question-answering systems mainly rely on rule-based retrieval algorithms or simple graph traversal methods, which are usually unable to cope with complex, cross-level reasoning requirements. In addition, traditional question-answering systems have limitations in processing the diversity of natural language expressions, making it difficult to accurately identify user intentions, especially for vague or obscure questions, the system often cannot give accurate answers.

[0004] In recent years, with the rapid development of large-scale language models (such as the GPT series of models), natural language processing technology has made significant progress. Large models have powerful contextual understanding and language generation capabilities, and can understand diverse user inputs and generate semantically consistent response content. However, using large models directly for question-answering reasoning also faces certain challenges. For example, existing large models do not combine structured knowledge graph data, and cannot guarantee the accuracy, interpretability, and reasoning depth of answers. Summary of the invention

[0005] In order to address the deficiencies of the prior art, the present invention provides a knowledge graph reasoning method and system based on a large model, which realizes explainable reasoning questions and answers for the knowledge graph, improves the transparency of the reasoning process, and ensures the traceability of the reasoning process.

[0006] In order to achieve the above object, the present invention adopts the following technical solution:

[0007] In a first aspect, the present invention provides a knowledge graph reasoning method based on a large model.

[0008] A knowledge graph reasoning method based on a large model includes the following processes:

[0009] Use the big model to extract all entities of the natural language question, build an entity list set containing all entities, traverse the entity list set, locate the main entity in the knowledge graph, and obtain the main entity set;

[0010] Use the big model to perform pruning operations on all triples of each main entity in the main entity set to obtain a pruned triple set. The big model determines the atomic method to be used and on which main entity to use the atomic method based on the atomic method set and the pruned triple set, executes the selected atomic method, and gives the result obtained after the atomic method processing to the big model for judgment;

[0011] The large model determines whether the conditions for answering natural language questions are met. If so, it stops reasoning and gives an answer. If not, it returns to the triple pruning process and continues to loop until the number of loops is reached or the conditions for answering natural language questions are met. At this time, reasoning stops and the large model gives an answer.

[0012] As a further limitation of the first aspect of the present invention, locating the main entity in the knowledge graph to obtain the main entity set includes:

[0013] Perform character-level matching on the entities in the entity list set with each entity in the knowledge graph stored in the database to obtain a first candidate entity set;

[0014] Obtaining embedding vectors of entities in the entity list set, and using the embedding vectors to perform cosine similarity calculation with the embedding vectors of all entities in the knowledge graph stored in the vector library to obtain a second candidate entity set;

[0015] The first candidate entity set and the second candidate entity set are merged to obtain the candidate entity set of each entity in the entity list set in the knowledge graph, and the main entity set is obtained by merging the candidate entity sets of all entities.

[0016] As a further limitation of the first aspect of the present invention, the distance between the entities in the entity list set and each entity in the knowledge graph is calculated, and the top k entities with the smallest distance are selected to form a first candidate entity set.

[0017] As a further limitation of the first aspect of the present invention, after the cosine similarity calculation is performed, first k entities with the highest similarity are selected to form a second candidate entity set.

[0018] As a further limitation of the first aspect of the present invention, each main entity e Main All triples T(e Main ), satisfying the following conditions: T(e Main )={(h,r,t)|h=e Main or t=e Main}, the pruned triple set T′(e Main ) is: T′(e Main )={(h,r,t)∈T(e Main)|high relevance score}, where h, r, and t represent the head entity, relationship, and tail entity, respectively.

[0019] As a further limitation of the first aspect of the present invention, the answering conditions for natural language questions include: if part of the question can be answered, or the entire question can be answered, then stop the reasoning; if the result obtained cannot answer the entire question and cannot answer part of the question, then return to the triple pruning process and continue the cycle.

[0020] As a further limitation of the first aspect of the present invention, the large model is an Agent large model.

[0021] In the second aspect, the present invention provides a knowledge graph reasoning system based on a large model.

[0022] A knowledge graph reasoning system based on a large model, comprising:

[0023] The main entity set generation unit is configured to: use the large model to extract all entities of the natural language question, build an entity list set containing all entities, traverse the entity list set, locate the main entity in the knowledge graph, and obtain the main entity set;

[0024] The atomic method processing unit is configured to: use the large model to perform a pruning operation on all triples of each main entity in the main entity set to obtain a pruned triple set; the large model determines the atomic method to be used and on which main entity the atomic method is used according to the atomic method set and the pruned triple set; executes the selected atomic method, and submits the result obtained after the atomic method processing to the large model for judgment;

[0025] The large model judgment unit is configured as follows: the large model judges whether the answer conditions of the natural language question can be met. If so, the reasoning is stopped and an answer is given; if not, the process of triple pruning is returned to continue the cycle until the number of cycles is reached or the answer conditions of the natural language question are met. At this time, the reasoning is stopped and the large model gives an answer.

[0026] In a third aspect, the present invention provides a computer device, comprising: a processor and a computer-readable storage medium;

[0027] a processor adapted to execute a computer program;

[0028] A computer-readable storage medium, wherein a computer program is stored in the computer-readable storage medium, and when the computer program is executed by the processor, the knowledge graph reasoning method based on a large model as described in the first aspect of the present invention is implemented.

[0029] In a fourth aspect, the present invention provides a computer-readable storage medium storing a computer program, wherein the computer program is suitable for being loaded by a processor and executing the large model-based knowledge graph reasoning method as described in the first aspect of the present invention.

[0030] In a fifth aspect, the present invention provides a computer program product, comprising a computer program, which, when executed by a processor, implements the large-model-based knowledge graph reasoning method as described in the first aspect of the present invention.

[0031] Compared with the prior art, the present invention has the following beneficial effects:

[0032] The present invention innovatively proposes a knowledge graph reasoning method based on a large model, and realizes explainable reasoning question and answering for the knowledge graph. In terms of problem processing, it first adopts the collaboration of character level and semantic level to completely and efficiently obtain the main entity, and then uses the large model to reason on the knowledge graph. The atomic method is adopted, so that the large model has multiple tools to fully search for answers on the knowledge graph, which solves the problem that traditional knowledge graph reasoning can only be single-step and single-path. At the same time, the reasoning process is very transparent and traceable, and has strong interpretability.

[0033] Advantages of additional aspects of the present invention will be given in part in the following description, and in part will become obvious from the following description, or will be learned through practice of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] The accompanying drawings in the specification, which constitute a part of the present invention, are used to provide a further understanding of the present invention. The exemplary embodiments of the present invention and their descriptions are used to explain the present invention and do not constitute improper limitations on the present invention.

[0035] Figure 1 A schematic diagram of the principle of the knowledge graph reasoning method based on a large model provided in Example 1 of the present invention;

[0036] Figure 2 A schematic diagram of a knowledge graph reasoning system based on a large model provided in Example 2 of the present invention;

[0037] Figure 3 A schematic diagram of a computer device provided in Example 3 of the present invention. DETAILED DESCRIPTION

[0038] The present invention will be further described below in conjunction with the accompanying drawings and embodiments.

[0039] It should be noted that the following detailed descriptions are exemplary and are intended to provide further explanation of the present invention. Unless otherwise specified, all technical and scientific terms used herein have the same meanings as those commonly understood by those skilled in the art to which the present invention belongs.

[0040] In the absence of conflict, the embodiments of the present invention and the features of the embodiments may be combined with each other.

[0041] Embodiment 1:

[0042] This implementation proposes a knowledge graph reasoning method based on a large model. Taking the large model agent as an example, by combining the natural language processing capabilities of the large model agent with the structured information of the knowledge graph, it is expected to achieve breakthroughs in complex question-answering reasoning, dynamic knowledge updating, and unstructured data integration, providing stronger intelligent support and technical advantages for the knowledge graph question-answering system. Specific reasoning methods, such as Figure 1 As shown, the following process is included:

[0043] S1: Main entity positioning.

[0044] For natural language question Q, we first use the big model to extract possible entities in the question. Here, we extract all entities in the question and form an entity list set with the extracted entities. Traverse the entity list set E Q , for each entity Perform operations on each entity The following two methods are used to locate the main entity in the knowledge graph.

[0045] Method 1: Character level matching.

[0046] The entities in the current problem entity set All entities E in the knowledge graph stored in the database KG Perform character-level matching and use the Levenshtein algorithm to calculate With each entity in the knowledge graph The distance between ij , select the first k entities with the smallest distance to form a candidate entity set:

[0047] Method 2: Embedding vector similarity calculation.

[0048] Get the entities in the current problem entity set The embedding vector Use this embedding vector and the embedding vectors of all entities in the knowledge graph stored in the vector library Calculate the cosine similarity:

[0049]

[0050] Select the top k entities with the highest similarity to form a candidate entity set:

[0051] The candidate entity sets obtained by the above two methods are combined to obtain The set of candidate entities in the knowledge graph:

[0052]

[0053] For all Merge to get the main entity collection:

[0054]

[0055] S2: Problem reasoning.

[0056] For the main entity set E Main For each entity in, a parallel reasoning process is started.

[0057] S2.1: Get all triples of the entity.

[0058] For each main entity e Main ∈E Main , obtain all triples of the main entity T(e Main ), the extracted triples need to meet the following conditions:

[0059] T(e Main )={(h,r,t)|h=e Main or t=e Main}(4);

[0060] Among them, the triple is expressed in the form of head entity-relationship-tail entity, and h, r, and t represent the head entity, relationship, and tail entity respectively.

[0061] S2.2: Triplet pruning.

[0062] Use the large model to analyze all triples of a single main entity T(e Main ) performs pruning operations, retaining the triples that may be related to answering question Q, and obtaining the pruned triple set:

[0063] T ′ (e Main )={(h,r,t)∈T(e Main )|High relevance score}(5);

[0064] S2.3: Define atomic methods.

[0065] Define atomic methods. Atomic methods are defined as some basic and standardized operation methods that are commonly used to achieve efficient data processing and flexible expansion of graphs. The core of atomic methods is to provide the smallest, indivisible operation unit to ensure that the operations of knowledge graph question answering can be efficient, flexible and composable. This implementation method designs a set of atomic methods. The atomic methods currently provided for specific knowledge graph structures are:

[0066] (1) GetEntityTriples(entity): Get all triples related to the specified entity in the knowledge graph;

[0067] (2) GetConnectedEntities(entity): Get all entities directly connected to the specified entity;

[0068] (3) GetEntityAttributes(entity): Get all attributes and their values ​​of the specified entity;

[0069] (4) FindRelationsBetweenEntities(entity1,entity2): Find the direct relationship between two entities;

[0070] (5)GetEntitiesByAttribute(attribute,value): Find entities based on attribute values.

[0071] S2.4: Large model judgment and selection of atomic methods.

[0072] The atomic method collection And the pruned triple set T of the main entity obtained in the previous step ′ (e Main ) are sent to the big model agent, which determines the atomic method to be used and on which entity the atomic method needs to be used. The schema of the knowledge graph is synchronized to the big model at the same time. In addition, the usage method, calling form and output result of the atomic method are synchronized to the big model. The big model determines how to call the atomic method based on this information and outputs it in json format.

[0073] S2.5: Perform atomic methods.

[0074] Atomic methods that need to be executed according to the large model agent selection and related entities, execute the atomic method The obtained results are then handed over to the large model Agent for judgment.

[0075] S2.6: Results Evaluation

[0076] The large model autonomously determines whether the current result is sufficient to answer question Q, or is sufficient to answer part of the question; if the large model Agent determines that it is sufficient to answer part of the question, or is sufficient to answer the entire question based on the result of S2.5, then the reasoning stops; if the large model Agent determines that the current conditions are not sufficient to answer the question, and is insufficient to answer part of the question, then the loop execution process continues, and the currently inferred entity and all its triples continue to start step S2.2.

[0077] S2.7: Loop iteration.

[0078] According to the result of S2.7, the reasoning cycle can be repeated up to three times. If the correct answer is not obtained, the exit condition is reached at the same time.

[0079] S2.8: Result generation.

[0080] Summarize all the inference results and give them to the big model to answer the questions and get the final answer.

[0081] Embodiment 2:

[0082] like Figure 2 As shown, this implementation provides a knowledge graph reasoning system based on a large model, including:

[0083] The main entity set generation unit is configured to: use the large model to extract all entities of the natural language question, build an entity list set containing all entities, traverse the entity list set, locate the main entity in the knowledge graph, and obtain the main entity set;

[0084] The atomic method processing unit is configured to: use the large model to perform a pruning operation on all triples of each main entity in the main entity set to obtain a pruned triple set; the large model determines the atomic method to be used and on which main entity the atomic method is used according to the atomic method set and the pruned triple set; executes the selected atomic method, and submits the result obtained after the atomic method processing to the large model for judgment;

[0085] The large model judgment unit is configured as follows: the large model judges whether the answer conditions of the natural language question can be met. If so, the reasoning is stopped and an answer is given; if not, the process of triple pruning is returned to continue the cycle until the number of cycles is reached or the answer conditions of the natural language question are met. At this time, the reasoning is stopped and the large model gives an answer.

[0086] The specific working process of each of the above units is described in Example 1 and will not be repeated here.

[0087] It is understandable that the above-mentioned various units can be separately or all combined into one or several other units to constitute, or some (some) units therein can also be split into multiple smaller units in function to constitute, which can achieve the same operation without affecting the realization of the technical effects of the embodiments of the present application. The above-mentioned units are divided based on logical functions. In practical applications, the function of a unit can also be realized by multiple units, or the function of multiple units can be realized by one unit. In other embodiments of the present application, the system can also include other units. In practical applications, these functions can also be implemented with the assistance of other units, and can be implemented by the collaboration of multiple units.

[0088] According to another embodiment of the present application, the system described in this embodiment can be constructed, and the method of Example 1 of the present application can be implemented by running a computer program (including program code) capable of executing the steps involved in the corresponding method described in Example 1 on a general computing device such as a computer, which includes processing elements and storage elements such as a central processing unit (CPU), random access memory (RAM), and read-only memory (ROM). The computer program can be recorded on, for example, a computer-readable recording medium, and loaded into the above-mentioned computing device through the computer-readable recording medium and run therein.

[0089] Embodiment 3:

[0090] like Figure 3 As shown, this implementation provides an electronic device, which includes a processor 1001, a communication interface 1002, and a computer-readable storage medium 1003. The processor 1001, the communication interface 1002, and the computer-readable storage medium 1003 may be connected via a bus or other means.

[0091] Among them, the communication interface 1002 is used to receive and send data, the computer-readable storage medium 1003 can be stored in the memory of the electronic device, the computer-readable storage medium 1003 is used to store a computer program, the computer program includes program instructions, and the processor 1001 is used to execute the program instructions stored in the computer-readable storage medium 1003.

[0092] Processor 1001 (or CPU (Central Processing Unit)) is the computing core and control core of the electronic device, which is suitable for implementing one or more instructions, specifically suitable for loading and executing one or more instructions to implement corresponding method processes or corresponding functions.

[0093] The processor 1001 is configured to execute the following process:

[0094] Use the big model to extract all entities of the natural language question, build an entity list set containing all entities, traverse the entity list set, locate the main entity in the knowledge graph, and obtain the main entity set;

[0095] Use the big model to perform pruning operations on all triples of each main entity in the main entity set to obtain a pruned triple set. The big model determines the atomic method to be used and on which main entity to use the atomic method based on the atomic method set and the pruned triple set, executes the selected atomic method, and gives the result obtained after the atomic method processing to the big model for judgment;

[0096] The large model determines whether the conditions for answering natural language questions are met. If so, it stops reasoning and gives an answer. If not, it returns to the triple pruning process and continues to loop until the number of loops is reached or the conditions for answering natural language questions are met. At this time, reasoning stops and the large model gives an answer.

[0097] The specific working process is described in Example 1 and will not be repeated here.

[0098] Embodiment 4:

[0099] This implementation provides a computer-readable storage medium (Memory), which is a memory device in an electronic device for storing programs and data. It is understandable that the computer-readable storage medium here can include both built-in storage media in the electronic device and, of course, extended storage media supported by the electronic device. The computer-readable storage medium provides a storage space that stores the processing system of the electronic device.

[0100] In addition, the storage space also stores one or more instructions suitable for being loaded and executed by the processor, and these instructions may be one or more computer programs (including program codes). It should be noted that the computer-readable storage medium here may be a high-speed RAM memory, or a non-volatile memory, such as at least one disk memory; optionally, it may also be at least one computer-readable storage medium located away from the aforementioned processor.

[0101] In one embodiment, the computer-readable storage medium stores one or more instructions; the processor loads and executes the one or more instructions stored in the computer-readable storage medium to implement the following process:

[0102] Use the big model to extract all entities of the natural language question, build an entity list set containing all entities, traverse the entity list set, locate the main entity in the knowledge graph, and obtain the main entity set;

[0103] Use the big model to perform pruning operations on all triples of each main entity in the main entity set to obtain a pruned triple set. The big model determines the atomic method to be used and on which main entity to use the atomic method based on the atomic method set and the pruned triple set, executes the selected atomic method, and gives the result obtained after the atomic method processing to the big model for judgment;

[0104] The large model determines whether the conditions for answering natural language questions are met. If so, it stops reasoning and gives an answer. If not, it returns to the triple pruning process and continues to loop until the number of loops is reached or the conditions for answering natural language questions are met. At this time, reasoning stops and the large model gives an answer.

[0105] The specific working process is described in Example 1 and will not be repeated here.

[0106] Embodiment 5:

[0107] The present implementation provides a computer program product or a computer program, which includes computer instructions stored in a computer-readable storage medium. A processor of an electronic device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, so that the electronic device performs the following process:

[0108] Use the big model to extract all entities of the natural language question, build an entity list set containing all entities, traverse the entity list set, locate the main entity in the knowledge graph, and obtain the main entity set;

[0109] Use the big model to perform pruning operations on all triples of each main entity in the main entity set to obtain a pruned triple set. The big model determines the atomic method to be used and on which main entity to use the atomic method based on the atomic method set and the pruned triple set, executes the selected atomic method, and gives the result obtained after the atomic method processing to the big model for judgment;

[0110] The large model determines whether the conditions for answering natural language questions are met. If so, it stops reasoning and gives an answer. If not, it returns to the triple pruning process and continues to loop until the number of loops is reached or the conditions for answering natural language questions are met. At this time, reasoning stops and the large model gives an answer.

[0111] The specific working process is described in Example 1 and will not be repeated here.

[0112] A person skilled in the art can appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed in this application can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. A person skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of this application.

[0113] In the above embodiments, it can be implemented in whole or in part by software, hardware, firmware or any combination thereof. When implemented using software, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When loading and executing computer program instructions on a computer, the process or function according to the embodiment of the present application is generated in whole or in part. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable devices. The computer instructions can be stored in a computer-readable storage medium or transmitted by a computer-readable storage medium. The computer instructions can be transmitted from a website site, a computer, a server or a data center to another website site, a computer, a server or a data center by wired (for example, coaxial cable, optical fiber, digital line (DSL)) or wireless (for example, infrared, wireless, microwave, etc.) mode. The computer-readable storage medium can be any available medium that a computer can access or a data processing device such as a server, a data center, etc. that contains one or more available media integrated. The available medium can be a magnetic medium (for example, a floppy disk, a hard disk, a tape), an optical medium (for example, a DVD), or a semiconductor medium (for example, a solid-state hard disk (SSD)), etc.

[0114] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. For those skilled in the art, the present invention may have various modifications and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention shall be included in the protection scope of the present invention.

Claims

1. A knowledge graph reasoning method based on a large model, characterized in that: The process includes: Use the big model to extract all entities of the natural language question, build an entity list set containing all entities, traverse the entity list set, locate the main entity in the knowledge graph, and obtain the main entity set; Use the big model to perform pruning operations on all triples of each main entity in the main entity set to obtain a pruned triple set. The big model determines the atomic method to be used and on which main entity to use the atomic method based on the atomic method set and the pruned triple set, executes the selected atomic method, and gives the result obtained after the atomic method processing to the big model for judgment; The large model determines whether the conditions for answering natural language questions are met. If so, it stops reasoning and gives an answer. If not, it returns to the triple pruning process and continues to loop until the number of loops is reached or the conditions for answering natural language questions are met. At this time, reasoning stops and the large model gives an answer.

2. The knowledge graph reasoning method based on a large model as claimed in claim 1, characterized in that: Locate the main entity in the knowledge graph and obtain the main entity set, including: Perform character-level matching on the entities in the entity list set with each entity in the knowledge graph stored in the database to obtain a first candidate entity set; Obtaining embedding vectors of entities in the entity list set, and using the embedding vectors to perform cosine similarity calculation with the embedding vectors of all entities in the knowledge graph stored in the vector library to obtain a second candidate entity set; The first candidate entity set and the second candidate entity set are merged to obtain the candidate entity set of each entity in the entity list set in the knowledge graph, and the main entity set is obtained by merging the candidate entity sets of all entities.

3. The knowledge graph reasoning method based on a large model as claimed in claim 2, characterized in that: Calculate the distance between the entities in the entity list set and each entity in the knowledge graph, and select the top k entities with the smallest distance to form the first candidate entity set.

4. The knowledge graph reasoning method based on a large model as claimed in claim 2, characterized in that: After calculating the cosine similarity, the first k entities with the highest similarity are selected to form the second candidate entity set.

5. The knowledge graph reasoning method based on a large model as claimed in claim 1, characterized in that: Each main entity Main All triples T(e Main ), satisfying the following conditions: T(e Main )={(h,r,t)|h=e Main or t=e Main }, the pruned triple set T ′ (e Main ) is: T ′ (e Main )={(h,r,t)∈T(e Main )|high relevance score}, where h, r, and t represent the head entity, relationship, and tail entity, respectively.

6. The knowledge graph reasoning method based on a large model as claimed in claim 1, characterized in that: The answering conditions for natural language questions include: if part of the question can be answered, or the whole question can be answered, then stop the reasoning; if the result obtained cannot answer the whole question and cannot answer part of the question, then return to the process of triple pruning and continue the cycle; or, the large model is an Agent large model.

7. A knowledge graph reasoning system based on a large model, characterized in that: include: The main entity set generation unit is configured to: use the large model to extract all entities of the natural language question, build an entity list set containing all entities, traverse the entity list set, locate the main entity in the knowledge graph, and obtain the main entity set; The atomic method processing unit is configured to: use the large model to perform a pruning operation on all triples of each main entity in the main entity set to obtain a pruned triple set; the large model determines the atomic method to be used and on which main entity the atomic method is used according to the atomic method set and the pruned triple set; executes the selected atomic method, and submits the result obtained after the atomic method processing to the large model for judgment; The large model judgment unit is configured as follows: the large model judges whether the answer conditions of the natural language question can be met. If so, the reasoning is stopped and an answer is given; if not, the process of triple pruning is returned to continue the cycle until the number of cycles is reached or the answer conditions of the natural language question are met. At this time, the reasoning is stopped and the large model gives an answer.

8. A computer device, characterized in that: include: A processor and a computer readable storage medium; a processor adapted to execute a computer program; A computer-readable storage medium, wherein a computer program is stored in the computer-readable storage medium, and when the computer program is executed by the processor, the large-model-based knowledge graph reasoning method is implemented as described in any one of claims 1 to 6.

9. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, which is suitable for being loaded by a processor and executing the large-model-based knowledge graph reasoning method as described in any one of claims 1 to 6.

10. A computer program product, characterized in that The computer program product includes a computer program, and when the computer program is executed by a processor, it implements the large model-based knowledge graph reasoning method as described in any one of claims 1 to 6.

Images