A multi-agent collaborative decision-making and disambiguation method and system

Abstract

The application provides a multi-agent collaborative decision-making and disambiguation method and system. The method comprises the following steps: registering the dependency relationship between the task context and the event trigger condition concerned by the agent to the coordination center, updating the dynamic dependency view through the coordination center, analyzing the knowledge update time through the coordination center, and generating a task context identifier set of the agent; constructing a fact set based on the task context identifier set, inputting the fact set into a rule reasoning engine, executing the rules in the collaborative rule base to generate a strategy, and obtaining a collaborative strategy; and distributing the collaborative strategy to the corresponding agent and executing a cleaning process at the end of the task generation period. The application solves the efficiency bottleneck of event routing in a distributed intelligent system from the system architecture level, greatly improves the real-time response capability and scalability of the system in a high-concurrency scenario while ensuring decision consistency.

Description

Technical Field

[0001] This invention belongs to the technical fields of distributed computing, high-performance system architecture and multi-agent systems, and specifically relates to a multi-agent collaborative decision-making and disambiguation method and system. Background Technology

[0002] As knowledge graphs become an important knowledge foundation for intelligent systems, multi-agent systems are increasingly being applied in fields such as finance and operations. In these systems, multiple agents need to make collaborative decisions based on the latest facts in a shared knowledge graph and maintain consistency in their decisions.

[0003] However, facts in knowledge graphs (such as user credit ratings and device status) are dynamically changing. When key facts change, they simultaneously affect the decision-making context of multiple agents. To address the potential "decision conflict" problem arising from this, a typical existing technology involves introducing a "centralized coordinator." This coordinator maintains a global state database for all agents in the system (e.g., a list containing all running tasks and their associated entities). When a knowledge update event occurs, the coordinator traverses this global state database to query and locate all agents affected by the event, and then generates and distributes collaborative decision-making instructions.

[0004] While this "global state query" scheme guarantees "decision consistency," it introduces a new and fatal technical flaw: the coordinator needs to perform a global traversal query every time it processes an event. This causes its coordination latency to be linearly proportional to the total number of agents and tasks in the system (i.e., O(N) time complexity). In high-concurrency, high-dynamic real-world application scenarios (such as financial risk control and intelligent operation and maintenance), the number of system tasks N is extremely large and changes frequently. This linearly increasing latency makes the system scalable poorly, quickly becoming a performance bottleneck and unable to meet the requirements of real-time response. This is essentially an inherent contradiction between "state query" and "event response" in distributed systems. This bottleneck can be precisely characterized at the level of algorithm complexity: Suppose there are N active agent tasks in the system. The global state database can be formally represented as a set of N task contexts, each task context implicitly associated with its dependent knowledge conditions. When a knowledge update event occurs, the centralized coordinator must perform a global state traversal query to locate the affected subset of contexts.

[0005] The fundamental flaw in existing technical solutions lies in the inherent algorithmic complexity of their core coordination mechanisms. This linear performance bottleneck can be formally described as follows: the operation of locating the affected context requires worst-case traversal of a global state set of size N, resulting in a lower bound of latency of Ω(N) for single event coordination. Therefore, the core problem with existing technologies is that any coordination mechanism based on global state traversal cannot meet the system's requirements for low-latency real-time performance and horizontal scalability while ensuring decision consistency. Summary of the Invention

[0006] To address the aforementioned technical problems, this invention provides a multi-agent collaborative decision-making and disambiguation method and system, which solves the technical problems in the prior art.

[0007] In a first aspect, the present invention provides the following technical solution: a multi-agent collaborative decision-making and disambiguation method, comprising:

[0008] Build a dynamic knowledge graph, initialize a collaboration center and maintain a dynamic dependency view, and build a collaboration rule base;

[0009] When an agent performs a task, it registers the dependency relationship between its task context and the event triggering conditions it is concerned with with the collaboration center and updates the dynamic dependency view through the collaboration center.

[0010] The knowledge update events of the dynamic knowledge graph are obtained, and the knowledge update time is parsed through the collaboration center to generate a set of task context identifiers for the intelligent agent.

[0011] A fact set is constructed based on the task context identifier set. The fact set is then input into the rule reasoning engine to execute the rules in the collaborative rule base to generate a strategy, thereby obtaining a collaborative strategy.

[0012] The collaborative strategy is distributed to the corresponding agents and a cleanup process is performed at the end of the task generation cycle.

