Knowledge graph construction based on multiple agents

Abstract

The invention provides a multi-agent-based knowledge graph construction method. The method comprises the steps of obtaining knowledge data; obtaining a demand description for the target knowledge graph; and generating the target knowledge graph based on the knowledge data and the demand description by using a hierarchical multi-agent framework, the hierarchical multi-agent framework comprising a plurality of agents arranged in a hierarchical manner.

Description

Technical Field

[0001] This disclosure relates generally to the field of computer science, and more specifically to methods and apparatus for constructing knowledge graphs based on multi-agent systems. Background Technology

[0002] The concept of AI agents has been proposed in the field of Artificial Intelligence (AI). An AI agent, also simply called an agent, is an intelligent entity driven by an AI model. Under the guidance of an AI model, an agent typically possesses capabilities such as perception, decision-making, and action, enabling it to autonomously complete a given goal without requiring human intervention for each step. Summary of the Invention

[0003] According to one aspect of this disclosure, a method for constructing a multi-agent-based knowledge graph is provided, comprising: obtaining knowledge data; obtaining a requirement description for a target knowledge graph; and generating the target knowledge graph based on the knowledge data and the requirement description using a hierarchical multi-agent framework, wherein the hierarchical multi-agent framework includes a plurality of agents arranged in a hierarchical manner.

[0004] According to another aspect of this disclosure, an apparatus for constructing a multi-agent-based knowledge graph is provided, comprising: a memory and a processor. The processor is coupled to the memory and configured to perform a method according to any of the various embodiments of this disclosure.

[0005] According to another aspect of this disclosure, a computer-readable medium is provided that stores a computer program including instructions that, when executed by a processor, cause the processor to be configured to perform a method according to any of the various embodiments of this disclosure.

[0006] According to another aspect of this disclosure, a computer program product is provided, including computer executable instructions that, when executed, cause one or more processors to perform a method according to any of the various embodiments of this disclosure. Attached Figure Description

[0007] Various embodiments of the claimed subject matter will now be described by way of example with reference to the accompanying drawings. In the different drawings, the same reference numerals are used to denote the same or similar parts.

[0008] Figure 1 A schematic diagram of the overall architecture for constructing a knowledge graph using a hierarchical multi-agent framework according to an example embodiment of the present disclosure is shown.

[0009] Figure 2A block diagram of an exemplary structure of an intelligent agent at the management level is shown according to an example embodiment of the present disclosure.

[0010] Figure 3 A block diagram illustrating an exemplary structure of an agent at the scheduling layer according to an example embodiment of the present disclosure is shown.

[0011] Figure 4 A block diagram of an exemplary structure of an agent at the working layer according to an example embodiment of the present disclosure is shown.

[0012] Figure 5 A schematic diagram of an exemplary structure of a hierarchical multi-agent framework for constructing a knowledge graph, according to an example embodiment of the present disclosure, is shown.

[0013] Figure 6 An example embodiment of the present disclosure is illustrated using the combination of... Figure 5 A sequence diagram describing a hierarchical multi-agent framework for performing knowledge graph construction operations.

[0014] Figure 7 An example flowchart of a method for constructing a multi-agent-based knowledge graph according to an example embodiment of the present disclosure is shown.

[0015] Figure 8 An exemplary apparatus for constructing a multi-agent-based knowledge graph is shown according to an example embodiment of the present disclosure. Detailed Implementation

[0016] In the following description, numerous specific details are set forth to provide a thorough understanding of embodiments of this disclosure. However, those skilled in the art will recognize that this disclosure may be practiced without one or more of these specific details, or that alternative methods, components, etc., may be used. In some instances, well-known structures and operations have not been shown or described in detail so as not to unnecessarily obscure this disclosure.

[0017] Given the advantages of agents, such as those driven by Large Language Models (LLMs), in natural language processing, there are ongoing efforts to introduce agent technology into various natural language processing task scenarios in order to improve task processing efficiency.

[0018] A typical complex natural language processing (NLP) task scenario may include knowledge graph construction. A knowledge graph is a semantic network that reveals the relationships between knowledge entities. It provides a rich, machine-understandable semantic model and can be used to achieve functions such as knowledge querying and knowledge reasoning. Common knowledge graph construction processes include stages such as extracting knowledge from data, developing an ontology, and generating the knowledge graph based on the extracted knowledge and the developed ontology. These stages typically involve complex NLP operations. These complex NLP operations often require extensive human involvement (e.g., experts).

[0019] However, it has been found that individual agents are often limited by their capabilities and cannot provide satisfactory performance when faced with such complex natural language processing tasks.

[0020] This disclosure proposes an improved hierarchical multi-agent framework. In this framework, multiple agents are arranged hierarchically at multiple levels and each performs operations corresponding to its level. In this way, the agents in the hierarchical multi-agent framework can cooperate with each other to achieve a specific goal. This improved hierarchical multi-agent framework can fully utilize the various capabilities of each agent in performing natural language processing operations, thereby exhibiting better performance for natural language processing tasks, especially complex natural language processing tasks such as knowledge graph construction.

[0021] This disclosure uses a knowledge graph construction task scenario as an example to describe the application of the proposed improved hierarchical multi-agent framework in complex natural language processing task scenarios.

[0022] Overall, this improved hierarchical multi-agent framework can automatically execute the knowledge graph construction process based on the knowledge data used to construct the knowledge graph and the requirement description for the knowledge graph to be constructed.

[0023] On the one hand, the proposed hierarchical multi-agent framework helps to provide better autonomy in the knowledge graph construction process. Each agent in the hierarchical multi-agent framework can independently complete its corresponding operation, thereby automatically and jointly achieving the goal of knowledge graph construction without requiring a large amount of manual operation as in existing knowledge graph construction mechanisms.

[0024] On the other hand, the proposed hierarchical multi-agent framework helps to provide better scalability in the knowledge graph construction process. The process of using the hierarchical multi-agent framework to perform knowledge graph construction is not limited by the data size, data domain, etc. of the knowledge data used to build the knowledge graph, thus it can be easily extended to task scenarios for building knowledge graphs for various large and complex datasets.

[0025] On the other hand, the proposed hierarchical multi-agent framework helps to provide higher efficiency in the knowledge graph construction process. The hierarchical multi-agent framework can automatically decompose the knowledge graph construction goal into a series of tasks / subtasks that are executed independently by the corresponding agents. This allows for the parallel execution of some tasks / subtasks, thereby improving the efficiency of the knowledge graph construction process.

[0026] Furthermore, the proposed hierarchical multi-agent framework facilitates the full utilization of the natural language processing capabilities of agents during knowledge graph construction. This framework effectively leverages the powerful natural language processing capabilities provided by agents deployed at each level, resulting in superior performance when constructing knowledge graphs, particularly domain-specific ones that require more accurate and targeted natural language processing.

[0027] The principles of the mechanism for constructing knowledge graphs using the hierarchical multi-agent framework of this disclosure will be further described in detail below with reference to the accompanying drawings.

[0028] Figure 1 A schematic diagram of the overall architecture for constructing a knowledge graph using a hierarchical multi-agent framework according to an example embodiment of the present disclosure is shown. This overall architecture may involve providing knowledge data 110 and a requirement description 120 as input to a hierarchical multi-agent framework 130. The hierarchical multi-agent framework 130 can automatically perform a knowledge graph construction process based on the knowledge data 110 and the requirement description 120. The knowledge graph generated by performing the knowledge graph construction process can be referred to as the target knowledge graph, for example, Figure 1 The target knowledge graph shown is 140.

[0029] Knowledge data 110 refers to data from which knowledge can be extracted for constructing a knowledge graph. Knowledge data 110 can also be referred to as source data, initial data, etc., for constructing a knowledge graph. The knowledge graph construction process of this disclosure adopts an ontology-based knowledge graph construction method known in the art, and therefore, knowledge data 110 can also be understood as data used to perform data filling operations on the ontology to construct the knowledge graph. In one example, the hierarchical multi-agent framework of this disclosure can be used to construct a knowledge graph for a general domain, and in this example, knowledge data 110 may include general knowledge data for the general domain, such as common sense data. In another example, the hierarchical multi-agent framework of this disclosure can be used to construct a knowledge graph for a specific domain, and in this example, knowledge data 110 may include domain knowledge data for that specific domain.

