A multi-agent cooperative optimization method and system

Abstract

The present application relates to the technical field of multi-agent cooperation optimization, and particularly relates to a multi-agent cooperation optimization method and system, comprising: obtaining the scheduling weight of each agent in the current round; distributing tasks and performing according to the scheduling weight, calculating the normalized contribution weight of each agent; obtaining a candidate elimination set based on the normalized contribution weight, sequentially performing single-point simulation elimination, if the single performance reduction is not greater than the performance tolerance, the candidate agent participates in joint simulation elimination; if the joint performance reduction is greater than the performance tolerance, the eliminated agents are recalled one by one according to the normalized contribution weight, until the recall performance reduction is not greater than the performance tolerance, obtaining the final multi-agent set, updating the scheduling weight of each agent. The present application quantifies the dynamic contribution by marginal contribution, guarantees the system performance safety by combining the reversible elimination and recall mechanism, and improves the cooperation stability and efficiency of the multi-agent system in the heterogeneous environment by using the performance feedback closed-loop iteration.

Description

Technical Field

[0001] This invention relates to the field of multi-agent cooperative optimization technology, specifically to a multi-agent cooperative optimization method and system. Background Technology

[0002] With the rapid development of artificial intelligence technology, multi-agent systems have been widely applied in areas such as task collaboration, reasoning and decision-making, and intelligent scheduling. Multi-agent systems typically consist of numerous agents with varying capabilities, each capable of independently completing a specific task or collaborating with other agents to execute complex tasks. To improve the execution efficiency of such systems, multi-agent collaboration optimization techniques have become a key research focus.

[0003] In existing multi-agent collaborative optimization methods, fixed weight allocation or heuristic rules based on human experience are typically used to schedule the agents. When performing complex tasks, the participation ratio of each agent is often pre-set; however, when the system performance is poor or some agents perform poorly, existing multi-agent systems usually use hard removal or manual re-intervention of weights to adjust the agent combination, thereby shrinking and optimizing the system structure.

[0004] However, the aforementioned existing technologies generally face the following drawbacks in practical applications: First, contribution quantification is inaccurate. Due to the highly heterogeneous capabilities of agents and the dynamic changes in the task environment, traditional fixed-weight or experience-based scheduling methods cannot accurately quantify the true marginal contribution of each agent to the overall task completion effect, resulting in large fluctuations in overall system performance and making it difficult to predict. Second, the elimination mechanism lacks adaptability and fault tolerance. When eliminating agents suspected of having low contributions, existing methods are prone to disrupting the original collaborative topology and contextual dependencies between multiple agents, often causing the overall system performance to plummet rather than improve; moreover, due to the lack of a reversible recovery mechanism, the system cannot quickly roll back and repair the damaged structure, greatly limiting its practicality in dynamic environments. In addition, due to the lack of a unified and dynamic contribution measurement standard, it is difficult to perform multiple rounds of iterative optimization based on performance feedback, making it difficult to achieve continuous improvement in the collaborative effect between agents.

[0005] Therefore, the urgent technical problem to be solved is: how to provide a multi-agent optimization method that can accurately quantify and evaluate the dynamic contribution of each agent, and adaptively adjust the combination and cooperation weights of agents while ensuring the overall system performance safety and reversibility, so as to achieve efficient cooperation and stable operation of multi-agent systems in complex task environments. Summary of the Invention

[0006] To address the aforementioned technical problems, the present invention aims to provide a multi-agent cooperative optimization method and system, the specific technical solution of which is as follows: One embodiment of the present invention provides a multi-agent cooperative optimization method, the method comprising the following steps: Step S1: Obtain the scheduling weight of each agent in the initial multi-agent set in the current round; Step S2: Assign tasks to each agent according to the scheduling weight and execute them. Evaluate the baseline system performance index of the current round based on the task execution accuracy and resource overhead index. By traversing the initial multi-agent set, calculate the marginal contribution of each agent in combination with the baseline system performance index, and then determine the normalized contribution weight of each agent in the current round based on the marginal contribution. Step S3: Add agents whose normalized contribution weight is lower than the preset contribution threshold to the candidate elimination set; sequentially traverse each candidate agent in the candidate elimination set, perform a single-point simulated elimination operation on the current candidate agent and re-evaluate the system performance. If the single performance drop between the benchmark system performance index and the simulated system performance index is not greater than the preset performance tolerance, then the current candidate agent participates in the joint simulated elimination. Step S4: Calculate the joint performance reduction after joint simulation elimination. If the joint performance reduction is greater than the performance tolerance, recall the eliminated candidate agents one by one in the order of the normalized contribution weight from high to low and calculate the recall performance reduction until the current recall performance reduction is not greater than the performance tolerance, and obtain the final system performance and the final multi-agent set for the current round. Step S5: Calculate the performance improvement between the final system performance index and the reference system performance index of the previous round; for each agent in the final multi-agent set, update the scheduling weight of each agent using the normalized contribution weight, the sign attribute of the marginal contribution, and the performance improvement.

[0007] Another embodiment of the present invention provides a multi-agent cooperative optimization system, including a processor and a memory, wherein the processor is used to process instructions stored in the memory to implement the multi-agent cooperative optimization method described above.

[0008] The present invention has the following beneficial effects: This invention provides a multi-agent collaborative optimization method and system. The method evaluates the performance of a benchmark system using task execution accuracy and resource overhead metrics, and calculates the marginal contribution of each agent using the Shapley value concept to determine normalized contribution weights. This accurately quantifies the true dynamic contribution of each agent to the overall task completion in the current round, overcoming the limitations of traditional fixed-weight or experience-based scheduling in adapting to heterogeneous capabilities and dynamic environments, significantly improving the stability and predictability of system performance. Furthermore, it introduces a candidate elimination mechanism based on contribution thresholds, a reversible Dropout strategy combining single-point simulated elimination and joint simulated elimination, and a backoff mechanism that sequentially recalls candidates based on contribution weight from high to low and verifies the joint performance reduction, effectively solving the problems of existing elimination methods. Addressing the issues of easily disrupting collaborative topology, causing sudden performance drops, and lacking rapid rollback, this mechanism, while ensuring system performance safety, achieves adaptive screening and structural repair of low-contribution agents, providing fault tolerance and reversible recovery capabilities for multi-agent collaboration in dynamic environments. Finally, it calculates the performance improvement between the final system performance of the current round and the reference performance of the previous round, and uses normalized contribution weights, the sign attribute of marginal contributions, and performance improvement to jointly update the scheduling weights of each agent, forming a closed-loop iterative optimization. This allows the collaborative effect between agents to continuously improve with each round, solving the problems of lacking a unified dynamic contribution measurement standard and difficulty in multi-round performance feedback adjustments, ultimately achieving efficient collaboration and stable operation of multi-agent systems in complex task environments. Attached Figure Description