[0013] Compared to existing technologies, the advantages of this invention are as follows: The dynamic dependency registration mechanism provides precise, real-time, and lightweight input to the dependency mapping structure, enabling the latter to discard redundant global states and become a highly efficient read-only cache view. This 'on-demand registration, dynamic construction' model is a prerequisite for achieving a qualitative leap in query efficiency; the efficient query capability of the dependency mapping structure allows the rule inference engine to avoid dealing with massive amounts of global task data, only needing to infer from a small number of precisely located relevant contexts. This greatly reduces the computational load and memory consumption of the rule engine, avoiding the possibility that complex rule inference may become a new performance bottleneck, thus making the 'event-driven + rule inference' architecture feasible in high-concurrency real-time systems; the rule inference engine's output results are more targeted based on the event and context generation strategy derived from precise routing, reducing unnecessary network broadcasts and data transmission, thus alleviating system load from another dimension; this collaborative approach of "registering and building the view first, then precisely routing events" not only achieves precise resolution of decision conflicts, but also decouples coordination latency from the total system workload at the system architecture level, transforming it into a relationship with the efficiency of searching for efficient data structures. In this way, the present invention fundamentally solves the inherent contradiction between decision consistency and system real-time performance and scalability, providing reliable technical support for multi-agent systems in high-concurrency scenarios.

[0014] Preferably, the dynamic knowledge graph is constructed using a graph database. In the graph database, triggers are set for the key entity types and attributes that need to be tracked. When the attributes of the key entity change, the triggers are activated to construct a structured knowledge update event. The knowledge update event is a data object containing entity ID, attribute name, new and old values, and timestamp.

[0015] Preferably, the collaboration center initializes a dependency mapping structure, which is an inverted index implemented based on a distributed cache. The inverted index uses the event trigger condition as the key and the set of task contexts of the agents subscribing to the event trigger condition as the value. The collaboration center is used to provide a RESTful API to receive decision dependency registration requests. When an agent starts executing a task, it actively initiates a call to the collaboration center and submits structured registration information. The registration information includes at least the dynamic association between the event trigger condition and the task context identifier, and the optional lease period.

[0016] Preferably, the collaborative rule base is loaded and executed by the rule inference engine. The collaborative rule base includes one or more collaborative disambiguation rules. The collaborative disambiguation rules are represented in a WHEN-THEN formal format. The WHEN part is used to define the logical premise for the rule to be activated and to make a comprehensive judgment based on the attributes of the received knowledge update event and the task context of the affected agent. The THEN part is used to define the collaborative control instruction output by the rule inference engine when the triggering condition is met.

[0017] Preferably, the step of parsing the knowledge update time and generating the agent task context identifier set through the collaboration center includes:

[0018] Receive knowledge update events through the collaboration center And the knowledge update event Formalize as tuples:

[0019] ;

[0020] In the formula, These are the entity ID, attribute name, and timestamp, respectively. These are the old value and the new value, respectively.

[0021] Generate at least one query key based on the contents of the tuple. And based on the query key In the dynamic dependency view Perform a lookup operation to obtain the set of task context identifiers for the affected agents. :

[0022] .

[0023] Preferably, the step of constructing a fact set based on the task context identifier set, and inputting the fact set into the rule reasoning engine to execute the rules in the collaborative rule base to generate a policy, thereby obtaining a collaborative policy, includes:

[0024] The corresponding task context is obtained through the task context identifier set to obtain the task context set. ;

[0025] Based on the task context set With knowledge update events Constructing a set of facts :

[0026] ;

[0027] The fact set is input into the rule reasoning engine and reasoned using the rules in the collaborative rule base for each candidate action. Define decision tuples :

[0028] ;

[0029] ;

[0030] In the formula, For normalization effect, For priority mapping, For logical timestamps, For action-stable hashing, For a monotonically increasing time domain, An auto-incrementing sequence within the same event, ordered by generation.

[0031] The best candidate actions are selected using lexicographical order to output a collaborative strategy.

[0032] ;

[0033] In the formula, Candidate actions The decision tuple, Candidate actions The normalization effect, Candidate actions Priority mapping, Candidate actions Logical timestamp, Candidate actions The action is stable hashing.

[0034] Preferably, the step of distributing the collaborative strategy to the corresponding intelligent agent and performing a cleanup process at the end of the task generation cycle specifically includes:

[0035] The collaboration center distributes the collaboration strategy to the corresponding agents and notifies the collaboration center when the agent's task lifecycle ends, and cleans up the corresponding dependencies from the dynamic dependency view through the collaboration center.

[0036] Secondly, the present invention provides the following technical solution: a multi-agent collaborative decision-making and disambiguation system, the system comprising:

[0037] The building module is used to construct a dynamic knowledge graph, initialize the collaboration center and maintain a dynamic dependency view, and build a collaboration rule base.

[0038] The update module is used to register the dependency relationship between its task context and the event triggering conditions of interest with the collaboration center when the agent performs a task, and update the dynamic dependency view through the collaboration center.