[0030] Requirements description 120 describes the characteristics that the knowledge graph to be constructed (i.e., the target knowledge graph 140) should possess. Requirements description 120 can be provided by the user and describes what kind of knowledge graph the user expects to construct using the hierarchical multi-agent framework 130. Requirements description 120 can include descriptions of the target knowledge graph 140 in several aspects, such as the data domain involved in the target knowledge graph 140, the expected representation and storage format of the target knowledge graph 140, and the expected application scenarios of the target knowledge graph 140. Requirements description 120 can be used to guide the hierarchical multi-agent framework 130 in constructing the target knowledge graph 140 with characteristics that meet the user's expectations. It should be noted that this disclosure does not limit the data format used in requirements description 120; on the contrary, requirements description 120 can use any data format that the hierarchical multi-agent framework 130 can recognize.

[0031] The hierarchical multi-agent framework 130 can automatically perform the knowledge graph construction process based on knowledge data 110 and requirement descriptions 120. The hierarchical multi-agent framework 130 adopts a structure that hierarchically arranges multiple agents at multiple levels. For example... Figure 1 As shown, in the hierarchical multi-agent framework 130, multiple agents can be arranged at three levels. For example, the hierarchical multi-agent framework 130 may include a managing layer (ML) 150, a dispatching layer (DL) 160, and a working layer (WL) 170. In the above three levels, the managing layer 150 may correspond to the top level of the hierarchical multi-agent framework 130, the working layer 170 may correspond to the bottom level of the hierarchical multi-agent framework 130, and the dispatching layer 160 may correspond to the intermediate layer between the top and bottom levels of the hierarchical multi-agent framework 130.

[0032] The agents at these three levels can interact and collaborate, enabling the hierarchical multi-agent framework to automatically and efficiently complete the knowledge graph construction process. Each agent in the hierarchical multi-agent framework 130 is driven by an AI model. In one example, this AI model can be based on an LLM (Language Modeling). An LLM is a large-scale language model capable of efficiently performing general language understanding and generation. This capability is acquired by learning a large number of parameters using a large amount of data during training. In another example, the AI ​​model can be based on other AI models with natural language processing capabilities. In one example, the agents in the hierarchical multi-agent framework 130 can be driven by AI models with the same model architecture, allowing each agent to provide similar natural language processing capabilities. In another example, the agents in the hierarchical multi-agent framework 130 can be driven by AI models with different model architectures, allowing each agent to provide different natural language processing capabilities.

[0033] An agent, such as agent 151, can be deployed at the management layer 150. Agent 151 acts as a manager in the hierarchical multi-agent framework 130 to manage the knowledge graph construction process holistically. For example, agent 151 can manage the operations of agents at levels below management layer 150 (e.g., scheduling layer 160, worker layer 170). The following will combine... Figure 2 Further discussion will focus on the details related to the agents in management level 150.

[0034] One or more agents can be deployed at the scheduling layer 160, for example, M agents 161-1, ..., 161-M. In one example, each agent among agents 161-1, ..., 161-M can be used to execute operations under the management of agent 151. In another example, each agent among agents 161-1, ..., 161-M can also be used to manage the operations of a group of agents at the working layer 170. The following will combine... Figure 3 Further discussion of the details related to the agents in scheduling layer 160.

[0035] Multiple agents can be deployed at working layer 170, for example, N agents 171-1, 171-2, ..., 171-N. Each agent among agents 171-1, 171-2, ..., 171-N can perform operations under the management of agent 151 or under the management of the corresponding agent among agents 161-1, ..., 161-M. The following will combine... Figure 4 Further discussion of the details related to the agent at working layer 170.

[0036] In one example, within the hierarchical multi-agent framework 130, multiple agents can be deployed at different levels based on their respective capabilities. For instance, in the hierarchical multi-agent framework 130, upper-level agents typically have the ability to manage the operations of lower-level agents, while lower-level agents typically have the ability to perform operations under the management of upper-level agents. In one example, upper-level agents typically possess stronger planning and decision-making capabilities compared to lower-level agents, thereby enabling them to manage lower-level agents.

[0037] The target knowledge graph 140 generated by the hierarchical multi-agent framework 130 can be represented and stored in any manner known in the art. In one example, the target knowledge graph 140 can be represented and stored as a Resource Description Framework (RDF) graph. RDF is a standardized schema for knowledge graphs. In an RDF graph, each piece of knowledge is organized in the format of triples {S, P, O}, where S (short for Subject) represents the subject, O (short for Object) represents the object associated with the subject, and P (short for Predicate) represents the relationship between the subject and the object. In one example, the RDF graph can be represented as a directed graph, where entities are visually represented using circles and relationships between entities are represented using directed edges with arrows.

[0038] The generated target knowledge graph 140 can be further used to perform various downstream tasks. For example, the target knowledge graph 140 can be accessed through a knowledge graph query / reasoning engine to query existing knowledge in the target knowledge graph 140, predict / reason new knowledge based on existing knowledge in the target knowledge graph 140, etc.

[0039] Although the above combination Figure 1 The process of constructing a target knowledge graph 140 using a hierarchical multi-agent framework 130 has been discussed. However, in another example, the hierarchical multi-agent framework 130 can also be used for other task scenarios, such as constructing a property graph. In a property graph, the relationship between two entities a and b can be represented in the format (a, relation, b). Compared to knowledge graphs, data representations in property graphs typically have relatively low standardization or relatively high flexibility. In other words, operations used to construct knowledge graphs can be backward compatible with the construction of property graphs to some extent. In this example, those skilled in the art can adaptively apply the hierarchical multi-agent framework 130 to the property graph construction task scenario by making adaptive modifications to the agents at the working layer in the hierarchical multi-agent framework 130 (e.g., modifying them to be more suitable for constructing property graphs).

[0040] Figure 2 A block diagram of an exemplary structure of an intelligent agent 210 at the management level according to an example embodiment of the present disclosure is shown.

[0041] Figure 2 The agent 210 shown can correspond to, for example, the combination described above. Figure 1 The agent under discussion is 151.

[0042] The agent 210 may include a perception module 211. The perception module 211 is used to obtain perception data from outside the agent 210. The perception module 211 can serve as an entry point for data interaction between the agent 210 and the outside world, allowing the agent 210 to receive input from the outside via the perception module 211. In one example, the input received via the perception module 211 may include input from outside the hierarchical multi-agent framework, for example, as described above. Figure 1 The discussion focuses on knowledge data 110 and requirement descriptions 120 received from outside the hierarchical multi-agent framework. In other words, in this example, agent 210 acts as an agent providing data input capabilities within the hierarchical multi-agent framework. It should be understood that using agent 210 as an agent providing data input capabilities within the hierarchical multi-agent framework is merely an example, and other agents within the hierarchical multi-agent framework may be configured to provide data input capabilities in other examples. In one example, the input received via the perception module 211 may also include input from other agents within the hierarchical multi-agent framework, such as candidate sub-plans from agents at the scheduling layer (which can be used by agent 210 to generate a knowledge graph construction plan, as discussed in detail below), task feedback data from agents at the scheduling layer and / or working layer, etc., to facilitate agent 210's management of agents at the scheduling layer and / or working layer. In one example, the perception module 211 may process the received input to generate perception data. The processing performed by the perception module 211 on the received data can include any data processing operation known in the art, such as parsing, decoding, conversion, transformation, etc. The perceived data generated by such data processing operations can be recognized and further processed by other modules of the intelligent agent 210.

