Multi-agent based distributed task dynamic disassembly method and system

Abstract

The application relates to the technical field of data processing, and discloses a multi-agent-based distributed task dynamic disassembly method and system. The method comprises the following steps: disassembling a total task into subtasks, and generating a complexity vector according to the resource requirement characteristics of the subtasks; perceiving the real-time resource state of the subtasks in an edge computing node, and generating a multi-dimensional resource state vector according to the real-time resource state; calculating a matching degree by a task agent according to the received multi-dimensional resource state vector; initiating direct negotiation between the task agent and a resource agent based on the matching degree to determine the resource agent; forming an autonomous task group between the task agent and the resource agent, and executing the subtasks in the autonomous task group; when an execution exception is monitored, triggering a new round of negotiation for the affected subtasks, and reorganizing the autonomous task group, and executing the subtasks according to the reorganized autonomous task group; and the application can improve the efficiency of multi-agent-based distributed task dynamic disassembly.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and in particular to a method and system for dynamic decomposition of distributed tasks based on multiple agents. Background Technology

[0002] Traditional distributed task decomposition methods often adopt a static partitioning model, which does not fully incorporate the real-time resource fluctuation characteristics of edge computing nodes for dynamic adaptation. The decomposition process of subtasks often ignores the precise matching of resource demand and node supply, resulting in some subtasks being assigned to nodes with insufficient resources, or nodes with sufficient resources not being fully utilized, which significantly reduces the overall task execution efficiency and makes it difficult to cope with the diverse resource requirements in complex tasks.

[0003] Existing multi-agent collaboration mechanisms lack efficient anomaly response and dynamic reorganization capabilities during task execution. When edge computing nodes experience abnormal situations such as resource fluctuations or task execution failures, they cannot quickly trigger targeted negotiation and adjustment of collaboration relationships, resulting in prolonged execution interruption time for affected subtasks. Furthermore, the negotiation process between agents often contains redundant steps, further restricting the overall flexibility and reliability of distributed task decomposition and execution. Summary of the Invention

[0004] This invention provides a distributed task dynamic decomposition method and system based on multi-agent systems to solve the problems mentioned in the background art.

[0005] To achieve the above objectives, the present invention provides a distributed task dynamic decomposition method based on multi-agent systems, comprising:

[0006] S1: Decompose the total task into subtasks, and generate the complexity vector of the subtasks based on their resource requirements.

[0007] S2: Perceive the real-time resource status of the subtask on the edge computing node, and generate a multi-dimensional resource status vector that matches the dimension of the complexity vector based on the real-time resource status.

[0008] S3: The task agent calculates the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the received multidimensional resource state vector;

[0009] S4: Based on the matching degree, initiate direct negotiation between the task agent and the resource agent to determine the resource agent corresponding to the subtask;

[0010] S5: Form an autonomous task group between the task agent and the resource agent, and execute the sub-task in the autonomous task group;

[0011] S6: When an execution anomaly is detected, a new round of negotiation is triggered for the affected subtasks, and the autonomous task group is reorganized. The subtasks are then executed according to the reorganized autonomous task group.

[0012] In a preferred embodiment, the step of decomposing the total task into subtasks and generating a complexity vector for each subtask based on its resource requirement characteristics includes:

[0013] Construct the task dependency graph of the overall task based on the logical dependencies in the overall task;

[0014] Based on the node division in the task dependency graph, the total task is broken down into sub-tasks;

[0015] The original characteristic parameters of the subtask are obtained by analyzing the type of computation required for the execution of the subtask, the expected data size to be processed, and the output size of the result.

[0016] Based on a preset vector dimension mapping rule, the original feature parameters are assembled into the complexity vector of the subtask.

[0017] In a preferred embodiment, sensing the real-time resource status of the subtask on the edge computing node includes:

[0018] The resource intelligence agent determines the types of local resources that need to be monitored based on a pre-set list of resource types to be sensed.

[0019] Based on the system performance counters and kernel status interfaces of the edge computing nodes corresponding to the resource agents, collect the raw monitoring data corresponding to the resource categories.

[0020] The original monitoring data is filtered for noise to obtain the resource indicators of the subtask;

[0021] The resource indicators are encapsulated according to their corresponding resource categories to obtain the real-time resource status of the edge computing node.

[0022] In a preferred embodiment, generating a multidimensional resource state vector that matches the dimension of the complexity vector based on the real-time resource state includes:

[0023] The resource agent extracts resource indicators corresponding to computing power, memory capacity, network bandwidth, and availability of dedicated hardware units from the real-time resource status.

[0024] Based on the characteristics of the resource indicators, the resource indicators are converted into dimensionless scalar values.

[0025] The scalar values ​​are arranged sequentially according to the order of the dimensions of the complexity vector;

[0026] The arranged scalar numerical sequence is encapsulated into a fixed-dimensional data structure to obtain a multi-dimensional resource state vector that matches the dimension of the complexity vector.

[0027] In a preferred embodiment, the task agent calculates the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the received multidimensional resource state vector, including:

[0028] Align the dimension of the complexity vector with the corresponding dimension of the multidimensional resource state vector using feature alignment.

[0029] The matching degree component of the alignment dimension is calculated based on the eigenvalues ​​of the alignment dimension in the complexity vector and the eigenvalues ​​of the multidimensional resource state vector.

[0030] By combining the matching degree components of all dimensions, the matching degree between the complexity vector and the multidimensional resource state vector is generated.

[0031] In a preferred embodiment, the formula for calculating the matching degree component is as follows:

[0032] ;

[0033] In the formula, For the matching degree component, It is a natural constant. For dimension The preset tolerance coefficient for resource supply and demand differences, For the subtask in dimension Resource demand characteristic values ​​on For the edge computing node in the current dimension Resource supply characteristic value on, This is the preset normalization benchmark factor.

[0034] In a preferred embodiment, the step of initiating direct negotiation between the task agent and the resource agent based on the matching degree to determine the resource agent corresponding to the sub-task includes:

[0035] Candidate resource agents with a matching degree higher than a preset threshold are selected for the subtask;

[0036] The task agent sends a negotiation request to the candidate resource agent;

[0037] Upon receiving the negotiation request, the candidate resource agent makes a local acceptance decision based on the currently maintained set of real-time resource states and a preset acceptance strategy, and generates the negotiation response of the candidate resource agent.

[0038] The candidate resource agent feeds back the negotiation response to the task agent via point-to-point communication.

[0039] Based on the received negotiation response, the task agent selects one of the candidate resource agents that have provided a feedback agreement response as the resource agent for final execution for the subtask.

[0040] In a preferred embodiment, forming an autonomous task group between the task agent and the resource agent, and executing the sub-task within the autonomous task group, includes:

[0041] The task agent integrates the complexity vector, execution objective, and constraints of the sub-task into a core task information set, sends it to the determined resource agent, and simultaneously receives its own processing capability description and adaptation suggestions from the resource agent, thus obtaining a two-way information interaction record of the task agent.

[0042] Based on the bidirectional information interaction record, the task agent and the resource agent negotiate together to obtain an intra-group collaboration protocol between the task agent and the resource agent.

[0043] Based on the intra-group collaboration protocol, a logical interaction link between intelligent agents is constructed, and the link connectivity confirmation result between the task intelligent agent and the resource intelligent agent is obtained;

[0044] The task agent, based on the execution logic of the subtask and the processing capability of the resource agent, breaks down the subtask into a series of processing steps, allocates corresponding processing steps and associated data to the resource agent, and obtains the step allocation scheme of the resource agent.

[0045] The resource agent performs task processing for the corresponding processing stage according to the stage allocation scheme and the group collaboration protocol.

[0046] In a preferred embodiment, the step of triggering a new round of negotiation for the affected subtasks when an execution anomaly is detected, reorganizing the autonomous task group, and executing the subtasks according to the reorganized autonomous task group includes:

[0047] The task agent captures abnormal behavior and its impact range to obtain an explanation of the abnormal situation of the subtask.