[0039] The parsing module is used to obtain the knowledge update events of the dynamic knowledge graph, parse the knowledge update time through the collaboration center, and generate a set of task context identifiers for the intelligent agent.

[0040] The strategy module is used to construct a fact set based on the task context identifier set, input the fact set into the rule reasoning engine to execute the rules in the collaborative rule base to generate a strategy, so as to obtain a collaborative strategy;

[0041] The cleanup module is used to distribute the collaborative strategy to the corresponding agents and perform a cleanup process at the end of the task generation cycle.

[0042] Thirdly, the present invention provides the following technical solution: a computer, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the multi-agent cooperative decision-making and disambiguation method as described above.

[0043] Fourthly, the present invention provides the following technical solution: a storage medium storing a computer program, wherein the computer program, when executed by a processor, implements the multi-agent collaborative decision-making and disambiguation method as described above. Attached Figure Description

[0044] To more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0045] Figure 1 This is a flowchart of the multi-agent collaborative decision-making and disambiguation method provided in Embodiment 1 of the present invention;

[0046] Figure 2 This is a structural block diagram of the multi-agent collaborative decision-making and disambiguation system provided in Embodiment 2 of the present invention;

[0047] Figure 3 This is a schematic diagram of the hardware structure of a computer provided for another embodiment of the present invention.

[0048] The embodiments of the present invention will be further described below with reference to the accompanying drawings. Detailed Implementation

[0049] Embodiments of the present invention are described in detail below, examples of which are illustrated in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain embodiments of the present invention, and should not be construed as limiting the present invention.

[0050] Example 1

[0051] In Embodiment 1 of the present invention, as Figure 1 As shown, a multi-agent cooperative decision-making and disambiguation method includes:

[0052] S1. Construct a dynamic knowledge graph, initialize the collaboration center and maintain a dynamic dependency view, and build a collaboration rule base;

[0053] The purpose of constructing a dynamic knowledge graph is to establish a domain knowledge graph that can publish structured "knowledge update events" as a unified source of facts for all intelligent agents to perceive changes in the environment.

[0054] Specifically, the dynamic knowledge graph is constructed using a graph database. In the graph database, triggers are set for the key entity types and attributes that need to be tracked. When the attributes of a key entity change, the triggers are activated, constructing a structured knowledge update event. The knowledge update event is a data object containing entity ID, attribute name, new and old values, and timestamp.

[0055] Initializing the coordination center and maintaining a dynamic dependency view specifically involves the coordination center initializing and maintaining a dependency mapping structure. This structure uses "event triggering conditions" as keys and the set of "agent task contexts" subscribed to those conditions as values. This mapping structure constitutes the system's "dynamic dependency view," which is the data core for achieving efficient routing. Simultaneously, a "decision dependency registration protocol" and an "association unlinking protocol" are defined between agents and the center.

[0056] Specifically, the collaboration center initializes a dependency mapping structure, which is an inverted index implemented based on a distributed cache. The inverted index uses the event trigger condition as the key and the set of task contexts of the agents subscribing to the event trigger condition as the value. The collaboration center provides a RESTful API to receive decision dependency registration requests. When an agent starts executing a task, it actively initiates a call to the collaboration center and submits structured registration information. The registration information includes at least the dynamic association between the event trigger condition and the task context identifier, and the optional lease period.

[0057] Simultaneously, when an agent begins executing a task, it proactively initiates a call to the endpoint, submitting structured registration information. This registration information includes at least a dynamic association between an "event triggering condition" and a "task context identifier." To further enhance system robustness, the registration information may include an optional lease period. During the lease period, the agent must maintain the validity of the dependency through renewal. If the lease expires without renewal, the collaboration center will automatically clean up this dependency association. This mechanism handles situations where the agent is unable to send a release request due to abnormal crashes or other reasons, effectively preventing the accumulation of expired dependency associations in the system.

[0058] For dynamic dependency views At its core, it is a mapping structure that maps "event triggering conditions" to a set of "agent task context identifiers," formally defined as:

[0059] ;

[0060] in, For the set of all possible event triggering conditions, For power set, For tasks, this view serves as an efficient index of the global state, replacing a redundant collection of task contexts.

[0061] The collaborative rule base mainly establishes a formal "condition → action" rule base to define what collaborative strategies should be generated under what event and context combinations.

[0062] Specifically, the collaborative rule base is loaded and executed by the rule inference engine. The collaborative rule base includes one or more collaborative disambiguation rules. The collaborative disambiguation rules are represented in a WHEN-THEN formal format. The WHEN part is used to define the logical premise for the rule to be activated and to make a comprehensive judgment based on the attributes of the received knowledge update event and the task context of the affected agent. The THEN part is used to define the collaborative control instruction output by the rule inference engine when the triggering condition is met.