[0043] Agent 210 may include a planning module 212. The planning module 212 can act as the decision-making center of agent 210 to perform various planning and decision-making operations. The planning module 212 can autonomously decompose the goals to be achieved by agent 210 into a series of executable steps and formulate strategies for implementing each step. In one example, the planning module 212 may be communicatively coupled to the perception module 211 and can perform planning and decision-making operations based on perception data generated by the perception module 211. The planning and decision-making operations performed by the planning module 212 may include, for example, generating a knowledge graph construction plan for the entire knowledge graph construction process, generating tasks / subtasks to be executed by agents at the scheduling layer and / or working layer according to the generated knowledge graph construction plan, and managing the execution of the corresponding tasks / subtasks by agents at the scheduling layer and / or working layer, etc.

[0044] The agent 210 may include an execution module 213. The execution module 213 can act as the action execution mechanism of the agent 210 to perform various specific actions. In one example, the execution module 213 may be communicatively coupled to the planning module 212 and can execute a series of steps to achieve a goal according to the strategy defined by the planning module 212. The execution module 213 can also serve as an outlet for data interaction between the agent 210 and the outside world, providing output to the outside. In one example, the output provided via the execution module 213 may include output provided to the outside of the hierarchical multi-agent framework, for example, in conjunction with the above... Figure 1 The generated target knowledge graph 140 is discussed. In other words, in this example, agent 210 acts as an agent providing data output capabilities within a hierarchical multi-agent framework. It should be understood that using agent 210 as an agent providing data output capabilities within a hierarchical multi-agent framework is merely an example, and other agents within the hierarchical multi-agent framework can be configured to provide data output capabilities in other examples. In one example, the output provided via execution module 213 may also include output provided to other agents within the hierarchical multi-agent framework. Output provided to other agents may include various commands, instructions, etc., for implementing the management of these other agents. For example, execution module 213 may be used to assign the tasks / subtasks generated by planning module 212 based on the knowledge graph construction plan to the corresponding agents at the scheduling layer and / or working layer. In one example, execution module 213 may invoke external tool 220 during the execution of various specific actions. External tool 220 may include any type of tool capable of interacting with agent 210, including various application programming interfaces (APIs), databases, software libraries, services, hardware devices, etc.

[0045] The agent 210 may include a memory module 214. The memory module 214 is used to remember the data processed by the agent 210. For example, the memory module 214 may be communicatively coupled to the perception module 211, the planning module 212, and the execution module 213 respectively to remember the data processed by each module. The data remembered by the memory module 214 may also be provided to the perception module 211, the planning module 212, and the execution module 213 so that these modules can use the remembered data to perform specific operations. For example, the planning module 212 can use the remembered data to perform planning and decision-making operations. In one example, the memory module 214 may implement long-term and / or short-term memory of the data processed by the agent 210. Long-term memory refers to the persistent memory of data, enabling the remembered data to be retained for a long time without changing or being lost over time. Short-term memory refers to the temporary memory of data, enabling the remembered data to be cleared after a short period of retention. In one example, the memory module 214 may include a long-term memory submodule 231 and a short-term memory module 232. Long-term memory submodule 231 can be configured to perform long-term memory of data processed by the various modules of agent 210. Short-term memory module 232 can be configured to perform short-term memory of data processed by the various modules of agent 210. In one example, long-term memory submodule 231 can be configured to perform long-term memory of the result data generated by the knowledge graph construction process processed by agent 210. This result data may include data that typically requires final output and is generated by executing the knowledge graph construction process, such as the target knowledge graph, ontology, etc. mentioned above. In one example, short-term memory submodule 232 can be configured to perform short-term memory of intermediate data generated by the knowledge graph construction process processed by agent 210. This intermediate data may include data that typically does not require final output and is generated during the execution of the knowledge graph construction process, such as the knowledge graph construction plan mentioned above, candidate sub-plans, command or instruction data for assigning tasks / subtasks to agents at the scheduling / working layer, task feedback data received from agents at the scheduling / working layer, etc. Long-term memory submodule 231 and short-term memory submodule 232 can be used in conjunction with various memory technologies to enable long-term or short-term memory of data.

[0046] It should be understood that the above combination Figure 2 The structure of agent 210 described is for illustrative purposes only. In other examples, agents in the management layer may have the same characteristics as... Figure 2 Other structures different from those shown for the intelligent agent 210, for example, including Figure 2 Other modules not shown, or omitted. Figure 2 One or more modules, etc., are shown in the figure.

[0047] Figure 3 A block diagram of an exemplary structure of an agent 310 at the scheduling layer according to an example embodiment of the present disclosure is shown.

[0048] Figure 3 The agent 310 shown can correspond to, for example, the combination described above. Figure 1 The agents under discussion are any one of the agents 161-1, ..., 161-M.

[0049] The intelligent agent 310 may include a perception module 311. The perception module 311 may be combined in a manner similar to that described above. Figure 2 The perception module 211 discussed can be used to obtain perception data from outside the agent 310. The perception module 311 can serve as an entry point for data interaction between the agent 310 and the outside world, allowing the agent 310 to receive input from the outside via the perception module 311. In one example, the input received via the perception module 311 may include input from other agents within the hierarchical multi-agent framework, such as requirements analysis results from the requirements analysis agent at the working layer (which can be used by the agent 310 to generate candidate sub-plans, as discussed in detail below), various commands and instructions from agents at the management layer (e.g., associated with tasks assigned to the agent 310), task feedback data from a group of agents managed by the agent 310 at the working layer, etc. In one example, the perception module 311 can process the received input in conjunction with the above. Figure 2 The data processing operations discussed are similar to those used to generate perceptual data. The generated perceptual data can be identified and further processed by other modules of the agent 310.

[0050] The intelligent agent 310 may include a planning module 312. The planning module 312 may be similar to the combination described above. Figure 2 The planning module 212 is discussed and can act as the decision center of agent 310 to perform various planning and decision-making operations. The planning module 312 can autonomously decompose the goals to be achieved by agent 310 into a series of executable steps and formulate strategies for achieving each step. In one example, the planning module 312 can be communicatively coupled with the perception module 311 and can perform planning and decision-making operations based on perception data generated by the perception module 311. The planning and decision-making operations performed by the planning module 312 may include, for example, generating candidate sub-plans based on demand analysis results, generating sub-tasks to be performed by a group of agents managed by agent 310 at the working layer according to assigned tasks, and managing the execution of the corresponding sub-tasks by the group of agents, etc. In one example, the planning module 312 may not be exactly the same as planning module 212. For example, the planning module 312 may have weaker planning and decision-making capabilities than planning module 212.

[0051] The intelligent agent 310 may include an execution module 313. The execution module 313 may be combined in a manner similar to that described above. Figure 2 The execution module 213 discussed here can act as the action execution mechanism of agent 310 to perform various specific actions. In one example, the execution module 313 can be communicatively coupled to the planning module 312 and can execute a series of steps to achieve a goal according to the strategy formulated by the planning module 312 as described above. The execution module 313 can also serve as an outlet for data interaction between agent 310 and the outside world, providing output to the outside. In one example, the output provided via the execution module 313 may include output provided to other agents within the hierarchical multi-agent framework. The output provided to other agents may include candidate sub-plans for provision to agents at the management level, task feedback data provided to agents at the management level for tasks assigned to agent 310, commands or instructions issued to a group of agents managed by agent 310 at the working level (e.g., associated with sub-tasks assigned to that group of agents), etc. In one example, in conjunction with the above... Figure 2 Similarly, in the process of performing various specific actions, the execution module 313 can call external tools 320.