[0048] Based on the above description of the abnormal situation, a new round of negotiation is triggered, and the agents associated with the affected subtasks are notified to exchange their current adaptation states, thereby obtaining a summary of the negotiation information of the agents.

[0049] Based on the summarized negotiation information, the appropriate resource agents are re-determined, the cooperation relationships are adjusted, and the autonomous task group reorganization scheme of the sub-tasks is obtained.

[0050] A new autonomous task group will be formed in accordance with the aforementioned autonomous task group reorganization plan, and the execution requirements of the unfinished parts of the sub-tasks will be synchronized to promote the subsequent execution of the sub-tasks.

[0051] To address the above problems, this invention also provides a distributed task dynamic decomposition system based on multi-agent systems, the system comprising:

[0052] The task decomposition and feature extraction module is used to decompose the total task into subtasks and generate the complexity vector of the subtasks based on the resource requirement characteristics of the subtasks.

[0053] The resource status awareness module is used to sense the real-time resource status of the subtask on the edge computing node, and generate a multi-dimensional resource status vector that matches the dimension of the complexity vector based on the real-time resource status.

[0054] The task resource matching degree calculation module is used by the task agent to calculate the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the multiple multidimensional resource state vectors received.

[0055] The agent negotiation and decision-making module is used to initiate direct negotiation between the task agent and the resource agent based on the matching degree, so as to determine the resource agent corresponding to the subtask.

[0056] An autonomous task group execution and coordination module is used to form an autonomous task group between the task agent and the resource agent, and to execute the sub-tasks in the autonomous task group.

[0057] The exception handling and dynamic reorganization module is used to trigger a new round of negotiation for the affected subtasks when an execution exception is detected, reorganize the autonomous task group, and execute the subtasks according to the reorganized autonomous task group.

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

[0059] 1. This invention generates subtask complexity vectors and multi-dimensional resource state vectors for edge computing nodes to accurately calculate the supply-demand matching degree. Then, through direct negotiation between agents, suitable resource agents are determined, forming autonomous task groups for targeted execution. This model avoids resource mismatch and redundant negotiation, allowing subtask allocation to better match node capabilities, significantly improving the dynamic decomposition and overall execution efficiency of distributed tasks.

[0060] 2. This invention, by setting up an anomaly triggering mechanism and an autonomous task group reorganization process, detects execution anomalies and quickly initiates a new round of negotiation for the affected subtasks, re-adapting resource agents and adjusting collaborative relationships. This approach can quickly mitigate the impact of node resource fluctuations and execution failures, reduce task interruption time, and ensure the stability and continuity of distributed task execution. Attached Figure Description

[0061] Figure 1 This is a flowchart illustrating a distributed task dynamic decomposition method based on multiple agents provided in an embodiment of the present invention.

[0062] Figure 2 This is a functional block diagram of a distributed task dynamic decomposition system based on multiple agents provided in an embodiment of the present invention;

[0063] The realization of the objective, functional features and advantages of the present invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0064] It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

[0065] This application provides a method for dynamically decomposing distributed tasks based on multi-agent mechanisms. The executing entity of this method includes, but is not limited to, at least one of the following electronic devices that can be configured to execute the method provided in this application: a server, a terminal, etc. In other words, the method can be executed by software or hardware installed on a terminal device or a server device. The server includes, but is not limited to, a single server, a server cluster, a cloud server, or a cluster of cloud servers. The server can be an independent server or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, content delivery networks (CDNs), and big data and artificial intelligence platforms.

[0066] Reference Figure 1 The diagram shown is a flowchart illustrating a multi-agent-based distributed task dynamic decomposition method according to an embodiment of the present invention. In this embodiment, the multi-agent-based distributed task dynamic decomposition method includes:

[0067] S1: Decompose the total task into subtasks, and generate the complexity vector of the subtasks based on their resource requirements.

[0068] In this embodiment of the invention, the step of decomposing the total task into subtasks and generating a complexity vector for each subtask based on its resource requirement characteristics includes:

[0069] Construct the task dependency graph of the overall task based on the logical dependencies in the overall task;

[0070] Based on the node division in the task dependency graph, the total task is broken down into sub-tasks;

[0071] The original characteristic parameters of the subtask are obtained by analyzing the type of computation required for the execution of the subtask, the expected data size to be processed, and the output size of the result.

[0072] Based on a preset vector dimension mapping rule, the original feature parameters are assembled into the complexity vector of the subtask.

[0073] When constructing the task dependency graph for the overall task, it is necessary to first comprehensively analyze the core objectives of the overall task and all the final results required to achieve these objectives, clarify the business scope and key requirements to be covered during execution, and then identify each independent operation step involved in the execution process. Each step has a clear execution subject and specific execution content. Subsequently, for each operation step, the input content that must be obtained before its execution is analyzed in detail, including the required raw data, the results of previous operations, and all other necessary information. At the same time, the output content generated after execution is also clearly defined, covering intermediate results, data files, or decision conclusions. By comparing the input and output content of all operation steps, the connection relationship between different steps is determined. If the output of one step happens to be the input of another step, it is determined that there is a logical dependency relationship between the two, and the former step must be completed before the latter step, and a dependency association record is established. Each independent operation step is treated as a node in the task dependency graph, with the step name clearly labeled. Dependency associations are used as the connecting lines between corresponding nodes, and the node positions are arranged reasonably according to the actual logical execution order, ensuring that dependent nodes are distributed in a "preceding before subsequent" manner to avoid logical confusion. Finally, the initial drawing is fully verified to check for any missing operation steps or unlabeled dependencies. This ensures that each node corresponds to a clear operation step, each connection accurately reflects the dependency relationship, and there are no redundant or incorrect connections. Ultimately, a complete and accurate overall task dependency diagram is formed, which can intuitively present the execution order and interdependencies of all operation steps.

[0074] When dividing the overall task into subtasks based on nodes in the task dependency graph, the constructed task dependency graph must be used as the sole basis. The functional attributes of each node's corresponding operational steps must be analyzed one by one to clarify its sub-goals. Simultaneously, execution boundaries must be defined to determine whether real-time interaction or data sharing with other nodes' operational steps is necessary. If the operational steps of multiple adjacent nodes jointly serve a specific sub-goal, and the execution process is tightly linked and inseparable, with no single step alone capable of achieving the goal, then collaborative execution is required, and these nodes should be merged into a single subtask unit. If an operational step of a node has an independent execution goal, does not depend on the real-time results of other steps, and can independently complete the goal through its own complete input-output process, and the execution result does not affect other steps, then this node should be treated as a separate subtask unit. When dividing the task, the nodes are arranged in the logical order of the task dependency graph, starting from the first node and classifying all nodes sequentially to ensure no omissions or duplications. At the same time, the execution content, input requirements, and output results of each subtask unit are clearly defined. The execution content must describe all the operation steps and execution order, the input requirements must specify all the data and information that must be obtained before execution, and the output results must specify the specific results produced after execution. This ensures that each subtask unit has independent execution conditions and clear execution standards. Finally, the divided subtasks are obtained. The set of all subtasks completely covers all the execution content of the total task, and the logical relationships between the subtasks are consistent with the dependency relationships of the nodes in the task dependency graph.

[0075] When analyzing the types of computations required for subtask execution, the expected scale of data to be processed, and the scale of output results to obtain the original feature parameters, it is necessary to observe the execution process of the subtask for each computation type and clarify the nature of the core operations required to achieve the goal: if the core operation is to organize, classify, filter, or sort various types of received information, without involving the derivation of new conclusions or the generation of new data, it is determined to be an information organization type; if it requires comparing, summarizing, and concluding multiple sets of data or information to extract common features or differences to form a comprehensive conclusion, it is determined to be a data induction type; if it requires logical reasoning, judgment, or decision-making based on known conditions, rules, or constraints to deduce the execution path or result that meets the conditions, it is determined to be a logical reasoning type, ensuring that the judgment of the computation type is consistent with the actual execution operation. When analyzing the expected data scale, a comprehensive review of all data sources that the subtask needs to receive and process is conducted, including the original data providers and the outputs of previous subtasks. The specific data content of each source is clearly defined, the number of all data entries is counted, and the information dimensions of each data entry are analyzed. The overall volume is determined by the data presentation format; fewer data entries and simpler information dimensions indicate a smaller scale, while more entries or richer dimensions indicate a larger scale, ensuring the analysis aligns with actual processing needs. When analyzing the output scale, based on the subtask's execution objectives and expected output, the specific presentation format of the output results is defined. The number of information entries is counted, and the level of detail for each entry is analyzed. Fewer entries and lower detail indicate a smaller scale, while more entries or higher detail indicate a larger scale, ensuring the analysis matches actual output. Finally, the calculation type, expected data scale, and output scale are integrated to form the subtask's unique original characteristic parameters. Each piece of information accurately reflects the actual situation without bias or omission.