[0063] Meanwhile, the rule base, as the system's "strategy brain," combines dynamically occurring events with statically preset business logic, thereby generating targeted collaborative strategies for different collaborative scenarios.

[0064] S2. When the agent performs a task, it registers the dependency relationship between its task context and the event triggering conditions of interest with the collaboration center and updates the dynamic dependency view through the collaboration center.

[0065] In the subsequent disambiguation process, its response flow for each knowledge update event at runtime forms an efficient closed loop, which includes:

[0066] Event reception and view routing: When the knowledge graph generates an update event, the collaboration center receives the event, immediately parses its attributes, and generates a query key. Subsequently, the center directly performs a lookup operation in the dependency mapping structure to accurately hit the task context of all affected agents;

[0067] Rule reasoning and strategy generation: The collaboration center takes the event and the located task context as input facts and feeds them into the rule engine for reasoning. The rule engine matches and executes the corresponding rules in the rule base to generate a unified, conflict-free collaboration strategy;

[0068] Policy distribution and state cleanup: The generated collaborative policy is distributed to all relevant agents for execution. At the end of the task lifecycle, the agents notify the collaboration center through the protocol, and the collaboration center then cleans up the relevant associations from the mapping structure, maintaining the accuracy and lightweight nature of the "dynamic dependency view".

[0069] S3. Obtain the knowledge update event of the dynamic knowledge graph, parse the knowledge update time through the collaboration center, and generate a task context identifier set for the intelligent agent;

[0070] Step S3 includes:

[0071] S31. Receive knowledge update events through the collaboration center. And the knowledge update event Formalize as tuples:

[0072] ;

[0073] In the formula, These are the entity ID, attribute name, and timestamp, respectively. These are the old value and the new value, respectively.

[0074] Specifically, when the `credit_rating` attribute of a `User` entity changes (e.g., from 'A' to 'C'), the trigger is activated, constructing a structured knowledge update event. This event is a data object containing the entity ID, attribute name, old and new values, and a timestamp. Subsequently, this event is published to a specified topic (e.g., `kg_updates`) via a message broker (e.g., Apache Kafka).

[0075] The system accepts knowledge update events, and the coordinator node generates lookup keys based on the event attributes. A then efficient key-value lookup is performed in the dynamic dependency view to accurately locate all affected "task context identifiers." This mechanism ensures that the complexity of routing operations is independent of the total system workload, achieving scalable response performance.

[0076] S32. Generate at least one query key based on the contents of the tuple. And based on the query key In the dynamic dependency view Perform a lookup operation to obtain the set of task context identifiers for the affected agents. :

[0077] ;

[0078] Specifically, the query key here can be a combination of entity ID and attribute name, such as "User:123:credit_rating";