[0052] The intelligent agent 310 may include a memory module 314. The memory module 314 may be combined in a manner similar to that described above. Figure 2 The memory module 214 discussed can be used to remember data processed by agent 310. For example, memory module 314 can be communicatively coupled to perception module 311, planning module 312, and execution module 313 respectively to remember data processed by each module. The data remembered by memory module 314 can also be provided to perception module 311, planning module 312, and execution module 313 so that these modules can use the remembered data to perform specific operations. For example, planning module 312 can use the remembered data to perform planning and decision-making operations. In one example, memory module 314 can implement short-term memory of data processed by various modules of agent 310. For example, memory module 314 can be configured to perform short-term memory of intermediate data generated during the knowledge graph construction process processed by agent 310. This intermediate data may include, for example, the aforementioned requirements analysis results, candidate sub-plans, various commands or instructions from agents at the management level, task feedback data from a group of agents managed by agent 310 at the working level, task feedback data provided to agents at the management level, and commands or instructions issued to a group of agents managed by agent 310 at the working level. Memory module 314 can be used in conjunction with various memory technologies to achieve short-term memory of data.

[0053] It should be understood that the above combination Figure 3 The structure of agent 310 described is for illustrative purposes only. In other examples, agents in the management layer may have the same characteristics as... Figure 3 The structure of the agent 310 shown is different from other structures, for example, including Figure 3 Other modules not shown, or omitted. Figure 3 One or more modules, etc., are shown. Although in Figure 3 The agent 310 is shown to provide only short-term memory of data, but in one example, the agent 310 may also include an additional long-term memory module to enable long-term memory of the data processed by the agent 310.

[0054] Figure 4 A block diagram of an exemplary structure of an agent 410 at the working layer according to an example embodiment of the present disclosure is shown.

[0055] Figure 4 The agent 410 shown can correspond to, for example, the combination described above. Figure 1 The agents under discussion are any one of the agents 171-1, 171-2, ..., 171-N.

[0056] The intelligent agent 410 may include a perception module 411. The perception module 411 may be combined in a manner similar to that described above. Figure 2 The perception module 211 discussed can be used to obtain perception data from outside the agent 410. The perception module 411 can serve as an entry point for data interaction between the agent 410 and the outside world, allowing the agent 410 to receive input from the outside via the perception module 411. In one example, the input received via the perception module 411 may include input from other agents within the hierarchical multi-agent framework, such as various commands and instructions (e.g., associated with tasks / subtasks assigned to agent 410) from agents at the management layer and / or from agents at the scheduling layer. In one example, the perception module 411 can process the received input in conjunction with the above. Figure 2 The data processing operations discussed are similar to those used to generate perceptual data. The generated perceptual data can then be recognized and further processed by other modules of the agent 410.

[0057] The intelligent agent 410 may include an execution module 413. The execution module 413 may be combined in a manner similar to that described above. Figure 2The execution module 213 discussed here can act as the action execution mechanism of agent 410 to perform various specific actions. In one example, the execution module 413 can be communicatively coupled to the perception module 413 and can execute the tasks / subtasks assigned to agent 410. The execution module 413 can also serve as an outlet for data interaction between agent 410 and the outside world, providing output to the outside. In one example, the output provided via the execution module 413 may include output provided to other agents within the hierarchical multi-agent framework, such as task feedback data provided to agents at the management layer and / or from agents at the scheduling layer for the tasks / subtasks assigned to agent 410. In one example, in conjunction with the above... Figure 2 Similarly, in the process of performing various specific actions, the execution module 413 can call external tools 420.

[0058] It should be understood that the above combination Figure 4 The structure of agent 410 described is for illustrative purposes only. In other examples, agents at the working layer may have the same characteristics as... Figure 4 Other structures different from the one shown for the intelligent agent 410, for example, including Figure 4 Other modules not shown, or omitted. Figure 4 One or more modules, etc., are shown. Although in Figure 4 Agent 410 is shown without a planning module, but in one example, agent 410 may also include an additional planning module. The planning module of agent 410 may have features combined with those described above. Figure 2 The discussed agent 210 and the above are combined Figure 3 The discussed agent 310 has weaker planning capabilities compared to other agents. Although in Figure 4 Agent 410 is shown without a memory module, but in one example, agent 410 may also include an additional memory module for implementing long-term and / or short-term memory of the data processed by agent 410.

[0059] Figure 5 A schematic diagram of an exemplary structure of a hierarchical multi-agent framework for constructing a knowledge graph, according to an example embodiment of the present disclosure, is shown.

[0060] like Figure 5 As shown, the hierarchical multi-agent framework (e.g., combined with the above) Figure 1 The hierarchical multi-agent framework (130) discussed may exemplarily include the following agents:

[0061] - Knowledge graphs are deployed at the management level (ML) to build intelligent agents 511;

[0062] - An ontology retrieval agent 521 and a knowledge data filling agent 522 are deployed at the scheduling layer (DL); and

[0063] - Deployed at the working layer (WL) are the following intelligent agents: requirement analysis agent 531, ontology development agent 532, ontology reuse agent 533, ontology alignment agent 534, knowledge mapping agent 535, named entity recognition agent 536, relation extraction agent 537, and data fusion agent 538.

[0064] The knowledge graph construction agent 511 is used to manage the entire knowledge graph construction process. The knowledge graph construction agent 511 can generate a knowledge graph construction plan. Then, based on the knowledge graph construction plan, the knowledge graph construction agent 511 can generate ontology retrieval tasks for the ontology retrieval agent 521 and knowledge data filling tasks for the knowledge data filling agent 522. The knowledge graph construction agent 511 can also separately manage the execution of the ontology retrieval tasks by the ontology retrieval agent 521 and the execution of the knowledge data filling tasks by the knowledge data filling agent 522.

[0065] Ontology retrieval agent 521 operates under the management of knowledge graph construction agent 511, for example, by executing its assigned ontology retrieval tasks. The goal of the ontology retrieval task is to generate a target ontology for constructing the target knowledge graph. An ontology can generally be understood as a collection of concepts and can define knowledge classes / concepts, relations, attributes, etc. Ontology retrieval agent 521 can also manage a group of agents at the working layer associated with executing the ontology retrieval task, such as ontology development agent 532, ontology reuse agent 533, and ontology alignment agent 534. Ontology retrieval agent 521 can assign appropriate subtasks to one or more agents in this group based on the ontology retrieval task and manage the execution of the corresponding subtasks. In one example, which agents(s) in the group the ontology retrieval agent 521 assigns a subtask to may depend on whether the ontology retrieval task involves generating a target ontology based on candidate ontology identified in an ontology library.

[0066] Knowledge data population agent 522 operates under the management of knowledge graph construction agent 511, for example, by performing its assigned knowledge data population tasks. The goal of the knowledge data population task is to generate a target knowledge graph based on a target ontology and knowledge data. The target knowledge graph can be generated by populating the target ontology with knowledge data. This process can also be referred to as knowledge graph materialization. Knowledge data population agent 522 can also manage a group of agents at the working layer associated with performing knowledge data population tasks, such as knowledge mapping agent 535, named entity recognition agent 536, relation extraction agent 537, and data fusion agent 538. Knowledge data population agent 522 can assign corresponding subtasks to one or more agents in the group based on the knowledge data population task and manage the execution of the corresponding subtasks. In one example, which agents(s) in the group the knowledge data population agent 522 assigns a subtask to can depend on the data type of the knowledge data. This data type can include structured and unstructured data. Structured data refers to data whose elements are organized according to standard formats or rules and can be directly used for knowledge data population operations, such as data stored in databases in various known formats. Unstructured data refers to data whose elements are not organized according to standard formats or rules and require further processing before knowledge data population operations can be performed, such as natural language text data.

[0067] The requirements analysis agent 531 operates under the management of the knowledge graph construction agent 511. The requirements analysis agent 531 receives requirements descriptions from the knowledge graph construction agent 511 and performs requirements analysis operations to generate requirements analysis results. The requirements analysis results can be a description of the target knowledge graph to be constructed. For example, the requirements analysis results may include the ontology scope, capability questions, and key concepts of the target knowledge graph. The ontology scope refers to the domain targeted by the target knowledge graph. Taking the scenario of constructing a knowledge graph involving academic articles as an example, the ontology scope can indicate that the domain targeted by the target knowledge graph is "academic articles." Capability questions are a series of questions that the target knowledge graph is expected to answer; these questions are important indicators for evaluating the performance of the target knowledge graph. Taking the construction of a target knowledge graph in the "academic articles" domain discussed above as an example, capability questions may include, for example, "What is the main content of a certain article?" or "Who is the author of this article?" Key concepts are descriptions of the important concepts involved in the target knowledge graph. Taking the construction of a target knowledge graph in the field of "academic articles" as an example, as discussed above, key concepts may include "article", "author", "title", "references", etc.