[0009] To more clearly illustrate the technical solutions and advantages in the embodiments of the present invention or the prior art, 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.

[0010] Figure 1 This is a flowchart illustrating the steps of a multi-agent cooperative optimization method according to an embodiment of the present invention. Detailed Implementation

[0011] To achieve efficient collaboration and stable operation of multi-agent systems in complex task environments, one embodiment of the present invention provides a multi-agent collaboration optimization method, such as... Figure 1 As shown, it includes the following steps: Step S1: Obtain the scheduling weight of each agent in the initial multi-agent set in the current round.

[0012] As an exemplary implementation, obtaining an initial multi-agent set includes: If the current round is the first iteration, during the system startup phase, an initial multi-agent set consisting of five agents with defined and complementary functions should be explicitly constructed. In this system, each agent performs inference and text generation tasks by calling the Application Programming Interface (API) provided by the Large Language Model (LLM). Specifically: intelligent agent As a mathematical reasoning agent, it is responsible for providing rigorous reasoning and calculation instructions for the mathematical, formulaic, and logical derivations in the input problem or task. intelligent agent As a strategic planning agent, it is responsible for generating step-by-step execution strategies and task planning suggestions; intelligent agent As a fact-checking agent, it is responsible for verifying and correcting factual statements in the output of other agents; intelligent agent As a style and readability agent, it is responsible for optimizing the language style, readability, and structure of the output; intelligent agent To aggregate and assist decision-making agents, it is responsible for integrating the opinions of various agents, generating the final synthesized recommendations, and outputting the final decision text.

[0013] Additionally, it should be noted that, in order to ensure consistency in the acquisition of underlying capabilities by agents, so that they can complement each other in this round of collaboration according to their respective task divisions, each agent can obtain inference capabilities at the implementation level by calling external LLM APIs (such as Spark X1-32K, OpenAI, etc., depending on the system configuration). The model identifier, authentication information and network parameters required for API calls are uniformly managed by the system configuration module.

[0014] If the current round is not the first iteration, the final set of multi-agents determined in the previous round is used as the initial set of multi-agents.

[0015] As an exemplary implementation, obtaining the scheduling weight of each agent in the initial multi-agent set in the current round includes: If the current round is the first iteration, to support subsequent contribution evaluation based on Shapley values ​​and the reversible Dropout mechanism, the initial weights of each agent in the initial multi-agent set are defined in the initialization phase for the first round. This is essentially the scheduling weight of each agent in the initial multi-agent set for the current round. Each agent has the same initial weight. For example, when the number of agents in the initial multi-agent set is 5, the initial weights of the agents can be: ,(i=1,...,5).

[0016] If the current round is not the first iteration, the scheduling weight of the current round is the updated scheduling weight of each agent in the final multi-agent set of the previous round.

[0017] Thus, this embodiment obtains the scheduling weights of each agent in the initial multi-agent set in the current round.

[0018] Step S2: Assign tasks to each agent according to the scheduling weight and execute them. Evaluate the baseline system performance index of the current round based on the task execution accuracy and resource overhead index. By traversing the initial multi-agent set, calculate the marginal contribution of each agent and then determine the normalized contribution weight of each agent in the current round based on the marginal contribution.

[0019] After obtaining the scheduling weights of each agent in the current round, the multi-agent parallel task execution phase can begin. In this phase, this embodiment dynamically evaluates the agent's contribution weight in the overall collaboration (i.e., normalized contribution weight) by performing performance sampling and marginal contribution analysis on the independent inference process of each agent, providing a basis for subsequent reversible Dropout adjustments.

[0020] As an exemplary implementation, tasks are assigned and executed to each agent according to scheduling weights, and the baseline system performance metrics for the current round are evaluated based on task execution accuracy and resource overhead metrics, including: The first step is to assign task information to each agent in the initial multi-agent set according to the scheduling weight and trigger parallel execution to obtain the overall execution output and the actual resource consumption.

[0021] Task information is assigned to agents and parallel execution is triggered. Based on the agents' system operating parameters and scheduling weights, task input information is assigned to each agent, and an independent inference thread is started to obtain the overall execution output and actual resource consumption. In this embodiment, the overall execution output refers to the final decision text generated in the current round by the aggregation decision agent after obtaining the intermediate inference results of other active agents and performing unified fusion; the actual resource consumption refers to the total token consumption generated by all active agents in the current round during their independent calls to the large model API.

[0022] The system operating parameters include at least the current scheduling weight of each agent, the active state identifier (indicating whether the agent is in a reversible Dropout frozen state), API call configuration information, and role prompt word templates corresponding to the functions of each agent. The system scheduling module reads these operating parameters, maps and distributes the corresponding input context only to agents in an active state, and allocates corresponding computing resources and inference execution priorities to them based on their current scheduling weight.

[0023] In this embodiment, the five agents each execute their corresponding tasks through their bound large language model API interfaces, wherein: the policy planning agent calls the model. Generate task breakdown and planning schemes; mathematical reasoning agent invokes model. Complete structured input preprocessing and feature extraction; the fact-verifying agent invokes the model. Perform factual and logical consistency checks on intermediate inference results; style and readability of the agent invoking the model. Unify text style, structure, and readability; summarize and summarize the model invoked by the decision-making aid agent. Finally, the results from multiple sources are merged to generate the system output.

[0024] The second step is to score the overall execution output based on the preset evaluation criteria to obtain the task execution accuracy.