[0076] When assembling the original feature parameters into a complexity vector for a subtask according to a pre-defined vector dimension mapping rule, this mapping rule is a fixed correspondence set in advance. It specifies that each dimension of the original feature parameters corresponds to a unique dimension position in the complexity vector. The first dimension carries computation type information, the second dimension carries the expected data scale information, and the third dimension carries the output scale information. Each dimension position has a clearly defined information carrying purpose, avoiding dimension confusion. The assembly operation then proceeds. Computation type information is extracted from the original feature parameters, and the specific description is accurately and completely filled into the first dimension position of the complexity vector according to the mapping rule, ensuring consistency with the original information without modification. Next, the expected data scale information is extracted and filled into the second dimension position, ensuring completeness and accuracy. Finally, the output scale information is extracted and filled into the third dimension position, maintaining consistency with the original content. During the assembly process, the content entered for each dimension is verified one by one to check for any missing information, description errors, or incorrect dimension correspondences. Problems are corrected in a timely manner to ensure that each dimension accurately carries the corresponding original feature parameter information. After all dimension information is entered, a complexity vector specific to the subtask is formed. This vector comprehensively and accurately reflects the characteristics of the subtask in terms of computation type, data processing scale, and result output scale, providing a complete and reliable basis for subsequent subtask complexity evaluation.

[0077] The beneficial effects are as follows: by clearly outlining the logical dependencies of the overall task and constructing a task dependency graph, the scientific and rational decomposition of the overall task is ensured. The decomposed subtasks have clear execution boundaries and independent execution conditions, effectively reducing the execution difficulty of the overall task. By comprehensively analyzing the computation type, data processing scale, and output scale of the subtasks, the original feature parameters are obtained, and the complexity vector is assembled based on fixed mapping rules, so that the complexity characteristics of the subtasks are accurately quantified. This provides a reliable basis for subsequent resource allocation and execution order optimization of subtasks. The overall process is logically rigorous and the operation is standardized, which can effectively improve the execution efficiency and management level of the overall task.

[0078] S2: Perceive the real-time resource status of the subtask on the edge computing node, and generate a multi-dimensional resource status vector that matches the dimension of the complexity vector based on the real-time resource status.

[0079] In this embodiment of the invention, sensing the real-time resource status of the subtask on the edge computing node includes:

[0080] The resource intelligence agent determines the types of local resources that need to be monitored based on a pre-set list of resource types to be sensed.

[0081] Based on the system performance counters and kernel status interfaces of the edge computing nodes corresponding to the resource agents, collect the raw monitoring data corresponding to the resource categories.

[0082] The original monitoring data is filtered for noise to obtain the resource indicators of the subtask;

[0083] The resource indicators are encapsulated according to their corresponding resource categories to obtain the real-time resource status of the edge computing node.

[0084] The step of generating a multi-dimensional resource state vector that matches the dimension of the complexity vector based on the real-time resource state includes:

[0085] The resource agent extracts resource indicators corresponding to computing power, memory capacity, network bandwidth, and availability of dedicated hardware units from the real-time resource status.

[0086] Based on the characteristics of the resource indicators, the resource indicators are converted into dimensionless scalar values.

[0087] The scalar values ​​are arranged sequentially according to the order of the dimensions of the complexity vector;

[0088] The arranged scalar numerical sequence is encapsulated into a fixed-dimensional data structure to obtain a multi-dimensional resource state vector that matches the dimension of the complexity vector.

[0089] Before executing an operation, the resource agent obtains a pre-defined list of resource types to be monitored. This list explicitly includes the names and corresponding attribute descriptions of various local resources that may need to be monitored. The resource agent compares each of the resources actually existing in the local edge computing node with the items in the list to determine which local resources belong to the scope of monitoring specified in the list. For resources that are explicitly listed in the list and actually exist locally, they are directly classified as the local resource categories to be monitored. Resources that are not mentioned in the list or do not exist locally are excluded from the monitoring scope, thus accurately determining the local resource categories to be monitored.

[0090] After identifying the local resource categories to be monitored, the resource agent calls the system performance counter and kernel status interface of the corresponding edge computing node for each resource category. The system performance counter can continuously record real-time data related to the operation of various resources, including basic information such as resource occupancy and operating load. The kernel status interface can directly obtain the underlying operating status information of the resource at the operating system kernel level, covering details such as process scheduling and data transmission status. Through these two methods, the resource agent comprehensively extracts all data directly related to each resource category to be monitored. This raw data without any processing is the raw monitoring data corresponding to the resource category.

[0091] After acquiring the raw monitoring data, noise filtering is required. The specific process of noise filtering is to first identify abnormal data in the raw monitoring data that is unrelated to the actual operating status of the resources. These abnormal data are mainly manifested as values ​​that suddenly appear beyond the normal operating fluctuation range of the resources, isolated data that have no logical connection with the preceding and following data, and invalid data generated by signal interference during the data acquisition process. For such identified abnormal data, a direct rejection method is adopted to process them, without retaining any interference data that may affect the judgment of resource status, ensuring that the remaining data can truly and accurately reflect the actual operating status of the resources. The regular and effective data obtained after this filtering process is the resource indicator.

[0092] After acquiring the resource metrics, all resource metrics are categorized and organized according to the previously determined local resource categories to be monitored. For each resource category, all resource metrics corresponding to that category are centrally summarized and arranged in an orderly manner according to a unified format. At the same time, the resource category information to which each metric belongs is clearly marked next to it to avoid confusion between metrics of different resource categories. This ensures that all operational status data of each resource category are centralized and clearly traceable. Through this method of classification, summarization and standardized organization, all resource metrics are encapsulated into a complete and systematic data set, which is the real-time resource status of the edge computing node.

[0093] The resource agent first acquires the real-time resource status of the encapsulated edge computing nodes. This real-time resource status includes all resource indicators organized by category. By identifying the classification tags in the real-time resource status corresponding to computing power, memory capacity, network bandwidth, and dedicated hardware unit availability, the resource agent accurately locates the data set for each target resource category. The resource indicators corresponding to computing power include data reflecting computing performance, such as processor operating efficiency and task processing response speed. The resource indicators corresponding to memory capacity include data reflecting storage capacity, such as occupied memory space and remaining available space. The resource indicators corresponding to network bandwidth include data reflecting network transmission capacity, such as data upload rate, download rate, and transmission latency. The resource indicators corresponding to dedicated hardware unit availability are data related to the operating status of dedicated hardware units and whether they are in an idle and callable state. The resource agent extracts all relevant data from the data set of each target category one by one, and finally obtains the resource indicators corresponding to computing power, memory capacity, network bandwidth, and dedicated hardware unit availability.

[0094] Based on the characteristics of the extracted resource indicators, a dimensionless scalar value conversion is performed. The characteristics of resource indicators are mainly reflected in whether they have specific units and whether the range of numerical variation is fixed. For resource indicators such as computing power, memory capacity, and network bandwidth, which have specific units and a clear range of numerical variation, the actual value of the indicator is compared with the preset maximum reasonable operating value of the indicator, and the ratio of the actual value to the maximum reasonable operating value is taken as the converted scalar value. The ratio value directly reflects the relative level of the indicator. For status-based resource indicators such as the availability of dedicated hardware units, two preset fixed scalar values ​​are used to correspond to different states. When the dedicated hardware unit is in a normal operating and idle state, it is converted to one fixed scalar value. When the dedicated hardware unit is in a faulty or occupied state, it is converted to the other fixed scalar value. In this way, all resource indicators are converted into a unitless pure numerical form, that is, dimensionless scalar values.