[0079] The search operation is specifically Q. route The time complexity of the operation depends on The implementation (such as a hash table implementation is O(1), and a B+ tree implementation is O(logM), where M = | | N, thus achieving decoupling of coordination delay and total system workload N at the algorithm level.

[0080] S4. Construct a fact set based on the task context identifier set, and input the fact set into the rule reasoning engine to execute the rules in the collaborative rule base to generate a strategy, so as to obtain a collaborative strategy;

[0081] Step S4 includes:

[0082] S41. Obtain the corresponding task context through the task context identifier set to obtain the task context set. ;

[0083] S42, Based on the task context set With knowledge update events Constructing a set of facts :

[0084] ;

[0085] S43. Input the fact set into the rule reasoning engine and use the rules in the collaborative rule base for reasoning, for each candidate action. Define decision tuples :

[0086] ;

[0087] ;

[0088] In the formula, For normalization effect, For priority mapping, For logical timestamps, For action-stable hashing, For a monotonically increasing time domain, An auto-incrementing sequence within the same event, ordered by generation.

[0089] Among them, the normalization utility is obtained by feature standardization and weight solidification under the parameter version; the priority mapping also belongs to the parameter version; and the logical timestamp is determined by the event time and the order-increasing function. Crash recovery uses persistent counters to ensure replayability and global comparability.

[0090] S44. Select the best candidate actions using lexicographical order to output the collaborative strategy:

[0091] ;

[0092] In the formula, Candidate actions The decision tuple, Candidate actions The normalization effect, Candidate actions Priority mapping, Candidate actions Logical timestamp, Candidate actions Action-stable hashing;

[0093] Specifically, regarding the lexicographical order comparison above, if the above conditions are met, then Superior Repeating the above steps will output the best candidate action, i.e., the collaborative strategy. On a finite candidate set, the comparison induces a total order, so the output is unique and recalculated. The parameter version fixes all the deterministic parameters (including feature standardization, weight / threshold and hash seed), ensuring that "same input will have the same output".

[0094] S5. Distribute the collaborative strategy to the corresponding intelligent agent and perform a cleanup process at the end of the task generation cycle;

[0095] Specifically, step S5 is as follows:

[0096] The collaboration center distributes the collaboration strategy to the corresponding agents and notifies the collaboration center when the agent's task lifecycle ends, and cleans up the corresponding dependencies from the dynamic dependency view through the collaboration center.

[0097] Specifically, a lease-based active maintenance mechanism was implemented, registration information was expanded to include tuples containing expiration times, and the intelligent agent was task-oriented. Register dependencies At that time, perform the following operation:

[0098] ;

[0099] In the formula, For the lease term, The current time of the collaboration center when the registration operation occurred. For registration;

[0100] This method is accompanied by a background cleanup process that periodically scans and removes dependencies corresponding to expired leases, thereby automatically cleaning up expired dependency associations left by abnormal agents.

[0101] This invention fundamentally enhances the system's decision consistency, real-time response capability, and scalability through an innovative event-precise routing and coordination mechanism. When an agent begins executing a task, it first registers the dependencies between its task context and the triggering conditions of the events it cares about with the coordination center. The coordination center then maintains an efficient dependency mapping structure (preferredly implemented as an inverted index) to dynamically manage this registration information. When an update event occurs in the knowledge graph, the coordination center parses the event and performs a one-time direct lookup based on its maintained mapping structure, accurately locating the task contexts of all affected agents, completely avoiding global traversal queries.

[0102] Subsequently, the collaboration center takes the event and the located task context as input and performs reasoning through a rule-based reasoning engine with a built-in deterministic arbitration mechanism. This engine executes pre-defined collaboration rules and performs deterministic arbitration on candidate actions based on a global total order decision tuple, ultimately generating a globally unified and reproducible collaboration strategy that is distributed to relevant agents, thereby fundamentally avoiding multi-agent decision conflicts and ensuring system consistency.

[0103] To ensure the determinism and correctness of event routing and policy arbitration, this method adopts the following mechanism: First, in the dependency registration and cleanup phase, lease and expiration cleanup constraints ensure the determinism and correctness of the dynamic dependency view V. dyn It can accurately reflect the effective dependencies of the system, so that for any event key k ERouting operation Q route It can accurately and completely locate all, and only, the affected contexts. Secondly, in the policy generation stage, a total order comparison rule for the deterministic arbitration tuple Γ(a) is used, and all key parameters (such as normalization rules, priority mapping, hash seeds, etc.) are solidified under a specific version, ensuring that the output policy of the inference engine is unique and reproducible for the same input rule. These mechanisms work together to eliminate ambiguity and conflict in decision-making at the system level, achieving high reliability in collaborative decision-making. Under the registration / cleanup constraints of lease coverage + expiration cleanup, for any event key k... E Q route It ensures no omissions or over-extractions; by combining deterministic arbitration tuples with version ν fixation, it guarantees that the same input will always have the same output and that there are no ambiguous conflicts.

[0104] The multi-agent collaborative decision-making and disambiguation method provided in Embodiment 1 of this invention uses a dynamic dependency registration mechanism to provide precise, real-time, and lightweight input to the dependency mapping structure, enabling the latter to discard redundant global states and become an efficient read-only cache view. This 'on-demand registration, dynamic construction' mode is a prerequisite for achieving a qualitative leap in query efficiency. The efficient query capability of the dependency mapping structure allows the rule inference engine to avoid dealing with massive amounts of global task data, only needing to infer from a small number of precisely located relevant contexts. This greatly reduces the computational load and memory consumption of the rule engine, avoiding the possibility that complex rule inference may become a new performance bottleneck, thus making the 'event-driven + rule inference' architecture feasible in high-concurrency real-time systems. The rule inference engine generates more targeted outputs based on events and context generated by precise routing, reducing unnecessary network broadcasts and data transmission, thus alleviating system load from another dimension. This collaborative approach of "registering and building the view first, then precisely routing events" not only achieves precise resolution of decision conflicts, but also decouples coordination latency from the total system workload at the system architecture level, transforming it into a relationship with the efficiency of searching for efficient data structures. In this way, the present invention fundamentally solves the inherent contradiction between decision consistency and system real-time performance and scalability, providing reliable technical support for multi-agent systems in high-concurrency scenarios.

[0105] Example 2

[0106] like Figure 2 As shown, in Embodiment 2 of the present invention, a multi-agent collaborative decision-making and disambiguation system is provided, the system comprising:

[0107] Module 1 is used to build a dynamic knowledge graph, initialize the collaboration center and maintain a dynamic dependency view, and build a collaboration rule base.

[0108] Update module 2 is used to register the dependency relationship between its task context and the event triggering conditions of interest with the collaboration center when the agent performs a task, and update the dynamic dependency view through the collaboration center.

[0109] Parsing module 3 is used to obtain the knowledge update events of the dynamic knowledge graph, parse the knowledge update time through the collaboration center, and generate a set of task context identifiers for the intelligent agent;

[0110] Strategy module 4 is used to construct a fact set based on the task context identifier set, input the fact set into the rule reasoning engine to execute the rules in the collaborative rule base to generate a strategy, so as to obtain a collaborative strategy;

[0111] The cleanup module 5 is used to distribute the collaborative strategy to the corresponding intelligent agents and perform a cleanup process at the end of the task generation cycle.

[0112] Specifically, the parsing module 3 is used for:

[0113] Through the orchestration agent Accepts a natural language query from the user and create a unique query context instance. .

[0114] Specifically, the decomposition module 3 is used for:

[0115] Receive knowledge update events through the collaboration center And the knowledge update event Formalize as tuples:

[0116] ;

[0117] In the formula, These are the entity ID, attribute name, and timestamp, respectively. These are the old value and the new value, respectively.

[0118] Generate at least one query key based on the contents of the tuple. And based on the query key In the dynamic dependency view Perform a lookup operation to obtain the set of task context identifiers for the affected agents. :

[0119] .

[0120] Specifically, the strategy module 4 is used for:

[0121] The corresponding task context is obtained through the task context identifier set to obtain the task context set. ;

[0122] Based on the task context set With knowledge update events Constructing a set of facts :

[0123] ;

[0124] The fact set is input into the rule reasoning engine and reasoned using the rules in the collaborative rule base for each candidate action. Define decision tuples :

[0125] ;

[0126] ;

[0127] In the formula, For normalization effect, For priority mapping, For logical timestamps, For action-stable hashing, For a monotonically increasing time domain, An auto-incrementing sequence within the same event, ordered by generation.

[0128] The best candidate actions are selected using lexicographical order to output a collaborative strategy.

[0129] ;

[0130] In the formula, Candidate actions The decision tuple, Candidate actions The normalization effect, Candidate actions Priority mapping, Candidate actions Logical timestamp, Candidate actions The action is stable hashing.

[0131] Specifically, the cleaning module 5 is used for:

[0132] The collaboration center distributes the collaboration strategy to the corresponding agents and notifies the collaboration center when the agent's task lifecycle ends, and cleans up the corresponding dependencies from the dynamic dependency view through the collaboration center.

[0133] In other embodiments of the present invention, the present invention provides the following technical solution: a computer, including a memory 102, a processor 101, and a computer program stored in the memory 102 and executable on the processor 101, wherein the processor 101 executes the computer program to implement the multi-agent cooperative decision-making and disambiguation method as described above.

[0134] Specifically, the processor 101 may include a central processing unit (CPU), or an application specific integrated circuit (ASIC), or one or more integrated circuits that can be configured to implement the embodiments of the present invention.

[0135] The memory 102 may include a large-capacity memory for data or instructions. For example, and not limitingly, the memory 102 may include a hard disk drive (HDD), a floppy disk drive, a solid-state drive (SSD), flash memory, an optical disk drive, a magneto-optical disk drive, magnetic tape, or a Universal Serial Bus (USB) drive, or a combination of two or more of these. Where appropriate, the memory 102 may include removable or non-removable (or fixed) media. Where appropriate, the memory 102 may be internal or external to a data processing device. In a particular embodiment, the memory 102 is non-volatile memory. In a particular embodiment, the memory 102 includes read-only memory (ROM) and random access memory (RAM). Where appropriate, the ROM may be a mask-programmed ROM, a programmable read-only memory (PROM), an erasable read-only memory (EPROM), an electrically erasable read-only memory (EEPROM), an electrically alterable read-only memory (EAROM), or flash memory, or a combination of two or more of these. Where appropriate, the RAM can be Static Random-Access Memory (SRAM) or Dynamic Random-Access Memory (DRAM). DRAM can be Fast Page Mode Dynamic Random Access Memory (FPMDRAM), Extended Data Out Dynamic Random Access Memory (EDODRAM), Synchronous Dynamic Random-Access Memory (SDRAM), etc.

[0136] The memory 102 can be used to store or cache various data files that need to be processed and / or used for communication, as well as possible computer program instructions executed by the processor 101.

[0137] The processor 101 reads and executes the computer program instructions stored in the memory 102 to implement the above-mentioned multi-agent cooperative decision-making and disambiguation method.

[0138] In some embodiments, the computer may further include a communication interface 103 and a bus 100. For example, Figure 3 As shown, the processor 101, memory 102, and communication interface 103 are connected through bus 100 and complete communication with each other.

[0139] The communication interface 103 is used to enable communication between the various modules, devices, units, and / or equipment in the embodiments of the present invention. The communication interface 103 can also enable data communication with other components such as external devices, image / data acquisition devices, databases, external storage, and image / data processing workstations.

[0140] Bus 100 includes hardware, software, or both, that couples components of a computer device together. Bus 100 includes, but is not limited to, at least one of the following: data bus, address bus, control bus, expansion bus, and local bus. For example, and not as a limitation, bus 100 may include an Accelerated Graphics Port (AGP) or other graphics bus, an Extended Industry Standard Architecture (EISA) bus, a Front Side Bus (FSB), a Hyper Transport (HT) interconnect, an Industry Standard Architecture (ISA) bus, an InfiniBand interconnect, a Low Pin Count (LPC) bus, a memory bus, a Micro Channel Architecture (MCA) bus, a Peripheral Component Interconnect (PCI) bus, a PCI-Express (PCI-X) bus, a Serial Advanced Technology Attachment (SATA) bus, a Video Electronics Standards Association Local Bus (VLB) bus, or other suitable buses, or a combination of two or more of these. Where appropriate, bus 100 may include one or more buses. Although specific buses are described and illustrated in the embodiments of the present invention, the present invention is contemplated by any suitable bus or interconnect.

[0141] The computer can execute the multi-agent collaborative decision-making and disambiguation method of the present invention based on the acquired multi-agent collaborative decision-making and disambiguation system, thereby realizing multi-agent collaborative decision-making and disambiguation.

[0142] In some further embodiments of the present invention, in conjunction with the above-described multi-agent cooperative decision-making and disambiguation method, the present invention provides the following technical solution: a storage medium storing a computer program, wherein the computer program, when executed by a processor, implements the above-described multi-agent cooperative decision-making and disambiguation method.

[0143] Those skilled in the art will understand that the logic and / or steps represented in the flowcharts or otherwise described herein, for example, can be considered as a ordered list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable medium" can mean any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device.

[0144] More specific examples of readable media (a non-exhaustive list) include: electrical connections (electronic devices) with one or more wires, portable computer disk drives (magnetic devices), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Furthermore, computer-readable media can even be paper or other suitable media on which the program can be printed, since the program can be obtained electronically, for example, by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in computer memory.

[0145] It should be understood that various parts of the present invention can be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented in software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, it can be implemented using any one or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0146] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0147] The embodiments described above are merely illustrative of several implementations of the present invention, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the invention patent. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and these all fall within the protection scope of the present invention. Therefore, the protection scope of this invention patent should be determined by the appended claims.