[0068] Ontology development agent 532 operates under the management of ontology acquisition agent 521, for example, by executing ontology development subtasks. The goal of these subtasks is to develop a new target ontology from scratch based on knowledge data. Ontology development agent 532 can adopt a bottom-up approach to develop the new target ontology for the knowledge data. Bottom-up ontology development aims to build a new ontology by identifying all data elements in the knowledge data and then abstracting these elements into higher-level classes / concepts. This approach to ontology building facilitates the gradual construction of the ontology based on real-world data and easily captures subtle differences and variations between the various data elements of the knowledge data.

[0069] The ontology reuse agent 533 operates under the management of the ontology acquisition agent 521, for example, by executing ontology reuse subtasks. The goal of these subtasks is to reuse the candidate ontology identified in the ontology repository as the target ontology. The ontology reuse agent 533 can employ a top-down approach to reuse candidate ontology as the target ontology for both knowledge data and candidate ontology. Top-down ontology reuse aims to refine candidate ontology from high-level abstract data (e.g., by identifying broad scopes and key concepts) to more specific data elements (e.g., by further defining subclasses, relations, attributes, etc.).

[0070] The ontology alignment agent 534 operates under the management of the ontology acquisition agent 521, for example, by executing ontology alignment subtasks. The goal of the ontology alignment subtasks is to align multiple ontologies built using different methods (e.g., ontologies generated using a bottom-up ontology development approach, ontologies generated using a top-down ontology reuse approach, etc., as discussed above) to produce a target ontology. For example, the ontology alignment agent 534 can align multiple ontologies into a single target ontology by aligning classes / concepts, relationships, etc., within the multiple ontologies.

[0071] The knowledge mapping agent 535 operates under the management of the knowledge data population agent 522, for example, by executing knowledge mapping subtasks. The goal of these subtasks is to generate a mapping between the target ontology and structured data, and to automatically generate a target knowledge graph based on this mapping. For example, the mapping can indicate the correspondence between data elements in the structured data and classes / concepts, relationships, attributes, etc., of the target ontology, thereby enabling data population of the target ontology based on this correspondence. In some examples, the knowledge mapping agent 535 can perform the knowledge mapping subtask by invoking a knowledge mapping tool (e.g., morph-kgc).

[0072] Named entity recognition agent 536 operates under the management of knowledge data population agent 522, for example, by performing named entity recognition subtasks. The goal of the named entity recognition subtask is to identify entities in the knowledge data based on the target ontology and classify the identified entities into corresponding classes.

[0073] The relation extraction agent 537 operates under the management of the knowledge data population agent 522, for example, by performing a relation extraction subtask. The goal of the relation extraction subtask is to extract relationships between entities identified by the named entity recognition agent 536 from the knowledge data. These relationships are used to form relationships between entities in the target knowledge graph (e.g., directed edges mentioned above).

[0074] Data fusion agent 538 operates under the management of knowledge data population agent 522, for example, by performing data fusion subtasks. The goal of the data fusion subtasks is to align entities identified by named entity recognition agent 536 and relations extracted by relation extraction agent 537 with existing entries (e.g., existing entities and relations) in the knowledge graph. Performing data fusion subtasks can help reduce data redundancy in the target knowledge graph and help ensure the consistency of data in the target knowledge graph.

[0075] It should be understood that the above combination Figure 5 The various agents discussed are merely examples of agents included in a hierarchical multi-agent framework used to perform the knowledge graph construction process. In other examples, the hierarchical multi-agent framework may have other structures different from those shown, for example, including... Figure 5 Other agents not shown, or omitted Figure 5 One or more intelligent agents, as shown.

[0076] The following will combine Figure 6 Further detailed discussion and Figure 5 Details of the operations performed by each agent during the knowledge graph construction process are shown. Figure 6 An example embodiment of the present disclosure is illustrated using the combination of... Figure 5 A sequence diagram describing a hierarchical multi-agent framework for performing knowledge graph construction operations.

[0077] Figure 6 This describes the interactions between agents in the management layer (ML) 610, the scheduling layer (DL) 620, and the working layer (WL) 630 during the knowledge graph construction process. Agents in the management layer 610 may include, for example, those combined with the above. Figure 5 The knowledge graph construction agent 511 is discussed. The agent at the scheduling layer 620 can include, for example, the combination of the above. Figure 5The discussion focuses on ontology acquisition agent 521 and knowledge data population agent 522. Agents at working layer 630 may include, for example, combinations of the above. Figure 5 The discussion includes the following intelligent agents: 531 for requirements analysis, 532 for ontology development, 533 for ontology reuse, 534 for ontology alignment, 535 for knowledge mapping, 536 for named entity recognition, 537 for relation extraction, and 538 for data fusion.

[0078] At point 641, the knowledge graph building agent can receive input. The received input can include knowledge data and a requirement description, for example, combined with the above... Figure 1 The discussion covers knowledge data 110 and requirements description 120.

[0079] At position 642, in response to receiving the above input, the knowledge graph building agent can call the requirements analysis agent to perform requirements analysis operations.

[0080] At point 643, the requirements analysis agent can perform requirements analysis operations on the requirements description under the invocation of the knowledge graph construction agent to generate requirements analysis results.

[0081] At position 644, the requirements analysis agent can provide the generated requirements analysis results to the ontology acquisition agent.

[0082] At point 645, the ontology acquisition agent can generate candidate ontology acquisition sub-plans based on the results of the requirements analysis.

[0083] An ontology acquisition agent can be configured to access an ontology repository. This repository may include multiple developed ontologies. The ontology acquisition agent can identify whether candidate ontologies in the repository match the requirements analysis results. In one example, if the scope of one or more ontologies in the repository is consistent with the scope of the target knowledge graph indicated by the requirements analysis results, and each of the one or more ontologies has covered all the key concepts of the target knowledge graph indicated by the requirements analysis results, then each of the one or more ontologies can be determined to be a complete match of the requirements analysis results and thus a candidate ontology. In another example, if the scope of one or more ontologies in the repository is similar to the scope of the target knowledge graph indicated by the requirements analysis results and / or each of the one or more ontologies has covered some of the key concepts of the target knowledge graph indicated by the requirements analysis results, then each of the one or more ontologies can be determined to be a partial match of the requirements analysis results and thus a candidate ontology. In yet another example, if there are no ontologies in the repository whose scope is similar to the scope of the target knowledge graph indicated by the requirements analysis results or that cover any of the key concepts of the target knowledge graph indicated by the requirements analysis results, then there are no candidate ontologies in the repository.

[0084] An ontology acquisition agent can generate candidate ontology acquisition sub-plans based on the identified candidate ontologies. For example, if a fully matching candidate ontology exists, the agent can generate an ontology acquisition sub-plan associated with reusing the candidate ontology as the target ontology. If a partially matching candidate ontology exists, the agent can generate an ontology acquisition sub-plan associated with developing the target ontology based on the candidate ontology. If no candidate ontologies exist, the agent can generate an ontology acquisition sub-plan associated with developing the target ontology from scratch.

[0085] Based on the above discussion, the ontology retrieval agent generates candidate ontology retrieval sub-plans by accessing an ontology repository and identifying candidate ontologies within it. This approach allows the ontology retrieval sub-plans to be dynamically generated based on existing ontology resources available in the ontology repository, thereby contributing to improved efficiency and accuracy in the knowledge graph construction process.

[0086] It should be understood that the ontology acquisition sub-plans generated by the ontology acquisition agent can be rough plans for generating the target ontology, because the ontology acquisition agent may have weaker decision-making capabilities compared to the knowledge graph construction agent. In other words, the ontology acquisition agent is responsible for providing the knowledge graph construction agent with potentially feasible (or candidate) ontology acquisition sub-plans. The knowledge graph construction agent can then decide, based on these ontology acquisition sub-plans, how to ultimately generate the target ontology in various ways.