[0095] Before arranging the scalar values, the dimensional order of the complexity vector is first defined. This order is predetermined and fixed. The resource indicator type corresponding to each dimension is also defined to ensure a clear and unique correspondence between the dimensional order and the resource indicator. Then, the dimensionless scalar values ​​obtained after conversion are matched one by one with the dimensions of the complexity vector. The corresponding scalar values ​​are arranged in order from the first dimension to the last dimension of the complexity vector. For example, if the first dimension of the complexity vector corresponds to the computing power indicator, the second dimension corresponds to the memory capacity indicator, the third dimension corresponds to the network bandwidth indicator, and the fourth dimension corresponds to the dedicated hardware unit availability indicator, then the scalar value corresponding to the computing power indicator is placed first. Then, the scalar values ​​corresponding to the memory capacity, network bandwidth, and dedicated hardware unit availability are arranged in order to form an ordered sequence of scalar values, ensuring that the position of each scalar value corresponds completely to the dimension of the complexity vector.

[0096] The arranged scalar value sequence is encapsulated. First, a fixed-dimensional data structure is constructed, with the number of dimensions exactly matching the number of dimensions in the complexity vector. Space is reserved in each dimension position to store scalar values. Then, each value in the ordered scalar value sequence is filled into the corresponding dimension position of the data structure one by one in the order of arrangement. Only one scalar value is filled in each dimension position, and no adjustments are made after the value is filled. After filling, the data structure is checked for completeness to confirm that all dimension positions have been accurately filled with the corresponding scalar values, and there are no gaps, duplicates, or misaligned values. After the check is correct, the fixed-dimensional data structure is the multi-dimensional resource state vector that matches the dimension of the complexity vector.

[0097] The beneficial effects include: determining the monitoring resource categories based on a preset list ensures the accuracy of the monitoring scope and avoids interference from irrelevant resources; data collection using system performance counters and kernel status interfaces guarantees the comprehensiveness and authenticity of the original monitoring data; data processing through explicit noise filtering improves the reliability of resource indicators; and encapsulating resource indicators by category to form real-time resource status makes the resource operation status of edge computing nodes clear and intuitive, providing an accurate basis for subsequent resource scheduling and optimization. The overall process is standardized and logically rigorous, effectively ensuring the accuracy and efficiency of resource monitoring.

[0098] S3: The task agent calculates the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the received multidimensional resource state vector;

[0099] In this embodiment of the invention, the task agent calculates the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the received multidimensional resource state vector, including:

[0100] Align the dimension of the complexity vector with the corresponding dimension of the multidimensional resource state vector using feature alignment.

[0101] The matching degree component of the alignment dimension is calculated based on the eigenvalues ​​of the alignment dimension in the complexity vector and the eigenvalues ​​of the multidimensional resource state vector.

[0102] By combining the matching degree components of all dimensions, the matching degree between the complexity vector and the multidimensional resource state vector is generated.

[0103] The formula for calculating the matching degree component is as follows:

[0104] ;

[0105] In the formula, For the matching degree component, It is a natural constant. For dimension The preset tolerance coefficient for resource supply and demand differences, For the subtask in dimension Resource demand characteristic values ​​on For the edge computing node in the current dimension Resource supply characteristic value on, This is the preset normalization benchmark factor.

[0106] The matching degree component is derived from the calculation of the resource demand feature values ​​of the subtasks and the resource supply feature values ​​of the edge computing nodes in the corresponding dimension using this formula. The natural constant is a general mathematical constant. The resource supply and demand difference tolerance coefficient is a pre-set value in the corresponding dimension. The resource demand feature value of the subtask in the dimension is the feature value corresponding to the aligned dimension in the complexity vector. The resource supply feature value of the edge computing node in the dimension is the feature value corresponding to the aligned dimension in the multi-dimensional resource state vector. The normalization benchmark factor is a pre-set value.

[0107] The significance of this formula is to calculate the matching degree component of the alignment dimension between the complexity vector and the multidimensional resource state vector. Specifically, it combines the resource demand feature value of the subtask under the corresponding dimension and the resource supply feature value of the edge computing node, while incorporating the preset resource supply and demand difference tolerance coefficient and normalization benchmark factor to quantify the degree of fit between the resource demand of the subtask and the resource supply of the node in this dimension.

[0108] The smaller the difference between the resource demand feature value of the subtask in the dimension and the resource supply feature value of the edge computing node in the same dimension, the smaller the ratio of this difference to the sum of their maximum values ​​and the normalized benchmark factor. The closer the value of the exponential part in the formula is to zero, the closer the result of the exponential operation is to one, and the higher the matching degree component is.

[0109] The larger the difference between the resource demand characteristic value of the subtask in a certain dimension and the resource supply characteristic value of the edge computing node in that same dimension, the larger the ratio of this difference to the sum of their maximum values ​​and the normalized benchmark factor. This results in a more negative exponential component in the formula, and naturally, a result closer to zero, leading to a lower matching degree component. Conversely, the larger the tolerance coefficient for resource supply and demand differences, the smaller the product of this coefficient and the aforementioned ratio in the exponential component, and the more smoothly the matching degree component changes with the difference.

[0110] When performing feature alignment, it is necessary to first clarify the dimensional feature definitions of the complexity vector and the multidimensional resource state vector. Each dimension of the complexity vector corresponds to the feature attributes of the subtask in terms of computation type, data processing scale, and result output scale, while each dimension of the multidimensional resource state vector corresponds to the resource feature attributes of the edge computing node, such as computing power, memory capacity, network bandwidth, and availability of dedicated hardware units. By verifying the dimensional feature descriptions of the two vectors one by one, the correspondence between the dimensions is established. The dimension in the complexity vector reflecting the intensity of computational demand is aligned with the dimension in the multidimensional resource state vector reflecting computational power; the dimension in the complexity vector reflecting the data processing volume demand is aligned with the memory capacity dimension in the multidimensional resource state vector; the dimension in the complexity vector reflecting the result output volume demand is aligned with the network bandwidth dimension in the multidimensional resource state vector; and the dimension in the complexity vector reflecting the dedicated hardware demand is aligned with the availability of dedicated hardware units in the multidimensional resource state vector. During the alignment process, each dimension is associated with only one corresponding dimension. By repeatedly verifying the feature meaning of the dimensions, it is ensured that the feature directions of the two are completely consistent, and there is no mismatch or repeated alignment of dimensions. In the end, the dimension of the complexity vector is accurately aligned with the corresponding dimension of the multidimensional resource state vector.

[0111] When calculating the matching degree component of the alignment dimension, for each dimension with completed feature alignment, the eigenvalues ​​of that dimension in the complexity vector and the eigenvalues ​​in the multidimensional resource state vector are extracted, and the actual meanings represented by the two eigenvalues ​​are compared in depth. If the demand intensity reflected by the eigenvalue of that dimension in the complexity vector is completely consistent with the supply capacity reflected by the eigenvalue of that dimension in the multidimensional resource state vector, that is, the resource supply exactly meets the task requirements, then the matching degree component of that alignment dimension is determined to be of the highest level; if the supply capacity reflected by the eigenvalue of that dimension in the multidimensional resource state vector is slightly higher than the demand intensity reflected by the eigenvalue of that dimension in the complexity vector, and the excess is within a reasonable range and does not cause resource waste, then the matching degree component is determined to be of the second highest level; if the supply capacity of that dimension in the multidimensional resource state vector basically meets the demand intensity of the complexity vector, but there is a slight deficiency, and it can only support the minimum operation of the task, then the matching degree component is determined to be of the medium level; if the supply capacity of that dimension in the multidimensional resource state vector differs greatly from the demand intensity of the complexity vector, and it cannot meet the task operation requirements at all, then the matching degree component is determined to be of the lowest level. The matching degree component of each alignment dimension is derived based on the aforementioned clear judgment criteria, ensuring that the division of component levels is objective and consistent with the actual matching situation, and accurately reflects the degree of fit between demand and supply in a single dimension.