[0025] In this embodiment, the overall system output is compared with the standard answer or preset verification target of the task. The accuracy or F1 score, normalized according to the task type, is used as the system-level task execution accuracy. For example, for classification tasks, the prediction accuracy or F1 score of the final system output is mapped to the [0,1] interval using Min-Max normalization. To eliminate differences in the dimensions of different task metrics, range normalization or Z-score standardization can be used, ensuring that the overall system task execution accuracy after removing different agents is mapped to a unified standard interval, providing a unified system-level performance evaluation benchmark for subsequently calculating the marginal contribution of each agent's Shapley value.

[0026] The third step is to obtain resource expenditure indicators based on the actual resource consumption.

[0027] In evaluation systems, resource consumption metrics are typically designed as cost-based indicators, aiming to measure the degree of resource efficiency or cost-effectiveness in resource usage. Specifically, higher actual resource consumption (such as CPU utilization and memory usage) means the system consumes more resources, resulting in higher operating costs or load pressure. To encourage efficient resource utilization, evaluation rules are set such that higher consumption leads to lower scores, and lower consumption leads to higher scores. Therefore, resource consumption metrics are negatively correlated with actual resource consumption.

[0028] In this embodiment, the formula for calculating the resource overhead index can be: In the formula, This represents the resource cost metric for the current round t. This represents the actual resource consumption in the current round t; This indicates the pre-set lower limit of historical experience points consumed per task token, which can be 500 experience points. This indicates the pre-set maximum historical experience value for a single task token consumption, which can be 800 experience points.

[0029] The fourth step involves using preset evaluation fusion weights to perform a weighted sum of task execution accuracy and resource overhead indicators to obtain the baseline system performance indicators for the current round.

[0030] To ensure that the performance evaluation is quantifiable, reproducible, and easy to assess using Shapley values, the following formula is constructed to calculate the benchmark system performance index for evaluating the performance of multi-agent systems: In the formula, This represents the baseline system performance index for the current round t. This indicates the preset evaluation fusion weights. This indicates the accuracy of task execution in the current round t. This represents the resource consumption metric for the current round t.

[0031] In the calculation formula of the benchmark system performance index, the preset evaluation fusion weight can be taken as an empirical value of 0.75. It can construct a performance evaluation model with task execution accuracy as the main factor and resource overhead index as the secondary factor, which can be applied to most NLP and inference generation tasks. The benchmark system performance index determined by the preset evaluation fusion weight not only reflects the accuracy of the generation results, but also measures the inference efficiency and token resource cost, making the subsequent Dropout and contribution calculation more meaningful for optimization.

[0032] As an exemplary implementation, by traversing the initial multi-agent set, calculating the marginal contribution of each agent, and then determining the normalized contribution weight of each agent in the current round based on the marginal contribution, including: The first step is to calculate the marginal contribution of each agent by traversing the initial multi-agent set, including: The first sub-step involves determining at least one first combined state containing the target agent for each target agent in the initial multi-agent set, and a second combined state corresponding to the first combined state after removing the target agent.

[0033] Here, the target agent refers to any agent in the initial set of multiple agents.

[0034] The second sub-step involves evaluating the system performance scores when performing tasks in the first and second combined states, respectively, and calculating the performance difference between the two.

[0035] Here, when the first combined state contains the complete initial multi-agent set for the current round, the benchmark system performance index is used as the system performance score of the first combined state.

[0036] The third sub-step involves determining the marginal contribution of the target agent based on the number of calculated performance differences. When the number of performance differences is equal to 1, the performance difference is directly used as the marginal contribution; when the number of performance differences is greater than 1, multiple performance differences are aggregated to obtain the marginal contribution.

[0037] As a specific implementation method, the marginal contribution of an agent is obtained based on an exact calculation method of exhaustive combination, including: The first sub-step involves obtaining the remaining agents in the initial multi-agent set, excluding the target agent, and enumerating all possible combinations of these remaining agents. For each combination, the combination is merged with the target agent to form a first combined state, and the combination itself is used as the corresponding second combined state.

[0038] For example, suppose the initial multi-agent set includes to There are five intelligent agents in total, and the target intelligent agent is... Exhaustive enumeration of remaining intelligent agents There are a total of 16 combinations (from the empty set to containing all four). Consider one of these combinations. For example, add The first combined state is then formed. , not joining The second combination state formed at that time is .

[0039] The second sub-step involves the system scheduling the corresponding agent combinations to perform inference tasks, and obtaining and calculating the system performance score differences for 16 pairs of combined states.