Claims

1. A multi-agent collaborative decision-making and disambiguation method, characterized in that, include: Build a dynamic knowledge graph, initialize a collaboration center and maintain a dynamic dependency view, and build a collaboration rule base; When an agent performs a task, it registers the dependency relationship between its task context and the event triggering conditions it is concerned with with the collaboration center and updates the dynamic dependency view through the collaboration center. The knowledge update events of the dynamic knowledge graph are obtained, and the knowledge update events are parsed through the collaboration center to generate a set of task context identifiers for the intelligent agent. A fact set is constructed based on the task context identifier set. The fact set is then input into the rule reasoning engine to execute the rules in the collaborative rule base to generate a strategy, thereby obtaining a collaborative strategy. The collaborative strategy is distributed to the corresponding agents and a cleanup process is performed at the end of the task generation cycle. The collaboration center initializes a dependency mapping structure, which is an inverted index implemented based on a distributed cache. The inverted index uses the event trigger condition as the key and the set of task contexts of the agents subscribing to the event trigger condition as the value. The collaboration center is used to provide a RESTful API to receive decision dependency registration requests. When an agent starts executing a task, it actively initiates a call to the collaboration center and submits structured registration information. The registration information includes at least the dynamic association between the event trigger condition and the task context identifier, and the optional lease period. The steps of constructing a fact set based on the task context identifier set, and inputting the fact set into the rule reasoning engine to execute the rules in the collaborative rule base to generate a policy, thereby obtaining a collaborative policy, include: The corresponding task context is obtained through the task context identifier set to obtain the task context set. ; Based on the task context set With knowledge update events Constructing a set of facts : ； The fact set is input into the rule reasoning engine and reasoned using the rules in the collaborative rule base for each candidate action. Define decision tuples : ； ； In the formula, For normalization effect, For priority mapping, For logical timestamps, For action-stable hashing, For a monotonically increasing time domain, An auto-incrementing sequence within the same event, ordered by generation. The best candidate actions are selected using lexicographical order to output a collaborative strategy. ； In the formula, Candidate actions The decision tuple, Candidate actions The normalization effect, Candidate actions Priority mapping, Candidate actions Logical timestamp, Candidate actions The action is stable hashing.