[0112] When generating the total matching score by integrating matching score components across all dimensions, the matching score components of all alignment dimensions are first arranged sequentially according to the feature alignment order, ensuring that each component corresponds to a specific alignment dimension without omissions or disordered order. An equal-weighted accumulation method is used for integration, meaning that each matching score component has the same importance in the total matching score, and no component is assigned a higher weight. Starting with the matching score component of the first alignment dimension, it is accumulated with the second component to obtain the accumulated result of the first two components. This result is then added to the third component, and so on, accumulating all components one by one until the matching score component of the last alignment dimension is included in the accumulation. After accumulation, the sum is the matching score between the complexity vector and the multi-dimensional resource state vector. The value of this matching score directly reflects the overall fit between the two vectors across all corresponding dimensions. A higher value indicates that the resource state of the edge computing node better meets the complexity requirements of the subtask, while a lower value indicates a poorer fit between the resource state and the task requirements, providing a direct and clear basis for subsequent task scheduling decisions.

[0113] The beneficial effects are as follows: precise alignment of dimensional features ensures the basic accuracy of matching degree calculation and avoids judgment bias caused by dimensional mismatch; the use of a clear level division method to calculate matching degree components makes the supply and demand fit of a single dimension clearly quantified; and the generation of total matching degree by summing all components with equal weights comprehensively reflects the overall matching situation between resource status and task requirements. The entire process is logically rigorous, standardized, and the calculation results are objective and reliable, providing a scientific basis for task allocation and resource optimization of edge computing nodes, and effectively improving resource utilization efficiency and task execution success rate.

[0114] S4: Based on the matching degree, initiate direct negotiation between the task agent and the resource agent to determine the resource agent corresponding to the subtask;

[0115] In this embodiment of the invention, initiating direct negotiation between the task agent and the resource agent based on the matching degree to determine the resource agent corresponding to the sub-task includes:

[0116] Candidate resource agents with a matching degree higher than a preset threshold are selected for the subtask;

[0117] The task agent sends a negotiation request to the candidate resource agent;

[0118] Upon receiving the negotiation request, the candidate resource agent makes a local acceptance decision based on the currently maintained set of real-time resource states and a preset acceptance strategy, and generates the negotiation response of the candidate resource agent.

[0119] The candidate resource agent feeds back the negotiation response to the task agent via point-to-point communication.

[0120] Based on the received negotiation response, the task agent selects one of the candidate resource agents that have provided a feedback agreement response as the resource agent for final execution for the subtask.

[0121] The task agent first obtains the matching degree between all resource agents and the subtask, and simultaneously retrieves a pre-set threshold. This threshold is a fixed value determined based on the minimum resource requirements for subtask execution and the system resource optimization allocation principles, and is not adjusted with changes in resource status or matching degree. The task agent compares the matching degree of each resource agent with the preset threshold one by one. During the comparison, resource agents with matching degrees higher than the preset threshold are directly included in the candidate range, while resource agents with matching degrees equal to or lower than the preset threshold are directly excluded from the candidate range. This ensures that all candidate resource agents have the resource conditions to meet the basic requirements of the subtask, ultimately forming a candidate resource agent set composed of all resource agents with matching degrees higher than the preset threshold.

[0122] After determining the set of candidate resource agents, the task agent begins constructing a negotiation request. This request contains core execution information for the subtask, including its execution objective, specific resource requirements, estimated execution time, and data transmission requirements during execution. This ensures that candidate resource agents can fully understand the subtask's execution needs through the negotiation request. Subsequently, the task agent initiates targeted transmission to each candidate resource agent through a pre-defined communication link, accurately sending the constructed negotiation request to each agent. During transmission, the receiving status of each candidate resource agent is monitored in real time. If a transmission failure occurs, it is immediately re-initiated until all candidate resource agents have successfully received the negotiation request.

[0123] After successfully receiving the negotiation request sent by the task agent, the candidate resource agent first parses all the information in the negotiation request to clarify the key contents such as the execution goal, resource requirements, and execution duration of the subtask. Then, it retrieves the real-time resource status set it currently maintains. This set contains real-time resource indicators such as the computing power, memory capacity, network bandwidth, and availability of dedicated hardware units of its corresponding edge computing node. At the same time, it obtains the preset acceptance policy. This acceptance policy clearly defines the criteria for the resource agent to accept the subtask, including whether the current resources meet the requirements of the subtask, whether there are already accepted tasks that conflict with the execution time of the subtask, and whether the dedicated hardware unit is in an idle and callable state. The candidate resource agent checks the matching of each indicator in the real-time resource status set with the sub-task requirements one by one according to the rules of the acceptance policy. First, it determines whether the core resources such as computing power, memory capacity, and network bandwidth are sufficient. Then, it checks whether the availability of dedicated hardware units meets the requirements. Finally, it confirms whether there is a conflict between the sub-task execution time and the accepted task. If all the checked items meet the acceptance policy requirements, it is determined to accept. If any checked item does not meet the acceptance policy requirements, it is determined to reject. Based on the judgment result, a negotiation response is generated, which clearly indicates the conclusion of acceptance or rejection. At the same time, the core verification results of resource status and sub-task requirements are attached to ensure that the task agent can clearly understand the basis of the response.

[0124] After generating a negotiation response, the candidate resource agent initiates a point-to-point communication mechanism. This mechanism establishes a dedicated direct communication link between the candidate resource agent and the task agent, without any intermediate forwarding nodes, ensuring the security and timeliness of response transmission. The candidate resource agent transmits its generated negotiation response directly to the task agent through this communication link. During transmission, the connection status of the communication link is monitored in real time. If the link is interrupted, the connection is immediately re-established and transmission is resumed until the negotiation response is successfully sent to the task agent. Simultaneously, the candidate resource agent records the response sending time and transmission status for subsequent traceability, ensuring that the task agent can fully receive the negotiation responses from each candidate resource agent.

[0125] The task agent receives negotiation responses from various candidate resource agents in real time, categorizes and organizes all responses, first filtering out those marked with "agree," forming a candidate set of agreeable responses for the corresponding resource agents, while excluding those marked with "reject." For each resource agent in the agreeable response candidate set, the task agent retrieves its previous matching score and sorts the resource agents in the agreeable response candidate set in descending order of matching score. The resource agent ranked first is selected as the final resource agent to be executed. This selection method ensures that the final selected resource agent has the highest matching score and the best resource fit among all currently agreeable candidates. After determining the final resource agent to be executed, the task agent sends a confirmation notification to that resource agent, informing it that it has been selected as the executor of the subtask, and simultaneously synchronizes the detailed execution plan of the subtask, completing the final selection process.

[0126] The beneficial effects are as follows: Candidate resource agents are screened using preset thresholds, ensuring that candidates possess the basic conditions to meet sub-task requirements and reducing the cost of ineffective negotiation; negotiation requests contain complete sub-task information, enabling candidate resource agents to accurately determine their own suitability; local decision-making based on real-time resource status sets and explicit acceptance strategies ensures the objectivity and accuracy of negotiation responses; point-to-point communication guarantees secure and timely response transmission, avoiding information loss or delay; and the selection criterion based on matching degree ensures optimal adaptation between the final executing resource agent and the sub-task. The overall process is standardized and efficient, effectively improving the rationality of sub-task allocation and execution success rate, and optimizing the utilization efficiency of system resources.

[0127] S5: Form an autonomous task group between the task agent and the resource agent, and execute the sub-task in the autonomous task group;

[0128] In this embodiment of the invention, forming an autonomous task group between the task agent and the resource agent, and executing the sub-task within the autonomous task group, includes:

[0129] The task agent integrates the complexity vector, execution objective, and constraints of the sub-task into a core task information set, sends it to the determined resource agent, and simultaneously receives its own processing capability description and adaptation suggestions from the resource agent, thus obtaining a two-way information interaction record of the task agent.