[0040] In this embodiment, referring to the calculation process of the benchmark system performance index described above, the system-level performance score corresponding to each first combined state and the second combined state can be obtained, and then the difference between the system-level performance scores of each pair of combined states can be obtained, that is, the first combined state (i.e. The system-level performance score minus the second combination state (i.e.) The system-level performance score.

[0041] The third sub-step involves a performance difference greater than one (16 in total). The aggregation process performed on multiple performance differences is a weighted summation: In this embodiment, based on the number of agents contained in each combined state (i.e., the first combined state or the second combined state), corresponding weight values ​​are assigned according to the standard Shapley value weight allocation formula. Then, the 16 system performance score differences are multiplied by the corresponding weights and summed to obtain the precise marginal contribution of the target agent.

[0042] As an example, the formula for calculating the marginal contribution of agent i (i.e., the target agent) in the current round t can be: In the formula, The marginal contribution of agent i in the current round t is represented; N represents the total number of agents in the current round t that are in an active state (not frozen); S represents any combination of the remaining agents other than agent i, i.e., the second combination state. This indicates the number of agents included in the second combination state; This represents the set formed after merging agent i into the second combined state, i.e., the first combined state; This represents the overall system performance score under the first combined state; This represents the overall system performance score under the second combination state; This represents the change in system performance score before and after the addition of target agent i, i.e., the difference in system performance score mentioned above. This represents the weight value assigned to the difference in the corresponding system performance score by the standard Shapley value weighting formula.

[0043] It should be noted that the exact calculation method based on exhaustive combination is suitable for situations where the number of agents is small and accuracy is required.

[0044] In another specific implementation, the marginal contribution of the agent is obtained based on an approximate calculation method using random sampling, including: The first sub-step involves setting a preset number of sampling times M (e.g., M=3). From the multi-agent set, excluding the target agent, three subsets of different sizes or members are randomly selected. These three random subsets are then merged with the target agent to generate three first combined states. The three randomly selected subsets are then directly used as the corresponding second combined states.

[0045] The second sub-step involves performing reasoning tasks on three pairs of combined states, obtaining performance scores, and subtracting them to obtain three performance difference values.

[0046] The third sub-step involves a performance difference greater than 1. The aggregation process for multiple performance differences is an arithmetic average: the three calculated performance differences are directly added together and divided by the preset number of samplings M to obtain the approximate marginal contribution of the target agent.

[0047] It should be noted that the approximate calculation method based on random sampling can be applied to situations where computational overhead needs to be controlled to save on API call costs for large models.

[0048] The second step is to determine the normalized contribution weight of each agent in the current round based on its marginal contribution, including: The first sub-step involves obtaining the historical contribution value of any agent in the initial multi-agent set from the previous round.

[0049] In this embodiment, if the current round is not the first iteration, the marginal contribution of the agent in the previous round can be used as the historical contribution value; if the current round is the first iteration, the historical contribution value is set as a preset initial benchmark value. For example, the initial benchmark value can be set as the average score (i.e., 1 / N, where N is the total number of agents) to maintain consistency with the initial weight of the agents, or it can be directly set to 0, and automatically updated and adjusted by the system in subsequent iterations.

[0050] The second sub-step involves using a preset smoothing coefficient to perform a weighted sum of the historical contribution value and the agent's marginal contribution in the current round, thereby calculating the agent's dynamic smoothed contribution value in the current round.

[0051] As an example, the formula for calculating the dynamic smoothing contribution value of agent i in the current round t can be: In the formula, This represents the dynamic smoothing contribution value of agent i in the current round t. This represents the preset smoothing coefficient. This indicates that agent i was in the previous round. Historical contribution value This represents the marginal contribution of target agent i in the current round t.

[0052] In the formula for calculating the dynamic smoothing contribution value, the smoothing coefficient can be taken as an empirical value of 0.7, which is used to balance the weight ratio of historical evaluation results and current observations. The setting of 0.7 tends to retain more historical memory, suppress random errors or occasional performance fluctuations caused by single-round inference, and ensure that the contribution evaluation transitions smoothly in multiple rounds of iteration.

[0053] The third sub-step is to calculate the sum of the dynamic smoothing contribution values ​​of all agents in the initial multi-agent set.

[0054] The fourth sub-step involves dividing the dynamic smoothed contribution value of any agent by the absolute value of the sum to obtain the normalized contribution weight of the agent in the current round.

[0055] To eliminate the dimensional differences caused by task indicators, absolute values ​​are converted into relative proportions, i.e., normalized contribution weights are determined. This satisfies the mathematical constraints of system scheduling weights and provides a unified comparison benchmark for subsequent Dropout determination based on contribution thresholds.

[0056] As an example, the formula for calculating the normalized contribution weight of agent i in the current round t can be: In the formula, This represents the normalized contribution weight of agent i in the current round t. Let N represent the dynamic smoothing contribution value of agent i in the current round t, and let N represent the total number of agents in the current round t that are in an active state (non-frozen state). This represents the dynamic smoothing contribution value of agent j in the current round t.

[0057] Thus, this embodiment obtains the normalized contribution weight of each agent in the current round.

[0058] Step S3: Add agents whose normalized contribution weight is lower than the preset contribution threshold to the candidate elimination set; sequentially traverse each candidate agent in the candidate elimination set, perform single-point simulation elimination operation on the current candidate agent and re-evaluate the system performance. If the single performance drop between the benchmark system performance index and the simulated system performance index is not greater than the preset performance tolerance, then the current candidate agent participates in the joint simulation elimination.

[0059] After obtaining the normalized contribution weight of each agent in the current round, agent selection can be performed. However, this embodiment does not simply eliminate low-contribution agents, but rather uses a dual constraint of initial contribution screening and system performance feedback verification to modify the structural state of inefficient agents. When performing the elimination operation, only the inference thread of the target agent is frozen, while its context cache and historical path information are retained. This achieves a structural adaptive adjustment that can be recovered without loss at any time, eliminating redundant agents to optimize system overhead while ensuring the continuity of the overall task inference process and the stability of system performance.

[0060] As an exemplary implementation, agents whose normalized contribution weight is lower than a preset contribution threshold are included in the candidate elimination set, including: Here, the candidate elimination set only represents a set of potentially inefficient agents; they are not immediately removed from the system but need to enter a subsequent step-by-step evaluation process. For candidate agents, initial screening and locking can be achieved by comparing normalized contribution weights with contribution thresholds. Utilizing normalized contribution values ​​to quickly identify inefficient agents avoids unnecessary computations on core high-contribution agents, reduces system overhead, and protects core processes.

[0061] In this embodiment, all agents can be sorted from low to high according to their normalized contribution weights to construct a candidate dropout set, which can be expressed as follows: In the formula, This represents the candidate set to be eliminated in the current round. Represents agent i, This represents the normalized contribution weight of agent i in the current round t. This indicates the preset contribution threshold.

[0062] As an example, the contribution threshold is set as follows: obtain the preset reversible Dropout threshold coefficient; calculate the theoretical average weight 1 / N based on the total number of agents N in the initial multi-agent set; multiply the theoretical average weight by the reversible Dropout threshold coefficient to obtain the contribution threshold. It is worth noting that this contribution threshold setting method can adaptively adjust the judgment criterion according to the agent size, avoiding candidate set selection failure caused by a single absolute threshold.

[0063] The preset reversible dropout threshold coefficient is used to define the system's tolerance for inefficient agent performance. An empirical value range can be set from 0.4 to 0.8. For example, setting this coefficient to 0.6. When the system contains 5 agents, the theoretical average weight is 0.2. The calculated contribution threshold is then 0.12. When an agent's normalized contribution weight is less than 0.12, it is added to the candidate elimination set.

[0064] It should be noted that if no agent's normalized contribution weight is lower than 0.12, it means that the contribution performance of all agents is at a relatively balanced and healthy level, and there are no obvious inefficient and redundant nodes in the system. In this round, no structural pruning is required. The subsequent elimination verification and recall steps can be skipped directly. The network structure of all active agents remains unchanged, and the current overall performance is taken as the final performance. The process can then proceed directly to the next step (i.e., step 5) to perform iterative updates of the weights.

[0065] As an exemplary implementation, each candidate agent in the candidate elimination set is traversed sequentially. A single-point simulated elimination operation is performed on the current candidate agent, and the system performance is re-evaluated. If the single performance degradation between the baseline system performance index and the simulated system performance index is not greater than a preset performance tolerance, then the current candidate agent participates in joint simulated elimination, including: Single-point simulated elimination is used to verify whether low-contribution agents are indispensable underlying nodes. If the performance degradation after single-point elimination is within tolerance, it indicates that the function of the agent is redundant in the current task or has been replaced by other agents, and has the potential for safe elimination, thus allowing it to enter the subsequent joint elimination test.

[0066] As an exemplary implementation, each candidate agent in the candidate elimination set is traversed sequentially to determine whether the current candidate agent can participate in the subsequent joint simulation elimination, including: The first step is to iterate through each candidate agent in the candidate elimination set, perform a single-point simulation elimination operation on the current candidate agent, and re-evaluate the system performance.

[0067] Here, single-point simulated elimination operation refers to eliminating only the current candidate agent in the candidate elimination set.

[0068] In this embodiment, any candidate agent in the candidate elimination set is taken as the current candidate agent, and the current candidate agent is eliminated from the initial multi-agent set by single-point simulation to obtain the simulated agent set; the system performance of the simulated agent set is evaluated to obtain the simulated system performance index corresponding to the current candidate agent.

[0069] Furthermore, any candidate agent in the candidate elimination set is taken as the current candidate agent. The inference thread of the current candidate agent is paused, while the context cache and historical path information of the current candidate agent are retained. The current candidate agent is marked as a reversible frozen state to achieve single-point simulation elimination of the current candidate agent from the initial multi-agent set, resulting in a simulated agent set. The task process is re-executed using the simulated agent set, and system performance is evaluated. That is, the overall performance index under the configuration information of the current simulated agent set is recorded as the simulated system performance index corresponding to the current candidate agent.

[0070] Among them, executing the task process refers to rerunning the complete task process once, and its inference depth and context window can be set to be consistent with step S2 as required; the method of obtaining the simulation system performance index corresponding to the current candidate agent can refer to the method of determining the benchmark system performance index in step S2 above, and will not be repeated here.

[0071] As an example, the expression for the performance index of the simulation system corresponding to the current candidate agent can be: In the formula, This represents the simulated system performance index of the system corresponding to the current set of simulated agents after eliminating the current candidate agent k in a single-point simulation. This represents the initial set of multiple agents, containing all agents currently active in the system. This represents the current candidate agent k that is marked as being in a reversible frozen state. This represents the system performance evaluation function, which uses the performance evaluation metrics defined in step S2 to calculate the task accuracy and resource overhead scores. This indicates that the difference operation is performed on the initial multi-agent set A, which is the simulated agent set formed after removing the current candidate agent k.

[0072] The second step is to calculate the single performance degradation between the baseline system performance index and the simulated system performance index. If the single performance degradation is not greater than the preset performance tolerance, the current candidate agent will participate in the joint simulation elimination.

[0073] Here, a single performance degradation is used to determine whether the Dropout operation is actually performed. To ensure stability, this embodiment sets a performance tolerance and uses the above and below judgment analysis.

[0074] In this embodiment, the single performance degradation is calculated as follows: the difference between the performance index of the benchmark system and the performance index of the simulated system is calculated to obtain the single performance degradation, and the calculation formula can be: In the formula, This represents the single performance degradation of the current candidate agent k. This represents the baseline system performance index for the current round t. This represents the simulation system performance index of the system corresponding to the current set of simulated agents after removing the current candidate agent k in a single-point simulation.

[0075] If the single performance degradation does not exceed the preset performance tolerance, that is... , If the preset performance tolerance is indicated, it means that removing the current candidate agent k will not cause unacceptable damage to the overall performance. At this time, the system can switch it to the formal Dropout state, that is, the current candidate agent can participate in the subsequent joint simulation elimination.

[0076] Performance tolerance quantifies the system's tolerance for a decrease in overall system performance due to the removal of agents. It can be set as a relative proportion to a historical benchmark, specifically by setting a percentage of the benchmark system's performance metric. For example, allowing a performance degradation of no more than 5% of the total performance is acceptable. .

[0077] Conversely, if the degradation of a single performance metric exceeds the preset performance tolerance, i.e. If the current candidate agent k has a low contribution, it means that although it has a structural dependency on the overall process or a compensatory effect on local steps, the freeze can be lifted and its inference thread can be restored.

[0078] It should be noted that when the recall conditions are met and the inference thread of the current candidate agent is restored, there is no need to reinitialize the agent. Instead, the agent's state is seamlessly switched back from the frozen state to the active state by calling the context cache snapshot and historical path information saved before the simulated elimination in step S3. This reversible recovery mechanism eliminates the semantic gaps of model hot-start, ensuring that the recalled agent can immediately continue to execute tasks on the original inference logic chain. Thus, while maintaining the flexibility of dynamic adjustment of the multi-agent cooperative network topology, it effectively guarantees the contextual coherence of the overall task output and the integrity of the inference path.

[0079] After performing the above step-by-step decision-making process on the candidate removal set, the joint removal set for the current round, i.e., the formal Dropout set, can be obtained. In the formula, This represents the joint elimination set for the current round t.

[0080] Thus, this embodiment has obtained the candidate agents participating in the joint simulation elimination in the current round.

[0081] Step S4: Calculate the joint performance reduction after joint simulation elimination. If the joint performance reduction is greater than the performance tolerance, recall the eliminated candidate agents one by one in order of normalized contribution weight from high to low and calculate the recall performance reduction until the current recall performance reduction is not greater than the performance tolerance, and obtain the final system performance and the final multi-agent set for the current round.

[0082] Although each candidate agent has passed single-point elimination verification, the concurrent absence of multiple agents may result in nonlinear collaborative performance loss. Therefore, after performing structured shrinkage (Dropout), a global performance consistency verification phase is entered. This phase primarily verifies the steady-state performance of the multi-agent cooperative network after topology simplification, ensuring that the elimination of local redundancy does not lead to a systematic degradation of global inference quality. If the performance degradation caused by joint elimination exceeds a preset performance tolerance, the current structure shrinkage is deemed excessive, triggering a step-by-step recall mechanism based on reverse contribution priority. Furthermore, by utilizing pre-stored context snapshots to perform lossless state recovery of key agents, adaptive dynamic regression of the system structure is achieved, thereby seeking the optimal balance between computational overhead and inference quality while ensuring overall performance reversibility.

[0083] As an exemplary implementation, step S4 above includes: The first step is to obtain a joint elimination set consisting of all candidate agents that satisfy the single performance reduction constraint in the initial multi-agent set, and simultaneously reconstruct the inference topology for the remaining active agents, including updating the task input allocation matrix, adjusting the dependency graph between agents and the context routing chain.

[0084] In this embodiment, by simultaneously removing all candidate agents participating in the joint simulation elimination from the initial multi-agent set (i.e., the joint elimination set), the initial multi-agent set after the joint simulation elimination is completed can be obtained. This can be denoted as the pruning structure or the formal multi-agent set for the current round. .

[0085] Furthermore, the effective inference topology structure is reconstructed for the agents corresponding to the pruning structure of the current round, including: updating the task input allocation matrix, adjusting the dependency graph between agents, reconstructing the context routing chain, and rearranging the thread strategy for parallel execution of multiple agents.

[0086] The second step involves executing the complete task flow by tailoring the structure and calculating the overall system performance to obtain the corresponding joint simulation system performance index. The joint performance degradation between the baseline system performance index and the joint simulation system performance index is then calculated.

[0087] In this embodiment, the joint performance degradation is calculated by calculating the difference between the baseline system performance index and the joint simulation system performance index to obtain the joint performance degradation; wherein, the joint simulation system performance index refers to the system performance index of the formal multi-agent set obtained after performing joint simulation elimination on the initial multi-agent set.

[0088] As an example, the expression for the performance index of a joint simulation system can be: In the formula, This represents the performance index of the joint simulation system in the current round t.

[0089] As an example, the expression for the combined performance degradation can be: In the formula, This indicates the combined performance reduction.

[0090] The third step is to determine the final system performance and the final multi-agent set for the current round by comparing the joint performance degradation and performance tolerance.

[0091] If the joint performance degradation is not greater than the performance tolerance, the current pruning structure is confirmed to be effective, the joint simulation system performance index is taken as the final system performance of the current round, and the pruning structure is taken as the final multi-agent set.

[0092] If the joint performance degradation exceeds the performance tolerance, a step-by-step recall mechanism is triggered: To ensure that each recall operation restores the most critical structural components for performance as much as possible, thereby reducing unnecessary system fluctuations, the context snapshots, historical inference state caches, and task interface configurations (including input channel mappings, inference depth parameters, API call templates, and intermediate product dependencies) of the candidates to be removed are read sequentially according to the normalized contribution weights of the agents in the joint removal set from high to low. They are then restored from the frozen state to the active state and connected to the inference topology. For each candidate agent recalled (i.e., the multi-agent set is recalled), the system performance index after recall (i.e., the recall system performance index) and its recall performance degradation relative to the baseline system performance index are recalculated until the current recall performance degradation is no greater than the performance tolerance, at which point the recall stops, and the final system performance and the final multi-agent set for the current round are obtained.

[0093] For example, for any recall, after the recall of candidate agents is completed, a new formal multi-agent set can be generated, denoted as the recall multi-agent set, whose expression can be: In the formula, This represents the formal set of multiple agents after the recall candidate agent k corresponding to the current round t, i.e., the recall multiple agent set.

[0094] Perform a single-alignment performance review process on the recalled multi-agent set to obtain the recall system performance index, which can be expressed as: In the formula, This represents the performance metrics of a recall system that recalls a set of multiple agents.

[0095] If satisfied If the current performance degradation is not greater than the performance tolerance, it means that the performance of this round of recall has been successfully restored to the tolerance range, and the recall process can be terminated and the current agent structure configuration can be accepted as the final multi-agent set; otherwise, if the performance still does not meet the standard, the same recovery process will continue to be performed on the next candidate agent according to the priority of normalized contribution weight, until the performance degradation value returns to the tolerance range, that is, less than or equal to the performance tolerance.

[0096] It should be noted that the recalled and recovered candidate agents do not need to be reinitialized, nor do they change the already formed context semantic sequence. Instead, they are reconnected to the system inference graph in a completely uninterrupted manner.

[0097] In this embodiment, the recall performance degradation is calculated as follows: the difference between the baseline system performance index and the recall system performance index is calculated to obtain the recall performance degradation; wherein, the recall system performance index refers to the system performance index of the recalled multi-agent set after performing candidate agent recall on the multi-agent set after joint simulation elimination.

[0098] Thus, this embodiment has obtained the final system performance and the final multi-agent set for the current round.

[0099] Step S5: Calculate the performance improvement between the final system performance index and the reference system performance index of the previous round; for each agent in the final multi-agent set, update the scheduling weight of each agent using the normalized contribution weight, the sign attribute of the marginal contribution, and the performance improvement.

[0100] Here, scheduling weights not only affect the relative importance of agents participating in reasoning, but also the frequency of API calls, input allocation ratio, context splicing priority, and convergence strength when integrating results.

[0101] In multi-agent systems, the marginal contribution (Shapley value) of each agent reflects its relative importance in the current task environment, while the final improvement in system performance relative to the previous round reflects the macroscopic effect of the overall system optimization. Relying solely on normalized contribution weights for weight updates can easily lead the system into local optima, ignoring the risk that overall performance may not actually improve; while relying solely on the overall performance improvement cannot accurately quantify the individual contribution of each agent.

[0102] Therefore, to achieve the co-evolution of micro-level contributions and macro-level effects, this embodiment constructs an update mechanism based on joint feedback of marginal contributions and performance. A global evaluation dimension is introduced by calculating the performance improvement between the final system performance index and the reference system performance index from the previous round. Furthermore, for each agent in the final multi-agent set, a baseline update magnitude is established based on its normalized contribution weight, the positive or negative sign attribute of its marginal contribution determines the reward / penalty direction of the update, and the update step size is dynamically adjusted based on the performance improvement. By updating the scheduling weights, it can be ensured that when the overall system performance improves, agents with significant positive contributions are prioritized for reinforcement, while negative contribution nodes are promptly suppressed when performance declines or fluctuates. This drives the scheduling weights of each agent to converge towards the optimal resource allocation strategy in multiple iterations.

[0103] As an exemplary implementation, at the end of each iteration, the final system performance index of the current round, the reference system performance index of the previous round, and the normalized contribution weights and original marginal contribution amounts of each agent in step S2 are extracted from the cache, and the weights are updated according to the following steps: The first step is to calculate the global performance improvement.

[0104] Here, the performance improvement can be used as a global feedback metric for the scheduling weight update in the current round.

[0105] In this embodiment, if the current round is the first iteration, the reference system performance index of the previous round is the initial system performance index obtained when initializing the initial multi-agent set; if the current round is not the first iteration, the reference system performance index of the previous round is the final system performance index of the round before the current round; the difference between the final system performance index of the current round and the reference system performance index is calculated to obtain the performance improvement amount.

[0106] As an example, if the current round is not the first iteration, the formula for calculating the performance improvement can be: In the formula, This indicates the amount of performance improvement in the current round. This represents the reference system performance index of the previous round, which is the final system performance index of the round before the current round.

[0107] The second step, based on the mechanism of local contribution guidance and global performance modulation of the scheduling weights of each agent, calculates the scheduling weights of each agent in the final multi-agent set for the next round after the current round, including: The first sub-step is to obtain the contribution learning rate and performance feedback modulation coefficients of each agent in the final multi-agent set.

[0108] In this embodiment, by obtaining the contribution learning rate and performance feedback modulation coefficient, the degree of intervention of individual local contribution and system global benefit on weight update can be quantified and balanced, preventing the weight from oscillating violently due to single-round extreme values, thereby ensuring the stability of iterative convergence.

[0109] The second sub-step involves determining the first weight update component based on the contribution learning rate and the normalized contribution weight.

[0110] In this embodiment, the product of the contribution learning rate and the normalized contribution weight is calculated and used as the first weight update component.

[0111] The third sub-step involves determining the second weight update component based on the performance feedback modulation coefficient, performance improvement amount, and the sign attribute of the marginal contribution.

[0112] Here, the sign attribute includes positive and negative.

[0113] In this embodiment, the product of the performance feedback modulation coefficient, the performance improvement amount, and the sign attribute of the marginal contribution is calculated and used as the second weight update component.

[0114] The fourth sub-step involves superimposing the first weight update component and the second weight update component to obtain the weight update amount of each agent in the final multi-agent set in the current round.

[0115] The fifth sub-step involves updating the scheduling weights of each agent in the final multi-agent set for the current round based on the weight update amount, thereby obtaining the scheduling weights of each agent in the final multi-agent set for the next round.

[0116] As an example, the formula for calculating the agent's scheduling weight in the next round can be: In the formula, This indicates the scheduling weight of agent i in the next round. This represents the scheduling weight of agent i in the current round. This represents the preset contribution learning rate (e.g., 0.01), used to maintain the long-term guidance of the Shapley value on the weights. This represents the preset performance feedback modulation coefficient (e.g., 0.05), used to dynamically adjust the weight step size based on global performance fluctuations. The sign function is used to maintain the consistency between the modulation direction and the agent's marginal contribution. It is incremented by 1 when agent i makes a positive marginal contribution in the current round and decremented by 1 when it makes a negative marginal contribution.

[0117] After updating the scheduling weights of each agent, the following is also included: The first step is to perform a lower bound truncation on the updated scheduling weights, limiting the scheduling weights below the preset minimum threshold to the preset minimum threshold, thereby obtaining the target scheduling weights for each agent.

[0118] The second step is to normalize the target scheduling weights and apply the normalized scheduling weights to the next round of iterative optimization.

[0119] In this embodiment, to prevent structural instability or sudden changes in API call behavior caused by fluctuations in the Shapley distribution, which could lead to negative values ​​or numerical explosions in the weights during accumulation, the updated weights are first protected by a limiting mechanism: In the formula, This represents a preset minimum positive number (such as 0.01).

[0120] Secondly, the updated weights of each agent in the final multi-agent set are normalized to obtain the normalized scheduling weights of each agent in the next round, so as to form a stable cooperative distribution. The calculation formula can be: In the formula, This represents the normalized scheduling weight of the agent in the next round. This indicates the scheduling weight of agent j in the next round.

[0121] After updating the scheduling weights of each agent in the final multi-agent set, this embodiment can reconfigure the task routing ratio, API call frequency limit, and context aggregation priority for the next round based on the new weights, and store the weight vector in the state matrix to enter the next round of optimization loop.

[0122] Thus, after multiple rounds of iterative execution of the aforementioned contribution evaluation based on Shapley values, reversible Dropout adjustment, and two-factor scheduling weight update process, this embodiment ultimately converges to a stable agent scheduling weight distribution and optimal cooperative topology, outputting task results with globally optimal performance. This iterative optimization mechanism, through rigorous individual marginal contribution modeling and joint modulation of system-level performance feedback, not only achieves adaptive and efficient allocation of multi-agent network computing resources in heterogeneous large language model collaborative reasoning tasks, but also establishes a highly statistically interpretable agent selection and dynamic elimination mechanism.

[0123] Another embodiment of the present invention provides a multi-agent cooperative optimization system, including a processor and a memory, wherein the processor is used to process instructions stored in the memory to implement the multi-agent cooperative optimization method described above.

[0124] The above-described embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

Claims

1. A multi-agent cooperative optimization method, characterized in that, Includes the following steps: Step S1: Obtain the scheduling weight of each agent in the initial multi-agent set in the current round; Step S2: Assign tasks to each agent according to the scheduling weight and execute them; evaluate the baseline system performance index of the current round based on the task execution accuracy and resource overhead index; calculate the marginal contribution of each agent by traversing the initial multi-agent set, and then determine the normalized contribution weight of each agent in the current round based on the marginal contribution. Step S3: Add agents whose normalized contribution weight is lower than a preset contribution threshold to the candidate elimination set. Each candidate agent in the candidate elimination set is traversed sequentially. A single-point simulated elimination operation is performed on the current candidate agent and the system performance is re-evaluated. If the single performance drop between the benchmark system performance index and the simulated system performance index is not greater than the preset performance tolerance, the current candidate agent participates in the joint simulated elimination. Step S4: Calculate the joint performance reduction after joint simulation elimination. If the joint performance reduction is greater than the performance tolerance, recall the eliminated candidate agents one by one in the order of the normalized contribution weight from high to low and calculate the recall performance reduction until the current recall performance reduction is not greater than the performance tolerance, and obtain the final system performance and the final multi-agent set for the current round. Step S5: Calculate the performance improvement between the final system performance index and the reference system performance index of the previous round; For each agent in the final multi-agent set, the scheduling weight of each agent is updated using the normalized contribution weight, the sign attribute of the marginal contribution, and the performance improvement amount. The step of updating the scheduling weights of each agent using the normalized contribution weights, the sign attribute of the marginal contribution, and the performance improvement amount includes: Obtain the contribution learning rate and performance feedback modulation coefficient of each agent in the final multi-agent set, and calculate the product of the contribution learning rate and the normalized contribution weight as the first weight update component. The product of the performance feedback adjustment coefficient, the performance improvement amount, and the sign attribute of the marginal contribution is calculated and used as the second weight update component. The sign attribute includes positive and negative. The first weight update component and the second weight update component are superimposed to obtain the weight update amount of each agent in the final multi-agent set in the current round; The scheduling weights of each agent in the final multi-agent set are updated in the current round based on the weight update amount, so as to obtain the scheduling weights of each agent in the final multi-agent set in the next round.

2. The multi-agent cooperative optimization method according to claim 1, characterized in that, The process of allocating and executing tasks to each agent according to the scheduling weights, and evaluating the baseline system performance metrics for the current round based on task execution accuracy and resource overhead metrics, includes: Based on the scheduling weight, task information is assigned to each agent in the initial multi-agent set and parallel execution is triggered to obtain the overall execution output and actual resource consumption. The overall execution output is scored based on preset evaluation criteria to obtain the task execution accuracy. The resource expenditure index is obtained based on the actual resource consumption; wherein the resource expenditure index is negatively correlated with the actual resource consumption. Using preset evaluation fusion weights, the task execution accuracy and the resource overhead index are weighted and summed to obtain the baseline system performance index for the current round.

3. The multi-agent cooperative optimization method according to claim 2, characterized in that, The step of calculating the marginal contribution of each agent by traversing the initial multi-agent set includes: For each target agent in the initial multi-agent set, at least one first combined state containing the target agent is determined, and a second combined state corresponding to the first combined state after removing the target agent is determined. The system performance scores of the first combined state and the second combined state when performing tasks are evaluated respectively, and the performance difference between the two is calculated; wherein, when the first combined state contains the complete initial multi-agent set of the current round, the benchmark system performance index is used as the system performance score of the first combined state. Based on the number of calculated performance differences, determine the marginal contribution corresponding to the target agent: When the number of performance differences is equal to 1, the performance difference is directly used as the marginal contribution; when the number of performance differences is greater than 1, the marginal contribution is obtained by performing aggregation processing on multiple performance differences.

4. The multi-agent cooperative optimization method according to claim 3, characterized in that, The process of determining the normalized contribution weight of each agent in the current round based on the marginal contribution includes: For any agent in the initial multi-agent set, obtain the agent's historical contribution value in the previous round; wherein, in the first round, the historical contribution value is the initial scheduling weight pre-assigned to the agent; Using a preset smoothing coefficient, the historical contribution value and the marginal contribution of the agent in the current round are weighted and summed to calculate the dynamic smoothed contribution value of the agent in the current round. Calculate the sum of the dynamic smoothing contribution values ​​of all agents in the initial multi-agent set; Divide the dynamic smoothed contribution value of any agent by the absolute value of the sum to obtain the normalized contribution weight of the agent in the current round.

5. The multi-agent cooperative optimization method according to claim 1, characterized in that, The preset contribution threshold is determined in the following ways: Obtain the preset reversible Dropout threshold coefficient; The theoretical average weight is calculated based on the number of agents in the initial multi-agent set. The contribution threshold is obtained by multiplying the theoretical average weight by the reversible Dropout threshold coefficient.

6. The multi-agent cooperative optimization method according to claim 1, characterized in that, The step of sequentially traversing each candidate agent in the candidate elimination set, performing a single-point simulated elimination operation on the current candidate agent, and re-evaluating system performance includes: Take any candidate agent in the candidate elimination set as the current candidate agent, and eliminate the current candidate agent from the initial multi-agent set in single-point simulation to obtain the simulated agent set; The system performance of the simulated agent set is evaluated to obtain the simulated system performance index corresponding to the current candidate agent.

7. The multi-agent cooperative optimization method according to claim 6, characterized in that, The single performance degradation is calculated by: calculating the difference between the performance index of the benchmark system and the performance index of the simulated system to obtain the single performance degradation; The joint performance degradation is calculated as follows: the difference between the baseline system performance index and the joint simulation system performance index is calculated to obtain the joint performance degradation; wherein, the joint simulation system performance index refers to the system performance index of the formal multi-agent set obtained after performing joint simulation elimination on the initial multi-agent set; The recall performance degradation is calculated as follows: the difference between the baseline system performance index and the recall system performance index is calculated to obtain the recall performance degradation; wherein, the recall system performance index refers to the system performance index of the recalled multi-agent set after performing candidate agent recall on the multi-agent set after joint simulation elimination.

8. The multi-agent cooperative optimization method according to claim 1, characterized in that, The calculation of the performance improvement between the final system performance index and the reference system performance index of the previous round includes: If the current round is the first iteration, then the reference system performance index of the previous round is the initial system performance index obtained when initializing the initial multi-agent set; If the current round is not the first iteration, then the reference system performance index of the previous round is the final system performance index of the round before the current round; The difference between the final system performance index and the reference system performance index in the current round is calculated to obtain the performance improvement amount.

9. A multi-agent cooperative optimization system, characterized in that, It includes a processor and a memory, the processor being used to process instructions stored in the memory to implement a multi-agent cooperative optimization method as described in any one of claims 1-8.

Images