[0087] Then, the ontology retrieval agent can provide the generated candidate ontology retrieval sub-plans to the knowledge data filling agent (this operation inside the scheduling layer is not shown in the figure), so that the knowledge data filling agent can generate knowledge data filling sub-plans.

[0088] At point 646, the knowledge graph building agent can provide the received knowledge data to the knowledge data populating agent.

[0089] At point 647, the knowledge data imputation agent can generate candidate data imputation plans based on candidate ontology retrieval plans provided by the ontology retrieval agent and the data type of the knowledge data. The knowledge data imputation agent has the ability to analyze the knowledge data to determine its data type. For example, it can determine whether the knowledge data is structured or unstructured. In one example, if the knowledge data is structured, the agent can generate a knowledge data imputation plan associated with performing knowledge data imputation on the ontology using data mapping. If the knowledge data is unstructured, the agent can generate a knowledge data imputation plan associated with performing knowledge data imputation on the ontology using data recognition and extraction.

[0090] Based on the above discussion, the knowledge data imputation agent generates candidate knowledge data imputation sub-plans by accessing knowledge data and determining its data type. This allows the knowledge data imputation sub-plans to be generated dynamically based on the data type, thereby helping to improve the efficiency and accuracy of the knowledge graph construction process.

[0091] It should be understood that the knowledge data filling sub-plans generated by the knowledge data filling agent can be rough plans for filling knowledge data into the target ontology to generate the target knowledge graph. This is because the knowledge data filling agent may have weaker decision-making capabilities compared to the knowledge graph building agent. In other words, the knowledge data filling agent is responsible for providing the knowledge graph building agent with potentially feasible (or candidate) knowledge data filling sub-plans. The knowledge graph building agent can then decide, based on these knowledge data filling sub-plans, how to ultimately fill the knowledge data into the target ontology in various ways to generate the target knowledge graph.

[0092] At point 648, the ontology retrieval agent and the knowledge data filling agent can provide the generated candidate ontology retrieval sub-plans and knowledge data filling sub-plans to the knowledge graph construction agent, respectively.

[0093] At point 649, the knowledge graph construction agent can perform decision operations on the received candidate ontology acquisition sub-plans and knowledge data filling sub-plans to generate a knowledge graph construction plan. The knowledge graph construction plan is an overall plan for the operations of the hierarchical multi-agent framework throughout the knowledge graph construction process. The knowledge graph construction agent can perform decision operations on the candidate ontology acquisition sub-plans and knowledge data filling sub-plans to determine (e.g., select) a target ontology acquisition sub-plan and a target knowledge data filling sub-plan from the candidate ontology acquisition sub-plans. Then, the knowledge graph construction agent can combine the target ontology acquisition sub-plan and the target knowledge data filling sub-plan to generate the knowledge graph construction plan.

[0094] At point 650, the knowledge graph building agent can generate an ontology retrieval task for the ontology retrieval agent and a knowledge data filling task for the knowledge data filling agent based on the generated knowledge graph building plan. The ontology retrieval task guides the ontology retrieval agent on how to generate the target ontology, and the knowledge data filling task guides the knowledge data filling agent on how to fill the target ontology with knowledge data to generate the target knowledge graph.

[0095] At point 651, the knowledge graph building agent can assign the ontology retrieval task to the ontology retrieval agent and the knowledge data filling task to the knowledge data filling agent.

[0096] At position 652, the ontology acquisition agent and the knowledge data filling agent can generate subtasks for one or more agents in the working layer based on their respective assigned tasks.

[0097] An ontology acquisition agent can generate subtasks for one or more agents managed by the ontology acquisition agent at the working layer for an ontology acquisition task. In one example, when an ontology acquisition task is associated with reusing candidate ontologies in an ontology library (e.g., the candidate ontologies that perfectly match the requirements analysis results, as discussed above) as the target ontology, the ontology acquisition agent can generate a native reuse subtask for itself as the reuse agent. When an ontology acquisition task is associated with developing a target ontology based on candidate ontologies in an ontology library (e.g., the candidate ontologies that do not perfectly match the requirements analysis results, as discussed above), the ontology acquisition agent can generate ontology development subtasks for the ontology development agent, native reuse subtasks for itself as the reuse agent, and ontology alignment subtasks for the ontology alignment agent. When an ontology acquisition task is associated with developing a target ontology from scratch, the ontology acquisition agent can generate an ontology development subtask for the ontology development agent.

[0098] A knowledge data filling agent can generate subtasks for one or more agents managed by the knowledge data filling agent at the working layer for a knowledge data filling task. In one example, when a knowledge data filling task is associated with performing knowledge data filling on an ontology using data mapping (e.g., corresponding to the case where the data type of the knowledge data discussed above is a structured data type), the knowledge data filling agent can generate a knowledge mapping subtask for the knowledge mapping agent. When a knowledge data filling task is associated with performing knowledge data filling on an ontology using data recognition and extraction (e.g., corresponding to the case where the data type of the knowledge data discussed above is an unstructured data type), the knowledge data filling agent can generate a named entity recognition subtask for the named entity recognition agent, a relation extraction subtask for the relation extraction agent, and a data fusion subtask for the data fusion agent.

[0099] At position 653, the ontology acquisition agent and the knowledge data filling agent can respectively assign the corresponding sub-tasks generated at position 652 to one or more agents in the working layer.

[0100] In one example, the ontology retrieval agent can assign an ontology reusing agent a reusing subtask, for example, in the case of the ontology retrieval task discussed above being associated with reusing candidate ontologies from an ontology library as the target ontology. In another example, the ontology retrieval agent can assign an ontology development subtask to the ontology development agent, an ontology reusing agent a reusing subtask, and an ontology alignment subtask to the ontology alignment agent, for example, in the case of the ontology retrieval task discussed above being associated with developing the target ontology based on candidate ontologies from an ontology library. In yet another example, the ontology retrieval agent can assign an ontology development subtask to the ontology development agent, for example, in the case of the ontology retrieval task discussed above being associated with developing the target ontology from scratch.

[0101] In one example, the knowledge data imputation agent can assign a knowledge mapping subtask to the knowledge mapping agent, for instance, in the case of the knowledge data imputation task discussed above being associated with performing knowledge data imputation on an ontology using data mapping. In another example, the knowledge data imputation agent can assign a named entity recognition subtask to the named entity recognition agent, a relation extraction subtask to the relation extraction agent, and a data fusion subtask to the data fusion agent, for instance, in the case of the knowledge data imputation task discussed above being associated with performing knowledge data imputation on an ontology using data recognition and extraction methods.

[0102] At position 654, each agent in the working layer can execute its assigned subtask. This has already been combined with... Figure 5 The content of each agent in the working layer performing its corresponding subtasks was discussed, and these contents will not be repeated here.

[0103] In one example, the ontology reusing agent can independently execute the ontology reusing subtask to reuse candidate ontologs identified in the ontology library as the target ontology. In another example, the ontology development agent, the ontology reusing agent, and the ontology alignment agent can be combined to execute the ontology development subtask, the ontology reusing subtask, and the ontology alignment subtask, respectively, to develop the target ontology based on candidate ontologs in the ontology library. In yet another example, the ontology development agent can independently execute the ontology development subtask to develop the target ontology from scratch based on knowledge data.

[0104] In one example, the knowledge mapping agent can independently execute the knowledge mapping subtask to generate a target knowledge graph by performing knowledge data imputation on the target ontology using data mapping methods. In another example, the named entity recognition agent, the relation extraction agent, and the data fusion agent can be combined to execute the named entity recognition subtask, the relation extraction subtask, and the data fusion subtask, respectively, to generate a target knowledge graph by performing knowledge data imputation on the target ontology using data recognition and extraction methods.