[0130] Based on the bidirectional information interaction record, the task agent and the resource agent negotiate together to obtain an intra-group collaboration protocol between the task agent and the resource agent.

[0131] Based on the intra-group collaboration protocol, a logical interaction link between intelligent agents is constructed, and the link connectivity confirmation result between the task intelligent agent and the resource intelligent agent is obtained;

[0132] The task agent, based on the execution logic of the subtask and the processing capability of the resource agent, breaks down the subtask into a series of processing steps, allocates corresponding processing steps and associated data to the resource agent, and obtains the step allocation scheme of the resource agent.

[0133] The resource agent performs task processing for the corresponding processing stage according to the stage allocation scheme and the group collaboration protocol.

[0134] The task agent first retrieves the complexity vector of the generated subtasks. This vector is a fixed-dimensional data structure related to the subtask complexity, previously encapsulated through scalar numerical arrangements. Simultaneously, it collects the execution objectives of the subtasks, clarifying the specific results they need to achieve, as well as their constraints, including execution time limits, data security requirements, and resource usage limits. These three types of information are then systematically integrated, with duplicate information removed and arranged logically to form a complete and comprehensive core task information set. Subsequently, the task agent accurately sends this core task information set to the previously identified resource agent via an established point-to-point communication link, ensuring that the resource agent can fully obtain the key information of the subtasks. After receiving the core task information set, the resource agent comprehensively analyzes its own processing capabilities, including the actual computing power, available memory capacity, real-time network bandwidth, and the specific support range of dedicated hardware units, forming a detailed description of its own processing capabilities. Simultaneously, considering the complexity vector and constraints of subtasks, it proposes specific adaptation suggestions regarding the execution flow, data allocation methods, and potential resource bottlenecks of the subtasks. This description of its processing capabilities and adaptation suggestions are then fed back to the task agent via the same communication link. The task agent receives and records all information fed back by the resource agent, organizing and archiving it together with the previously sent core task information set to form a two-way information exchange record. This record completely preserves all key content exchanged between the two parties, providing a comprehensive basis for subsequent negotiations.

[0135] Based on the bidirectional information exchange records, the task agent and the resource agent initiate a joint negotiation process. This negotiation takes place in real-time via a point-to-point communication link, with both parties relying solely on the content of the bidirectional information exchange records and refraining from introducing any irrelevant information. The task agent first proposes a preliminary execution plan for the sub-task based on its execution objectives and constraints, combined with the resource agent's processing capacity description. This plan includes the expected execution steps, the time allocation for each step, and the specific time periods for data transmission. The resource agent then responds to the preliminary execution plan based on its actual processing capacity and adaptation suggestions. If any part of the plan exceeds its processing capacity or conflicts with other accepted tasks, it will explicitly point this out and propose adjustments, such as optimizing the order of execution steps, adjusting data transmission time periods, or processing related data in batches. Both parties repeatedly communicate regarding any points of disagreement. The task agent optimizes the plan based on the resource agent's adjustment suggestions and the core requirements of the sub-task. The resource agent then performs a second adaptability check on the optimized plan until both parties reach complete agreement on all key matters, including the sub-task's execution flow, data transmission method, resource allocation standards, exception handling mechanism, and progress feedback frequency. All agreed-upon content is compiled into a standardized text record, clearly defining the rights and obligations of both parties. This text record serves as the intra-group collaboration agreement between the task agent and the resource agent. The agreement content is ensured to be clear and unambiguous, and can be directly used as the basis for subsequent execution.

[0136] Based on the communication requirements and interaction rules specified in the group's collaboration protocol, the task agent and the resource agent jointly construct a logical interaction link between the agents. The construction process first clarifies the core functions of the link, including data transmission, command issuance, and status feedback. Based on these functional requirements, the logical architecture of the link is determined, specifying key elements such as the data transmission path, the command delivery order, and the feedback format of status information. Subsequently, the task agent and the resource agent each activate their own link adaptation modules, configuring them according to the determined logical architecture to ensure that their communication interfaces, data formats, and transmission protocols are fully compatible and that there are no compatibility issues. After configuration, a link connectivity test is initiated. The task agent sends test data packets and test commands to the resource agent. Upon receiving these, the resource agent returns a test response in the format required by the protocol. The task agent checks the integrity of the test data packets, the execution of the test commands, and the timeliness of the response. If all test items meet the protocol requirements, it indicates that the link has been successfully established, and a confirmation result of successful link connectivity is generated. If any test item fails, both parties promptly investigate and resolve any issues in the adaptation configuration, adjust accordingly, and re-perform the connectivity test until all test items pass. Finally, a link connectivity confirmation result is obtained between the task agent and the resource agent. This result clearly indicates the link connectivity status, providing communication assurance for subsequent task execution.

[0137] The task agent first conducts an in-depth analysis of the subtask's execution logic, outlining all key steps the subtask must take from initiation to completion. It clarifies the core function, execution order, and dependencies between each step, ensuring the decomposed steps are coherent and without omissions or duplication. Simultaneously, it re-verifies the resource agent's processing capacity description, accurately assessing its actual capabilities in computing, memory, network, and dedicated hardware, ensuring each decomposed step is compatible with the resource agent's processing capacity. Based on the subtask's execution logic and the resource agent's processing capabilities, the subtask is broken down into several coherent processing steps. The complexity and workload of each step are controlled within the resource agent's capacity, and adjacent steps maintain clear logical connections, with the output of one step directly serving as the input for the next. Subsequently, corresponding associated data is assigned to each processing step. This associated data originates from the subtask's original data or pre-processed results, ensuring each step receives the necessary complete data support. All processing steps, corresponding related data, execution order, and dependencies are systematically organized to form a clear allocation description. This allocation description is the resource agent's step allocation scheme. The scheme clearly marks the specific content, required data, execution requirements, and expected output of each processing step to ensure that the resource agent can accurately understand and execute it.

[0138] The resource agent first receives the complete process allocation plan from the task agent. Combining this with the group's collaboration protocol, it comprehensively analyzes the specific content, execution requirements, associated data, and dependencies of each allocated processing step, clarifying its own responsibilities in each step. Following the execution order specified in the process allocation plan, the resource agent first obtains the associated data for the first processing step, performs integrity verification to ensure no missing or incorrect data, and then initiates the corresponding processing module. It then performs task processing according to the processing standards required by the protocol, strictly adhering to the resource usage specifications and data security requirements stipulated in the group's collaboration protocol. After completing the first processing step, the resource agent organizes the processing results according to the format specified in the protocol and feeds them back to the task agent through a logical interaction link. Simultaneously, it obtains the associated data for the next processing step and continues working based on the processing results of the previous step. If data anomalies or resource shortages are encountered during processing, the resource agent immediately reports the anomaly and preliminary processing suggestions to the task agent according to the anomaly handling mechanism agreed upon in the protocol, and only proceeds with subsequent operations after receiving instructions from the task agent. The resource agent sequentially completes all assigned processing steps. The execution log of each step is recorded synchronously, including information such as execution time, processing result, and resource usage, to ensure that the entire task processing process is traceable and verifiable, and to complete the task processing of the corresponding processing step in strict accordance with the step allocation plan and the group collaboration agreement.

[0139] The beneficial effects are as follows: by integrating the core information set of the task and conducting two-way information interaction, the integrity and accuracy of information transmission between the task agent and the resource agent are ensured, laying a solid foundation for subsequent collaboration; the joint negotiation based on the interaction records forms an intra-group collaboration agreement, clarifying the execution standards and responsibilities of both parties and avoiding disagreements during the execution process; the construction of logical interaction links ensures the stability and efficiency of communication, providing reliable support for data transmission and status feedback; the link allocation scheme combining execution logic and processing capabilities realizes the reasonable decomposition and precise allocation of sub-tasks, improving processing efficiency; the resource agent strictly executes tasks according to the scheme and protocol, ensuring the standardization and accuracy of sub-task processing; the overall process is progressive and logically rigorous, effectively ensuring the smooth completion of sub-tasks and optimizing the collaborative effect between agents.