2. The multi-agent cooperative decision-making and disambiguation method according to claim 1, characterized in that, The dynamic knowledge graph is constructed using a graph database. In the graph database, triggers are set for the key entity types and attributes that need to be tracked. When the attributes of a key entity change, the triggers are activated, constructing a structured knowledge update event. The knowledge update event is a data object containing entity ID, attribute name, new and old values, and timestamp.

3. The multi-agent cooperative decision-making and disambiguation method according to claim 1, characterized in that, The collaborative rule base is loaded and executed by the rule inference engine. The collaborative rule base includes one or more collaborative disambiguation rules. The collaborative disambiguation rules are represented in a WHEN-THEN formal format. The WHEN part is used to define the logical premise for the rule to be activated and to make a comprehensive judgment based on the attributes of the received knowledge update event and the task context of the affected agent. The THEN part is used to define the collaborative control instruction output by the rule inference engine when the triggering condition is met.

4. The multi-agent cooperative decision-making and disambiguation method according to claim 1, characterized in that, The step of parsing the knowledge update event and generating a set of agent task context identifiers through the collaboration center includes: Receive knowledge update events through the collaboration center And the knowledge update event Formalize as tuples: ； In the formula, These are the entity ID, attribute name, and timestamp, respectively. These are the old value and the new value, respectively. Generate at least one query key based on the contents of the tuple. And based on the query key In the dynamic dependency view Perform a lookup operation to obtain the set of task context identifiers for the affected agents. : 。 5. The multi-agent cooperative decision-making and disambiguation method according to claim 1, characterized in that, The specific steps of distributing the collaborative strategy to the corresponding intelligent agents and performing a cleanup process at the end of the task generation cycle are as follows: The collaboration center distributes the collaboration strategy to the corresponding agents and notifies the collaboration center when the agent's task lifecycle ends, and cleans up the corresponding dependencies from the dynamic dependency view through the collaboration center.