[0105] At point 655, the generated target knowledge graph can be provided to the knowledge graph construction agent. In one example, the target knowledge graph can be generated by a knowledge mapping agent, which corresponds to the case discussed above where the knowledge data imputation task is associated with performing knowledge data imputation on an ontology using data mapping. In another example, the target knowledge graph can be generated by a data fusion agent, which corresponds to the case discussed above where the knowledge data imputation task is associated with performing knowledge data imputation on an ontology using data recognition and extraction methods.

[0106] At position 656, the knowledge graph building agent can output the generated target knowledge graph to the external environment.

[0107] It should be understood that Figure 6 The operations shown are merely examples of what agents perform during the knowledge graph construction process. In other examples, agents may perform the following operations during the knowledge graph construction process: Figure 6 Part of the operation shown or execution Figure 6 Other operations not shown in the diagram. Furthermore, it should be understood that... Figure 6 The order of the operations shown is for illustrative purposes only. In other examples, the order can be... Figure 6 The operations can be performed in a different order than the one shown.

[0108] exist Figure 6 For simplicity, the interaction operations during the management of lower-level agents performing corresponding tasks / subtasks by higher-level agents are omitted. In one example, when performing management operations, the higher-level agent can receive task / subtask feedback data from the lower-level agent and responsively provide further commands or instructions to the lower-level agent based on the task / subtask feedback data, thereby facilitating the lower-level agent to complete its assigned corresponding task / subtask. This management can involve the management of the ontology acquisition agent by the knowledge graph construction agent during the execution of the ontology acquisition task, and the management of the knowledge data filling agent during the execution of the knowledge data filling task. This management can also involve the management of a group of agents under its management (e.g., ontology development agent, ontology reuse agent, ontology alignment agent) during the execution of corresponding subtasks by the ontology acquisition agent, and the management of a group of agents under its management (e.g., knowledge mapping agent, named entity recognition agent, relation extraction agent, data fusion agent) during the execution of corresponding subtasks by the knowledge data filling agent.

[0109] In one example, the aforementioned management could involve a higher-level agent confirming that a lower-level agent has completed its assigned task / subtask. For instance, only after a higher-level agent confirms that a lower-level agent has completed its task / subtask is another lower-level agent allowed to execute its assigned task. This task / subtask confirmation mechanism is advantageous when there are dependencies between the tasks / subtasks assigned to different agents and can be used to avoid conflicts between multiple related tasks / subtasks. For example, as discussed above, the data fusion agent is only allowed to execute the data fusion subtask after the knowledge data filling agent confirms that the named entity recognition agent has completed the named entity recognition subtask and the relation extraction agent has completed the relation extraction subtask.

[0110] It should be understood that although the process of automatically constructing a target knowledge graph using a hierarchical multi-agent framework has been discussed above, the scheme disclosed herein does not exclude the possibility of manual intervention in the process of constructing the target knowledge graph. In one example, after generating the target ontology, its accuracy can be verified through manual intervention, for example, performed by an expert. If the target ontology fails verification, the hierarchical multi-agent framework can further modify the generated target ontology based on the modification suggestions provided by the expert. After the target ontology passes verification, subsequent operations such as knowledge data population can be performed on the verified target ontology. In another example, a similar manual verification operation can also be performed after generating the target knowledge graph. Introducing such manual verification operations helps to construct a more accurate target knowledge graph.

[0111] Figure 7 An example flowchart of a method 700 for constructing a multi-agent-based knowledge graph according to an example embodiment of the present disclosure is shown.

[0112] In step S710, knowledge data can be obtained.

[0113] In step S720, a requirement description for the target knowledge graph can be obtained.

[0114] At step S730, a target knowledge graph can be generated using a hierarchical multi-agent framework based on the knowledge data obtained at step S710 and the demand description obtained at step S720. The hierarchical multi-agent framework may include multiple agents arranged in a hierarchical manner.

[0115] In one implementation, the hierarchical multi-agent framework may include a management layer, a scheduling layer, and a working layer. The management layer may correspond to the top layer of the hierarchical multi-agent framework, the working layer may correspond to the bottom layer of the hierarchical multi-agent framework, and the scheduling layer may correspond to the intermediate layer between the top and bottom layers of the hierarchical multi-agent framework.

[0116] In one implementation, generating the target knowledge graph may include: generating a knowledge graph construction plan by constructing an intelligent agent through a knowledge graph at the management level.

[0117] In one implementation, generating a knowledge graph construction plan may include: obtaining agents and populating agents with knowledge data through an ontology at the scheduling layer, generating multiple candidate sub-plans; and generating a knowledge graph construction plan based on multiple candidate sub-plans through a knowledge graph construction agent.

[0118] In one implementation, generating multiple candidate sub-plans may include: acquiring an agent through an ontology and generating at least one ontology acquisition sub-plan based on the results of the demand analysis; and populating an agent with knowledge data and generating at least one knowledge data population sub-plan based on at least one ontology acquisition sub-plan and the data type of the knowledge data.

[0119] In one implementation, the requirements analysis results can be generated by a requirements analysis agent at the working layer based on the requirements description; and the requirements analysis results can include at least one of the following: the scope of the target knowledge graph, capability issues, and key concepts.

[0120] In one implementation, generating at least one ontology acquisition sub-plan based on the requirements analysis results may include: accessing an ontology repository; identifying in the ontology repository whether there are candidate ontologies that match the requirements analysis results; and generating at least one ontology acquisition sub-plan based on the identification results.

[0121] In one implementation, the data type of knowledge data can include structured data types or unstructured data types.

[0122] In one implementation, generating the target knowledge graph may further include constructing agents through the knowledge graph: assigning corresponding tasks to multiple agents in the scheduling layer according to the knowledge graph construction plan, wherein the corresponding tasks include ontology acquisition tasks for ontology acquisition agents in the scheduling layer and knowledge data filling tasks for knowledge data filling agents in the scheduling layer.

[0123] In one implementation, the ontology acquisition agent can perform one of the following operations for the ontology acquisition task: when the ontology acquisition task is associated with reusing candidate ontology entities in the ontology library as the target ontology, assign an ontology reusing subtask to the ontology reusing agent in the working layer; when the ontology acquisition task is associated with developing the target ontology based on candidate ontology entities in the ontology library, assign an ontology development subtask to the ontology development agent in the working layer, assign an ontology reusing subtask to the ontology reusing agent in the working layer, and assign an ontology alignment subtask to the ontology alignment agent in the working layer; or when the ontology acquisition task is associated with developing the target ontology from scratch, assign an ontology development subtask to the ontology development agent in the working layer.

[0124] In one implementation, the knowledge data filling agent can be used to perform one of the following operations for the knowledge data filling task: when the knowledge data filling task is associated with performing knowledge data filling on an ontology using a data mapping method, assign a knowledge mapping subtask to the knowledge mapping agent at the working layer; or when the knowledge data filling task is associated with performing knowledge data filling on an ontology using a data recognition and extraction method, assign a named entity recognition subtask to the named entity recognition agent at the working layer, assign a relation extraction subtask to the relation extraction agent at the working layer, and assign a data fusion subtask to the data fusion agent at the working layer.

[0125] In one implementation, the hierarchical multi-agent framework can be used to provide at least one of the following: short-term memory of intermediate data in the construction process of the target knowledge graph; or long-term memory of the result data in the construction process of the target knowledge graph.

[0126] It should be understood that method 700 may also include any steps / processes for constructing a multi-agent-based knowledge graph according to the embodiments of this disclosure described above.

[0127] Figure 8 An exemplary apparatus 800 for constructing a knowledge graph based on a multi-agent system is shown according to an embodiment.

[0128] The apparatus 800 may include at least one processor 810. The apparatus 800 may also include a memory 820 connected to the at least one processor 810. The memory 820 may store computer-executable instructions that, when executed, cause the at least one processor 810 to: obtain knowledge data; obtain a demand description for a target knowledge graph; and generate the target knowledge graph based on the knowledge data and the demand description using a hierarchical multi-agent framework, wherein the hierarchical multi-agent framework includes a plurality of agents arranged hierarchically. Furthermore, the at least one processor 810 may also be configured to perform any other operations of the method for constructing a multi-agent-based knowledge graph according to the embodiments of the present disclosure described above.