[0140] S6: When an execution anomaly is detected, a new round of negotiation is triggered for the affected subtasks, and the autonomous task group is reorganized. The subtasks are then executed according to the reorganized autonomous task group.

[0141] In this embodiment of the invention, when an execution anomaly is detected, triggering a new round of negotiation for the affected subtasks, reorganizing the autonomous task group, and executing the subtasks according to the reorganized autonomous task group includes:

[0142] The task agent captures abnormal behavior and its impact range to obtain an explanation of the abnormal situation of the subtask.

[0143] Based on the above description of the abnormal situation, a new round of negotiation is triggered, and the agents associated with the affected subtasks are notified to exchange their current adaptation states, thereby obtaining a summary of the negotiation information of the agents.

[0144] Based on the summarized negotiation information, the appropriate resource agents are re-determined, the cooperation relationships are adjusted, and the autonomous task group reorganization scheme of the sub-tasks is obtained.

[0145] A new autonomous task group will be formed in accordance with the aforementioned autonomous task group reorganization plan, and the execution requirements of the unfinished parts of the sub-tasks will be synchronized to promote the subsequent execution of the sub-tasks.

[0146] The task agent monitors the entire execution process of subtasks in real time, including the processing progress of the resource agent, data transmission status, intermediate result output, and the connectivity of logical interaction links. By continuously collecting this execution-related real-time data, it promptly detects abnormal behaviors that do not conform to preset execution standards. Specific abnormal behaviors include resource agent processing stalls, data loss or delays during transmission, intermediate results that do not meet expectations, and interruptions in logical interaction links leading to communication failures. Each abnormal behavior is determined by specific execution phenomena, eliminating ambiguous abnormal definitions. After confirming an abnormal behavior, the task agent further traces the source of the anomaly, analyzes its impact on the current processing stage, and investigates whether it will spread to other related processing stages. It clarifies the scope of affected related data, unexecuted processing stages, and other potentially affected subtasks. The specific form of the anomaly, its occurrence time, its source, and the determined scope of impact are systematically organized into a clearly structured and detailed description of the subtask's anomaly. This description fully presents all key information related to the anomaly, providing a clear basis for subsequent processing.

[0147] Based on the established anomaly description, the task agent immediately triggers a new round of negotiation, consistent with the initial negotiation mechanism, ensuring operational continuity and standardization. Through the established communication network, the task agent accurately identifies and notifies all agents associated with the affected subtasks. These associated agents include the resource agents originally executing the subtasks, task agents of other subtasks that depend on the affected processing stage, and their corresponding resource agents. The notification clearly includes the core content of the anomaly description, allowing associated agents to quickly understand the anomaly's background and scope of impact. Upon receiving the notification, each associated agent comprehensively reviews its current adaptation status, including its real-time resource status, the execution progress of accepted tasks, current idle processing capacity, and the degree of association with the affected subtasks. This adaptation status information is then organized in a unified format and fed back to the task agent. The task agent collects, classifies, and integrates the adaptation status information from all associated agents, eliminating duplicate information and verifying information completeness to ensure no associated agent's feedback is missed, ultimately forming a comprehensive and accurate summary of agent negotiation information.

[0148] Based on the summarized negotiation information, the task agent analyzes the adaptation status of each associated agent, focusing on the degree of matching between its resource status and the remaining execution requirements of the subtask, and determining whether it has the capacity to handle the unfinished portion of the affected subtask. For the original resource agent, if its adaptation status shows that the anomaly has been eliminated and it still has sufficient processing capacity, it can continue to be included in the adaptation scope; if the anomaly cannot be eliminated or the processing capacity is insufficient, it will no longer be considered as an adaptation candidate. For other associated agents, based on their feedback of idle processing capacity, resource status, and other information, agents that can meet the remaining execution requirements of the subtask are selected as new adapted resource agents. After identifying the new adaptive resource agents, the task agents readjust their collaborative relationships, severing the collaborative associations between previously incompatible agents. They clarify the collaborative responsibilities and interaction rules between the new adaptive resource agents, the task agents, and other related agents, and determine the new execution order, data transmission paths, and status feedback mechanisms. The newly identified adaptive resource agents, adjusted collaborative relationships, and new execution specifications are systematically integrated to form a detailed autonomous task group reorganization plan for subtasks. This plan clarifies the composition structure and execution rules of the new task groups, ensuring the smooth execution of subtasks after reorganization.

[0149] According to the established autonomous task group reorganization plan, a new autonomous task group is formed, led by a task agent. First, the specific roles and responsibilities of the task agents and resource agents within the new task group are clearly defined, ensuring that each agent understands its own work content and collaborating partners. Then, the logical interaction links between agents are reconstructed, ensuring connectivity, security, and efficiency by referring to the initial link construction standards. After link construction, connectivity testing is conducted to ensure normal communication between all agents. The task agent meticulously reviews the execution requirements of the unfinished parts of the subtasks, including unexecuted processing steps, specific execution standards for each step, the current status of related data, remaining execution time constraints, data security requirements, and other key information. This information is synchronized to all resource agents in the new autonomous task group through the constructed logical interaction links, ensuring that each resource agent fully understands the execution requirements of the unfinished parts. After synchronization, the new autonomous task group initiates the processing of the unfinished parts of the subtasks according to the predetermined execution order. Resource agents strictly adhere to the execution requirements and collaboration rules, while task agents monitor the execution progress in real time, promptly coordinating and resolving any issues that arise during execution to ensure the smooth progress of subsequent subtask execution until all subtasks are completed.

[0150] The beneficial effects are as follows: by accurately capturing abnormal behavior and its scope of impact and forming an explanation of the abnormal situation, a clear basis for anomaly handling is provided, preventing the anomaly from escalating; triggering a new round of negotiation based on the anomaly and summarizing the agent adaptation status ensures the scientific and comprehensive nature of the reorganization decision; based on the summary of negotiation information, the adapted resource agents are re-determined and the cooperation relationship is adjusted to form a reasonable autonomous task group reorganization plan, ensuring the continuity of sub-task execution; forming a new task group according to the reorganization plan and executing the requirements synchronously effectively promotes the subsequent execution of sub-tasks, reduces the impact of anomalies on task completion, and the overall process is timely, standardized, and improves the fault tolerance and reliability of sub-task execution.

[0151] like Figure 2 The diagram shown is a functional block diagram of a distributed task dynamic decomposition system based on multiple agents provided in an embodiment of the present invention.

[0152] The multi-agent-based distributed dynamic task decomposition system 100 of this invention can be installed in an electronic device. Depending on the functions implemented, the multi-agent-based distributed dynamic task decomposition system 100 may include a task decomposition and feature extraction module 101, a resource status awareness module 102, a task resource matching degree calculation module 103, an agent negotiation and decision-making module 104, an autonomous task group execution and coordination module 105, and an exception handling and dynamic reorganization module 106. The module described in this invention can also be called a unit, which refers to a series of computer program segments that can be executed by the processor of an electronic device and can perform a fixed function, stored in the memory of the electronic device.

[0153] In this embodiment, the functions of each module / unit are as follows:

[0154] The task decomposition and feature extraction module 101 is used to decompose the total task into sub-tasks and generate the complexity vector of the sub-tasks according to the resource requirement characteristics of the sub-tasks.

[0155] The resource status perception module 102 is used to perceive the real-time resource status of the subtask on the edge computing node, and generate a multi-dimensional resource status vector that matches the dimension of the complexity vector based on the real-time resource status.

[0156] The task resource matching degree calculation module 103 is used for the task agent to calculate the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the received multiple multidimensional resource state vectors.

[0157] The agent negotiation and decision-making module 104 is used to initiate direct negotiation between the task agent and the resource agent based on the matching degree, so as to determine the resource agent corresponding to the subtask.

[0158] The autonomous task group execution and coordination module 105 is used to form an autonomous task group between the task agent and the resource agent, and to execute the sub-task in the autonomous task group.