6. A multi-agent collaborative decision-making and disambiguation system, characterized in that, The system includes: The building module is used to construct a dynamic knowledge graph, initialize the collaboration center and maintain a dynamic dependency view, and build a collaboration rule base. The update module is used to register the dependency relationship between its task context and the event triggering conditions of interest with the collaboration center when the agent performs a task, and update the dynamic dependency view through the collaboration center. The parsing module is used to obtain the knowledge update events of the dynamic knowledge graph, parse the knowledge update events through the collaboration center, and generate a set of task context identifiers for the intelligent agent. The strategy module is used to construct a fact set based on the task context identifier set, input the fact set into the rule reasoning engine to execute the rules in the collaborative rule base to generate a strategy, so as to obtain a collaborative strategy; The cleanup module is used to distribute the collaborative strategy to the corresponding intelligent agents and perform a cleanup process at the end of the task generation cycle; The collaboration center initializes a dependency mapping structure, which is an inverted index implemented based on a distributed cache. The inverted index uses the event trigger condition as the key and the set of task contexts of the agents subscribing to the event trigger condition as the value. The collaboration center provides a RESTful API to receive decision dependency registration requests. When an agent starts executing a task, it actively initiates a call to the collaboration center and submits structured registration information. The registration information includes at least the dynamic association between the event trigger condition and the task context identifier, and the optional lease period. The strategy module is specifically used for: The corresponding task context is obtained through the task context identifier set to obtain the task context set. ; Based on the task context set With knowledge update events Constructing a set of facts : ； The fact set is input into the rule reasoning engine and reasoned using the rules in the collaborative rule base for each candidate action. Define decision tuples : ； ； In the formula, For normalization effect, For priority mapping, For logical timestamps, For action-stable hashing, For a monotonically increasing time domain, An auto-incrementing sequence within the same event, ordered by generation. The best candidate actions are selected using lexicographical order to output a collaborative strategy. ； In the formula, Candidate actions The decision tuple, Candidate actions The normalization effect, Candidate actions Priority mapping, Candidate actions Logical timestamp, Candidate actions The action is stable hashing.

7. A computer comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the multi-agent cooperative decision-making and disambiguation method as described in any one of claims 1 to 5.

8. A storage medium, characterized in that, The storage medium stores a computer program, which, when executed by a processor, implements the multi-agent cooperative decision-making and disambiguation method as described in any one of claims 1 to 5.

Images