[0129] Embodiments of this disclosure can be implemented in a computer-readable medium. This computer-readable medium may store a computer program including instructions. In one example aspect, when executed by a processor, the instructions may cause the processor to: obtain knowledge data; obtain a demand description for a target knowledge graph; and generate the target knowledge graph based on the knowledge data and the demand description using a hierarchical multi-agent framework, wherein the hierarchical multi-agent framework includes a plurality of agents arranged hierarchically. In another example aspect, when executed by a processor, the instructions may cause the processor to implement the above combination... Figure 7Other operations discussed for methods of constructing multi-agent knowledge graphs.

[0130] Embodiments of this disclosure can be implemented in a computer program product. The computer program product may include instructions. In one example aspect, when executed, the instructions may cause one or more processors to: obtain knowledge data; obtain a demand description for a target knowledge graph; and generate the target knowledge graph based on the knowledge data and the demand description using a hierarchical multi-agent framework, wherein the hierarchical multi-agent framework includes a plurality of agents arranged hierarchically. In another example aspect, when executed by a processor, the instructions may cause one or more processors to implement the above combination. Figure 7 Other operations discussed for methods of constructing multi-agent knowledge graphs.

[0131] The various elements in one or more examples described in this article can be implemented in hardware, software, or any combination thereof. Whether these elements are implemented as hardware or software can depend on the specific application and the design constraints imposed on the overall system.

[0132] For example, the described elements or any combination of elements can be implemented as a "processing system" including one or more processors (which may also be referred to as processing units). Examples of processors include microprocessors, microcontrollers, graphics processing units (GPUs), general-purpose GPUs (GPGPUs), central processing units (CPUs), application processors, digital signal processors (DSPs), reduced instruction set computing (RISC) processors, system-on-a-chip (SoCs), baseband processors, application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), programmable logic devices (PLDs), state machines, gated logic, discrete hardware circuits, and other suitable hardware configured to perform the various functions described throughout this disclosure. One or more processors in a processing system can execute software. Software can be broadly interpreted as instructions, instruction sets, code, code segments, program code, programs, subroutines, software components, applications, software applications, software packages, routines, subroutines, objects, executable files, threads of execution, procedures, functions, etc., whether referring to software, firmware, middleware, microcode, hardware description languages, etc.

[0133] If implemented in software, these elements may be stored on or encoded as one or more instructions or code on a computer-readable medium. Computer-readable media include computer storage media. Storage media can be any available medium that can be accessed by a computer. By way of example, and not limitation, such computer-readable media may include random access memory (RAM), read-only memory (ROM), electrically erasable programmable ROM (EEPROM), optical disc storage devices, magnetic disk storage devices, other magnetic storage devices, combinations of computer-readable media of the types described above, or any other medium that can be used to store computer-executable code in the form of instructions or data structures that can be accessed by a computer.

[0134] In addition to the content described herein, various modifications may be made to the disclosed embodiments and implementations of the present invention without departing from the scope of the invention. Therefore, the descriptions and examples herein should be interpreted as illustrative rather than limiting. The scope of the invention should be measured solely by reference to the claims.

Claims

1. A method for constructing a knowledge graph based on multi-agent systems, comprising: Acquire knowledge data; Obtain a requirements description for the target knowledge graph; as well as The target knowledge graph is generated using a hierarchical multi-agent framework based on the knowledge data and the requirement description, wherein the hierarchical multi-agent framework includes multiple agents arranged in a hierarchical manner.

2. The method according to claim 1, wherein, The hierarchical multi-agent framework includes a management layer, a scheduling layer, and a working layer; and The management layer corresponds to the top layer of the hierarchical multi-agent framework, the working layer corresponds to the bottom layer of the hierarchical multi-agent framework, and the scheduling layer corresponds to the intermediate layer between the top and bottom layers of the hierarchical multi-agent framework.

3. The method according to claim 2, wherein, The generation of the target knowledge graph includes: A knowledge graph construction plan is generated by constructing an intelligent agent based on the knowledge graph at the management level.

4. The method according to claim 3, wherein, The knowledge graph construction plan includes: By acquiring agents and populating agents with knowledge data through the ontology at the scheduling layer, multiple candidate sub-plans are generated; and An intelligent agent is constructed using the knowledge graph, and a knowledge graph construction plan is generated based on the multiple candidate sub-plans.

5. The method according to claim 4, wherein, The generation of multiple candidate sub-plans includes: The agent is acquired through the ontology, and at least one ontology acquisition sub-plan is generated based on the requirements analysis results; and By populating the agent with the knowledge data, at least one knowledge data population sub-plan is generated based on the at least one ontology to obtain the sub-plan and the data type of the knowledge data.

6. The method according to claim 5, wherein, The requirements analysis results are generated by the requirements analysis agent at the working layer based on the requirements description; and The requirements analysis results include at least one of the following: the scope of the target knowledge graph, capability issues, and key concepts.

7. The method according to claim 5, wherein, The process of generating at least one ontology acquisition sub-plan based on the requirements analysis results includes: Access the ontology repository; Identify whether there are candidate ontologies in the ontology library that match the requirements analysis results; and The at least one ontology acquisition sub-plan is generated based on the identification results.

8. The method according to claim 5, wherein, The data types of the knowledge data include structured data types and unstructured data types.

9. The method according to claim 3, wherein, The generation of the target knowledge graph further includes constructing an intelligent agent using the knowledge graph: According to the knowledge graph construction plan, corresponding tasks are assigned to multiple agents in the scheduling layer, wherein the corresponding tasks include an ontology acquisition task for an ontology acquisition agent in the scheduling layer and a knowledge data filling task for a knowledge data filling agent in the scheduling layer.

10. The method according to claim 9, wherein, The ontology acquisition agent is configured to perform one of the following operations in response to the ontology acquisition task: When the ontology acquisition task is associated with reusing candidate ontologs in the ontology library as the target ontology, an ontology reusing subtask is assigned to the ontology reusing agent in the working layer. When the ontology acquisition task is associated with developing a target ontology based on candidate ontology in the ontology library, ontology development subtasks are assigned to the ontology development agent in the working layer, ontology reuse subtasks are assigned to the ontology reuse agent in the working layer, and ontology alignment subtasks are assigned to the ontology alignment agent in the working layer. When the ontology acquisition task is associated with developing a target ontology from scratch, an ontology development sub-task is assigned to the ontology development agent in the working layer.

11. The method according to claim 9, wherein, The knowledge data population agent is configured to perform one of the following operations in response to the knowledge data population task: When the knowledge data filling task is associated with performing knowledge data filling on an ontology using a data mapping method, a knowledge mapping sub-task is assigned to the knowledge mapping agent in the working layer. or When the knowledge data filling task is associated with performing knowledge data filling on the ontology using data recognition and extraction methods, a named entity recognition subtask is assigned to the named entity recognition agent in the working layer, a relation extraction subtask is assigned to the relation extraction agent in the working layer, and a data fusion subtask is assigned to the data fusion agent in the working layer.

12. The method according to claim 1, wherein, The hierarchical multi-agent framework is used to provide at least one of the following: Short-term memory of intermediate data during the construction process of the target knowledge graph; Long-term memory of the result data of the construction process of the target knowledge graph.

13. An apparatus for constructing a knowledge graph based on multi-agent systems, comprising: Memory; as well as A processor coupled to the memory, the processor being configured to perform the method according to any one of claims 1-12.

14. A computer-readable medium storing a computer program comprising instructions that, when executed by a processor, cause the processor to be configured to perform the method according to any one of claims 1-12.

15. A computer program product comprising computer-executable instructions, which, when executed, cause one or more processors to perform the method according to any one of claims 1-12.

Images