[0159] The exception handling and dynamic reorganization module 106 is used to trigger a new round of negotiation for the affected subtasks when an execution exception is detected, and to reorganize the autonomous task group, and to execute the subtasks according to the reorganized autonomous task group.

[0160] In the several embodiments provided by this invention, it should be understood that the disclosed methods and systems can be implemented in other ways. For example, the system embodiments described above are merely illustrative; for instance, the division of modules is only a logical functional division, and other division methods may be used in actual implementation.

[0161] The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0162] Furthermore, the functional modules in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or in the form of hardware plus software functional modules.

[0163] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the present invention can be implemented in other specific forms without departing from the spirit or essential characteristics of the present invention.

[0164] The embodiments of this application can acquire and process relevant data based on artificial intelligence technology. Artificial intelligence is the theory, method, technology, and application system that uses digital computers or machines controlled by digital computers to simulate, extend, and expand human intelligence, perceive the environment, acquire knowledge, and use that knowledge to obtain optimal results.

[0165] Finally, it should be noted that the above 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 preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention.

Claims

1. A distributed task dynamic decomposition method based on multi-agent systems, characterized in that, The method includes: S1: Decompose the overall task into subtasks, and generate a complexity vector for each subtask based on its resource requirement characteristics, including: Construct the task dependency graph of the overall task based on the logical dependencies in the overall task; Based on the node division in the task dependency graph, the total task is broken down into sub-tasks; The original characteristic parameters of the subtask are obtained by analyzing the type of computation required for the execution of the subtask, the expected data size to be processed, and the output size of the result. Based on a preset vector dimension mapping rule, the original feature parameters are assembled into the complexity vector of the subtask; S2: Sensing the real-time resource status of the subtask on the edge computing node, and generating a multi-dimensional resource status vector that matches the dimension of the complexity vector based on the real-time resource status, including: The resource intelligence agent determines the types of local resources that need to be monitored based on a pre-set list of resource types to be sensed. Based on the system performance counters and kernel status interfaces of the edge computing nodes corresponding to the resource agents, collect the raw monitoring data corresponding to the resource categories. The original monitoring data is filtered for noise to obtain the resource indicators of the subtask; The resource indicators are encapsulated according to their corresponding resource categories to obtain the real-time resource status of the edge computing node; The resource agent extracts resource indicators corresponding to computing power, memory capacity, network bandwidth, and availability of dedicated hardware units from the real-time resource status. Based on the characteristics of the resource indicators, the resource indicators are converted into dimensionless scalar values. The scalar values ​​are arranged sequentially according to the order of the dimensions of the complexity vector; The arranged scalar numerical sequence is encapsulated into a fixed-dimensional data structure to obtain a multi-dimensional resource state vector that matches the dimension of the complexity vector. S3: The task agent calculates the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the received multidimensional resource state vector; S4: Based on the matching degree, initiate direct negotiation between the task agent and the resource agent to determine the resource agent corresponding to the subtask; S5: An autonomous task group is formed between the task agent and the resource agent, and the sub-task is executed in the autonomous task group, including: The task agent integrates the complexity vector, execution objective, and constraints of the sub-task into a core task information set, sends it to the determined resource agent, and simultaneously receives its own processing capability description and adaptation suggestions from the resource agent, thus obtaining a two-way information interaction record of the task agent. Based on the bidirectional information interaction record, the task agent and the resource agent negotiate together to obtain an intra-group collaboration protocol between the task agent and the resource agent. Based on the intra-group collaboration protocol, a logical interaction link between intelligent agents is constructed, and the link connectivity confirmation result between the task intelligent agent and the resource intelligent agent is obtained; The task agent, based on the execution logic of the subtask and the processing capability of the resource agent, breaks down the subtask into a series of processing steps, allocates corresponding processing steps and associated data to the resource agent, and obtains the step allocation scheme of the resource agent. The resource agent performs task processing for the corresponding processing stage according to the stage allocation scheme and the intra-group collaboration protocol; S6: When an execution anomaly is detected, a new round of negotiation is triggered for the affected subtasks, and the autonomous task group is reorganized. The subtasks are then executed according to the reorganized autonomous task group.

2. The distributed task dynamic decomposition method based on multi-agent systems as described in claim 1, characterized in that, The task agent calculates the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the received multidimensional resource state vector, including: Align the dimension of the complexity vector with the corresponding dimension of the multidimensional resource state vector using feature alignment. The matching degree component of the alignment dimension is calculated based on the eigenvalues ​​of the alignment dimension in the complexity vector and the eigenvalues ​​of the multidimensional resource state vector. By combining the matching degree components of all dimensions, the matching degree between the complexity vector and the multidimensional resource state vector is generated.

3. The distributed task dynamic decomposition method based on multi-agent systems as described in claim 2, characterized in that, The formula for calculating the matching degree component is as follows: ； In the formula, For the matching degree component, It is a natural constant. For dimension The preset tolerance coefficient for resource supply and demand differences, For the subtask in dimension Resource demand characteristic values ​​on For the edge computing node in the current dimension Resource supply characteristic value on, This is the preset normalization benchmark factor.

4. The distributed task dynamic decomposition method based on multi-agent systems as described in claim 1, characterized in that, The step of initiating direct negotiation between the task agent and the resource agent based on the matching degree to determine the resource agent corresponding to the sub-task includes: Candidate resource agents with a matching degree higher than a preset threshold are selected for the subtask; The task agent sends a negotiation request to the candidate resource agent; Upon receiving the negotiation request, the candidate resource agent makes a local acceptance decision based on the currently maintained set of real-time resource states and a preset acceptance strategy, and generates the negotiation response of the candidate resource agent. The candidate resource agent feeds back the negotiation response to the task agent via point-to-point communication. Based on the received negotiation response, the task agent selects one of the candidate resource agents that have provided a feedback agreement response as the resource agent for final execution for the subtask.

5. The distributed task dynamic decomposition method based on multi-agent systems as described in claim 1, characterized in that, When an execution anomaly is detected, a new round of negotiation is triggered for the affected subtasks, and the autonomous task group is reorganized. The subtasks are then executed according to the reorganized autonomous task group, including: The task agent captures abnormal behavior and its impact range to obtain an explanation of the abnormal situation of the subtask. Based on the above description of the abnormal situation, a new round of negotiation is triggered, and the agents associated with the affected subtasks are notified to exchange their current adaptation states, thereby obtaining a summary of the negotiation information of the agents. Based on the summarized negotiation information, the appropriate resource agents are re-determined, the cooperation relationships are adjusted, and the autonomous task group reorganization scheme of the sub-tasks is obtained. A new autonomous task group will be formed in accordance with the aforementioned autonomous task group reorganization plan, and the execution requirements of the unfinished parts of the sub-tasks will be synchronized to promote the subsequent execution of the sub-tasks.

6. A distributed task dynamic decomposition system based on multi-agent systems, characterized in that, The system is used to implement the distributed task dynamic decomposition method based on multiple agents according to any one of claims 1-5, the system comprising: The task decomposition and feature extraction module is used to decompose the total task into subtasks and generate the complexity vector of the subtasks based on the resource requirement characteristics of the subtasks. The resource status awareness module is used to sense the real-time resource status of the subtask on the edge computing node, and generate a multi-dimensional resource status vector that matches the dimension of the complexity vector based on the real-time resource status. The task resource matching degree calculation module is used by the task agent to calculate the matching degree between the subtask complexity vector and the multidimensional resource state vector based on the multiple multidimensional resource state vectors received. The agent negotiation and decision-making module is used to initiate direct negotiation between the task agent and the resource agent based on the matching degree, so as to determine the resource agent corresponding to the subtask. An autonomous task group execution and coordination module is used to form an autonomous task group between the task agent and the resource agent, and to execute the sub-tasks in the autonomous task group. The exception handling and dynamic reorganization module is used to trigger a new round of negotiation for the affected subtasks when an execution exception is detected, reorganize the autonomous task group, and execute the subtasks according to the reorganized autonomous task group.

Images