Multi-agent collaborative deep learning task allocation method

Abstract

The invention discloses a multi-agent collaborative deep learning task allocation method, and relates to the technical field of task allocation, and the multi-agent collaborative deep learning task allocation method comprises the following steps: S1, obtaining data, and setting a database; s2, extracting core feature parameters, and converting the core feature parameters into standardized task feature vectors; s3, setting a rule and adopting a Transform architecture model to evaluate the real-time capability of the node to generate a capability evaluation result; s4, presetting an allocation rule, obtaining a task allocation scheme, and performing verification adjustment; s5, performing task execution by the nodes, and acquiring data in real time; and S6, comparing the historical data with the data based on the execution exception threshold, adding a label, and storing the label into a database. According to the method, the data is acquired and the multi-agent task allocation historical scheme database is constructed, so that one-sided data acquisition in traditional deep learning task allocation is avoided, and waste of computing resources caused by blind allocation is reduced.

Description

Technical Field

[0001] This invention relates to the field of task allocation technology, and more particularly to a deep learning task allocation method for multi-agent collaboration. Background Technology

[0002] In the era of computing power networks that deeply integrate artificial intelligence and distributed computing, multi-agent collaborative systems, as the core support for efficient scheduling of deep learning tasks, have been widely penetrated into key areas such as intelligent computing clusters, edge computing node scheduling, cloud task distribution, and industrial AI computing power allocation. The collaborative efficiency of task allocation, the accuracy of resource matching, and the flexibility of scenario adaptation are directly related to the utilization rate of computing power resources and the execution efficiency of deep learning tasks. Enterprises have put forward higher requirements for the response speed of cluster computing power scheduling, the ability of edge nodes to undertake real-time tasks, and the rationality of cloud allocation of multiple types of tasks. Multi-agent collaborative technology, with its powerful distributed decision-making and dynamic negotiation capabilities, has shown groundbreaking advantages in the field of deep learning task allocation. By integrating core technical elements such as node capability assessment, task feature matching, and allocation scheme optimization, it constructs a multi-dimensional collaborative allocation system, becoming a key technical direction to break through the limitations of traditional single-node scheduling and improve the effect of computing power configuration. It has important engineering application value and industry promotion significance.

[0003] However, existing deep learning task allocation methods based on multi-agent collaboration lack multi-dimensional fusion design in practical applications. Most solutions rely solely on node hardware configuration data, failing to synchronously integrate real-time node operating status and historical task execution data. This results in one-sided evaluation support, making it difficult to address the precise allocation requirements in complex computing scenarios. Furthermore, they lack a standardized mapping relationship between task characteristics and multi-agent allocation strategies, often employing a single weight matching mode. This leads to poor adaptability of the allocation scheme to actual needs, resulting in significant computational waste and task latency issues. Currently, no effective solutions have been proposed to address these problems in the relevant technologies. Summary of the Invention

[0004] To address the problems in related technologies, this invention proposes a multi-agent collaborative deep learning task allocation method to overcome the aforementioned technical problems in existing related technologies.

[0005] To achieve the above objectives, the specific technical solution adopted by the present invention is as follows: A method for assigning deep learning tasks in a multi-agent collaborative manner includes the following steps: S1. Acquire deep learning task data, node hardware configuration data, and historical task execution data, and set up a database of historical multi-agent task allocation schemes. S2. Extract the core feature parameters of the deep learning task data, and pre-set the task feature mapping rules. Then, convert the core feature parameters into standardized task feature vectors according to the task feature mapping rules. S3. Based on the node hardware configuration data, set multi-dimensional capability assessment weighting rules, and adopt the Transformer architecture model to evaluate the real-time capabilities of each node in the node hardware configuration data and generate capability assessment results. As a preferred embodiment, the step of setting multi-dimensional capability evaluation weighting rules based on node hardware configuration data and using the Transformer architecture model to evaluate the real-time capabilities of each node in the node hardware configuration data and generate capability evaluation results includes the following steps: S31. Analyze the specific configuration of the node hardware configuration data and clarify the multi-dimensional capability assessment dimensions; S32. Preset weight allocation logic, combine the weight allocation logic with the analytic hierarchy process to set up multi-dimensional capability assessment weighting rules, and allocate initial weights to the multi-dimensional capability assessment dimensions based on the multi-dimensional capability assessment weighting rules. As a preferred embodiment, the preset weight allocation logic, which combines the weight allocation logic with the analytic hierarchy process (AHP) to set multi-dimensional capability assessment weighting rules, and allocates initial weights to the multi-dimensional capability assessment dimensions based on the multi-dimensional capability assessment weighting rules, includes the following steps: S321. Based on the degree of impact of the evaluation dimensions on task execution efficiency as the core basis for defining the logic, a weight allocation logic is preset, and the priority of dimensions is clarified in combination with the type of deep learning task. S322. Taking the accuracy of node capability assessment as the target layer, computing power, transmission power, and redundancy capability as the criteria layer, and multi-dimensional capability assessment dimensions as the scheme layer, a hierarchical structure of weighted decision-making is constructed by combining the analytic hierarchy process and the subordinate relationship between each level is clarified. S323. Based on the weight allocation logic and the hierarchical structure of weight decision, and using the scaling method to construct a judgment matrix, the relative importance of each evaluation dimension is quantified. S324. Calculate the weight vector of the assessment dimension in the multi-dimensional capability assessment dimension using the analytic hierarchy process, and normalize the weight vector to obtain the initial weight value set of the dimension. S325. Verify the rationality of the initial weight set of dimensions, and use the initial weight values ​​of dimensions that pass the rationality verification as the initial weights of the multi-dimensional capability assessment weighting rules.

[0006] S33. Collect real-time operating status data of each node, and integrate the real-time operating status data with the node hardware configuration data to form a node comprehensive evaluation dataset; S34. Construct a capability assessment model based on the Transformer architecture, input the node comprehensive assessment dataset into the capability assessment model, and obtain the comprehensive assessment results; As a preferred embodiment, the construction of a capability assessment model based on the Transformer architecture, which involves inputting the node comprehensive assessment dataset into the capability assessment model to obtain the comprehensive assessment results, includes the following steps: S341. Decompose the core component layers of the capability assessment model based on the Transformer architecture to obtain the data input layer, feature embedding layer, multi-head attention encoder layer and result output layer, and connect the data input layer, feature embedding layer, multi-head attention encoder layer and result output layer in series through the data interface. S342. Divide the node comprehensive evaluation dataset into static hardware configuration data and dynamic real-time status data, and use numerical standardization to process the static hardware configuration data and time-series serialization to process the dynamic real-time status data, and summarize to obtain standardized input data. S343. The standardized input data is input into the model data input layer. The feature embedding layer performs dual-path encoding on the static hardware data and dynamic time series data in the standardized input data. The two types of vectors are concatenated by the feature fusion operator to obtain a node feature tensor with uniform dimension. As a preferred embodiment, the step of inputting standardized input data into the model data input layer, performing dual-channel encoding on the static hardware data and dynamic time-series data in the standardized input data by the feature embedding layer, and concatenating the two types of vectors through a feature fusion operator to obtain a node feature tensor with uniform dimensions includes the following steps: S3431. Input standardized input data into the model data input layer, and clarify the adaptation encoding method of the feature embedding layer for static hardware data and dynamic time series data. S3432. The static hardware data in the standardized input data is encoded using one-hot encoding in the feature embedding layer according to the adaptive encoding method to generate hardware feature vectors, and the dynamic time-series data in the standardized input data is encoded using position encoding to generate time-series feature vectors. S3433: Call the feature fusion operator to perform dimension alignment and concatenation processing on the hardware feature vector and the temporal feature vector to obtain a node feature tensor with unified dimensions.

[0007] S344. Input the node feature tensor into the multi-head attention encoder layer, set the number of attention heads, and calculate the correlation weight of each evaluation dimension feature through the self-attention mechanism to strengthen the feature expression of high priority dimensions and obtain the node comprehensive feature vector. As a preferred embodiment, the step of inputting the node feature tensor into the multi-head attention encoder layer, setting the number of attention heads, and calculating the correlation weights of features in each evaluation dimension through a self-attention mechanism to enhance the feature representation of high-priority dimensions and obtain the node comprehensive feature vector includes the following steps: S3441. Input the node feature tensor into the multi-head attention encoder layer, preset the threshold for the number of attention heads, and match the node feature tensor with the threshold for the number of attention heads. Set the number of attention heads based on the matching result to complete the model parameter configuration. S3442. The self-attention mechanism is used to perform correlation calculation on the features of each evaluation dimension in the node feature tensor to obtain the correlation weights corresponding to each dimension. Based on the correlation weights, the feature expression of high priority dimensions is strengthened to obtain the node comprehensive feature vector.

[0008] S345. Input the node comprehensive feature vector into the result output layer, and map the feature vector into a quantitative evaluation value through a fully connected neural network to form a comprehensive evaluation result.

[0009] S35. Preset the result threshold division rules, and use the result threshold division rules to classify the comprehensive ability assessment results and generate the ability assessment results.

[0010] S4. Preset multi-agent collaborative allocation rules, use multi-agent negotiation algorithm to combine standardized task feature vectors and capability evaluation results to obtain task allocation scheme, and verify and adjust the task allocation scheme with historical task execution data; As a preferred embodiment, the preset multi-agent collaborative allocation rule, which uses a multi-agent negotiation algorithm combined with standardized task feature vectors and capability assessment results to obtain a task allocation scheme, and verifies and adjusts the task allocation scheme with historical task execution data, includes the following steps: S41. Preset multi-agent collaborative allocation rules and multi-agent negotiation algorithm, set the input parameters of the multi-agent negotiation algorithm as standardized task feature vector and capability evaluation results, and set the core optimization objective of the multi-agent negotiation algorithm; S42. Based on the multi-agent negotiation algorithm and the core optimization objective, set up a dynamic allocation model, input the standardized task feature vector and the capability assessment results into the dynamic allocation model, and obtain the initial allocation scheme. S43. Extract key comparison dimensions from historical task execution data, compare the initial allocation scheme with the historical task execution data item by item, and adjust the initial allocation scheme based on the comparison results to generate a task allocation scheme. As a preferred embodiment, the steps of extracting key comparison dimensions from historical task execution data, comparing the initial allocation scheme with the historical task execution data item by item, and adjusting the initial allocation scheme based on the comparison results to generate a task allocation scheme include the following steps: S431. Based on the core indicators of the initial allocation scheme, determine the key comparison dimensions, extract relevant data corresponding to the key comparison dimensions from the historical task execution data, and form a standardized comparison dataset. S432. Establish a comparison mapping relationship between the initial allocation scheme and historical task execution data, compare the initial allocation scheme with the standardized comparison dataset item by item, and use the difference calculation method to quantify the data comparison deviation. S433. Preset a data deviation threshold, compare the data deviation threshold with the data comparison deviation, and adjust the standardized comparison dataset according to the comparison results to generate a task allocation scheme.

[0011] S44. Perform a secondary comparison and verification of the task allocation scheme with historical task execution data, preset the verification adjustment threshold and verification adjustment rule set, and compare the secondary comparison and verification results with the verification adjustment threshold for threshold adjustment. S45. Match the threshold adjustment comparison results with the verification adjustment rules in the verification adjustment rule set, and adjust the task allocation scheme based on the matched verification adjustment rules.

[0012] S5. The verified and adjusted task allocation scheme is sent to each node in the node hardware configuration data for task execution, and the task execution progress, computing resource utilization and task accuracy data of each node are collected in real time. As a preferred embodiment, the step of distributing the verified and adjusted task allocation scheme to each node in the node hardware configuration data for task execution, and collecting task execution progress, computing resource utilization, and task accuracy data of each node in real time includes the following steps: S51. Decompose the verified and adjusted task allocation scheme into a dedicated execution list for each node, and send the dedicated execution list to each node in the node hardware configuration data. S52. Preset integrity verification rules: Verify the dedicated execution list according to the integrity verification rules, load the deep learning framework and data resources required by the dedicated execution list for each node according to the verified dedicated execution list, and start each node to execute the task. As a preferred embodiment, the preset integrity verification rules, which verify the dedicated execution list according to the integrity verification rules, load the deep learning framework and data resources required by the dedicated execution list onto each node according to the verified dedicated execution list, and start each node to execute the task, include the following steps: S521. Preset integrity verification rules and define the verification dimensions of the dedicated execution list; S522. Perform integrity verification on the dedicated execution list received by each node based on integrity verification rules and verification dimensions; If the verification passes, the corresponding deep learning framework and data resources will be loaded for each node according to the requirements of the dedicated execution list; If the verification fails, the dedicated execution list will be reissued until the verification passes and the resource loading is completed. S523. After each node has completed loading the deep learning framework and data resources and confirmed that there are no errors, start each node to execute the corresponding task.

[0013] S53. Preset data acquisition rules and event-triggered acquisition rules, collect the computing resource utilization and task execution progress of each node at regular intervals according to the data acquisition rules, and collect task accuracy data according to the event-triggered acquisition rules; S54. Structure and store the data on computing resource utilization, task execution progress, and task accuracy.

[0014] S6. Preset execution anomaly threshold, compare historical task execution data with task execution progress, computing resource utilization and task accuracy data based on the execution anomaly threshold, add tags based on the comparison results and store them in the multi-agent task allocation historical scheme database.

[0015] The beneficial effects of this invention are as follows: 1. This invention acquires deep learning task data, node hardware configuration data, and historical task execution data, and constructs a database of historical multi-agent task allocation schemes. It combines the Transformer architecture model with multi-dimensional capability evaluation weighting rules to achieve accurate real-time node capability evaluation. At the same time, it uses the analytic hierarchy process to optimize the weights of evaluation dimensions and a multi-agent negotiation algorithm to generate task allocation schemes. This avoids the problems of one-sided data collection, neglect of hardware differences and real-time status in node capability evaluation, and poor adaptability of allocation schemes to task features in traditional deep learning task allocation. It reduces the risks of wasted computing resources, low task execution efficiency, or substandard accuracy caused by blind allocation. Furthermore, it strengthens the expression of high-priority dimension features through dual-path encoding in the feature embedding layer and a multi-head attention mechanism, ensuring that the node capability evaluation logic conforms to the principles of deep learning technology, avoiding interference from invalid features, and improving the accuracy of evaluation results and the adaptability of allocation schemes.

[0016] 2. This invention achieves dynamic monitoring and tagged storage of task execution data by comparing the initial allocation scheme with historical task execution data item by item, performing secondary verification and adjustment, and combining preset anomaly thresholds. This solves the pain points of traditional allocation schemes that lack historical data support and dynamic optimization mechanisms, reduces the cost of repeated debugging and the iteration cycle of the scheme, and improves the reliability and scalability of task allocation. At the same time, through the integrity verification of the dedicated execution list and the resource loading adaptation process, it ensures the resource readiness before the node task is executed, avoids execution interruption due to missing list or resource mismatch, and ensures the stability of task execution. Attached Figure Description

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

[0018] Figure 1 This is a flowchart of a deep learning task allocation method for multi-agent collaboration according to an embodiment of the present invention. Detailed Implementation

[0019] The specific embodiments of the present invention will be described in further detail below with reference to the accompanying drawings and examples. The following examples are for illustrative purposes only and are not intended to limit the scope of the invention.

[0020] Therefore, the following detailed description of the embodiments of the invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the invention without inventive effort are within the scope of protection of the invention.

[0021] The present invention will now be further described in conjunction with the accompanying drawings and specific embodiments, such as... Figure 1 As shown, the multi-agent collaborative deep learning task allocation method according to an embodiment of the present invention includes the following steps: S1. Acquire deep learning task data, node hardware configuration data, and historical task execution data, and set up a database of historical multi-agent task allocation schemes. Specifically, data acquisition: Deep learning task data is extracted from business systems (such as AI training platforms) or public datasets, including core information such as task type and computing power requirements; node hardware configuration data is collected in real time through hardware management interfaces (such as IPMI) or system commands (lscpu, nvidia-smi), covering CPU parameters, memory, etc.; historical task execution data is exported from node logs and task management systems, including execution time, accuracy, etc.

[0022] Data preprocessing: Clean outliers, fill in missing items, and standardize configuration data and task data to form a structured dataset.

[0023] Database setup: A distributed storage architecture is adopted, which is divided into modules such as task information, node configuration, and historical solutions, and associated with data indexes; multi-agent access permissions are set to ensure data read and write security and support fast querying and reuse of historical solutions during task allocation.

[0024] S2. Extract the core feature parameters of the deep learning task data, and pre-set the task feature mapping rules. Then, convert the core feature parameters into standardized task feature vectors according to the task feature mapping rules. Specifically, from deep learning task data, we focus on five core dimensions: task type (such as image classification, NLP), computing power requirements (GPU memory / floating-point computing power), accuracy requirements (accuracy threshold), data scale (sample size / data dimension), and real-time requirements (latency limit). We extract the original values ​​of parameters through task description parsing and configuration file reading tools.

[0025] Rules are formulated according to feature type. Discrete features (task type) are mapped to binary vectors using one-hot encoding; continuous features (computing power, data scale) are mapped to the [0, 1] interval using Min-Max normalization; Boolean features (real-time requirements) are converted into 0-1 values, and parameter priority weights are established at the same time.

[0026] The mapped feature values ​​are arranged in a fixed order of "task type-computing power-precision-data scale-real-time". They are then integrated into a vector with uniform dimension using a feature splicing tool. Redundant feature terms are removed simultaneously, and the final output is a standardized task feature vector that meets the model input requirements, ensuring that the vector can be directly used for subsequent task allocation calculations.

[0027] S3. Based on the node hardware configuration data, set multi-dimensional capability assessment weighting rules, and adopt the Transformer architecture model to evaluate the real-time capabilities of each node in the node hardware configuration data and generate capability assessment results. In this embodiment of the application, the step of setting multi-dimensional capability evaluation weighting rules based on node hardware configuration data and using the Transformer architecture model to evaluate the real-time capabilities of each node in the node hardware configuration data and generate capability evaluation results includes the following steps: S31. Analyze the specific configuration of the node hardware configuration data and clarify the multi-dimensional capability assessment dimensions; Specifically, data is obtained from the hardware management system or interface (such as IPMI, SNMP), and broken down into four core components according to function: computing unit (number of CPU cores / clock frequency, GPU model / floating point computing power), storage unit (memory capacity / bandwidth, hard disk type / read / write speed), network unit (network card bandwidth / latency, data transmission protocol), and basic information (device model, runtime, heat dissipation capacity), and the specific parameter values ​​of each component are extracted.

[0028] Based on the requirements of deep learning tasks, multiple evaluation dimensions are extracted from the configuration composition, including computing power (related to CPU / GPU parameters), transmission capacity (corresponding to network and storage bandwidth), storage capacity (matching memory / disk indicators), redundancy capacity (based on device operation stability and fault recovery speed), and adaptability (combined with the hardware's compatibility with deep learning frameworks). Each dimension is directly related to the core hardware parameters to ensure that the evaluation closely matches the actual service capabilities of the node.

[0029] S32. Preset weight allocation logic, combine the weight allocation logic with the analytic hierarchy process to set up multi-dimensional capability assessment weighting rules, and allocate initial weights to the multi-dimensional capability assessment dimensions based on the multi-dimensional capability assessment weighting rules. In this embodiment of the application, the preset weight allocation logic, which combines the weight allocation logic with the analytic hierarchy process to set multi-dimensional capability assessment weighting rules, and allocates initial weights to the multi-dimensional capability assessment dimensions based on the multi-dimensional capability assessment weighting rules, includes the following steps: S321. Based on the degree of impact of the evaluation dimensions on task execution efficiency as the core basis for defining the logic, a weight allocation logic is preset, and the priority of dimensions is clarified in combination with the type of deep learning task. Specifically, we first sort out the evaluation dimensions such as computing power and transmission capacity, and review the correlation between each dimension and execution efficiency through historical task data, such as the impact coefficient of computing power fluctuations on execution time. We then combine expert experience to quantify the "level of impact" as the basis for weight allocation.

[0030] Then, a model of "basic weight plus task adaptation coefficient" is established. First, basic weights for each dimension are set according to general scenarios (computing power usually accounts for the highest proportion). Then, an adaptation coefficient interface is reserved for dynamic adjustment based on task type. At the same time, different sorting is performed for different task types. Image training tasks are given priority in computing and storage capacity; NLP inference tasks are given priority in memory bandwidth and transmission capacity; and real-time prediction tasks are given priority in response speed and redundancy. This forms a priority system of "influence degree as the base and task type as the adjustment" to ensure that the weight allocation fits the actual needs.

[0031] S322. Taking the accuracy of node capability assessment as the target layer, computing power, transmission power, and redundancy capability as the criteria layer, and multi-dimensional capability assessment dimensions as the scheme layer, a hierarchical structure of weighted decision-making is constructed by combining the analytic hierarchy process and the subordinate relationship between each level is clarified. Specifically, the first step is to anchor the target layer, taking "accuracy of node capability assessment" as the core objective. This layer is the ultimate guide for weight allocation, and all criteria and schemes revolve around this objective to ensure that the weight design serves the accuracy of the assessment results.

[0032] Secondly, a criteria layer is established, with "computing power, transmission power, and redundancy power" as the core criteria that support the target layer. These three directly determine the scientific nature of the node capability assessment and form a direct subordinate relationship with the target layer. Computing power reflects the node's computing power foundation, transmission power is related to data interaction efficiency, and redundancy power ensures execution stability, jointly supporting the achievement of the assessment accuracy goal.

[0033] Finally, the solution layer is refined, taking multi-dimensional capability assessment dimensions (such as CPU core count, GPU floating-point computing power, network card bandwidth, memory capacity, fault recovery speed, etc.) as specific solutions. The solution layer and the criterion layer form a corresponding subordinate relationship: CPU parameters and peak computing power belong to computing power; network card bandwidth and transmission latency belong to transmission power; device runtime and fault recovery time belong to redundancy capability. This forms a hierarchical structure in which "the target layer governs the criterion layer, and the criterion layer controls the solution layer". The subordinate relationships of each level are clear, providing rigorous structural support for the subsequent judgment matrix construction and weight calculation.

[0034] S323. Based on the weight allocation logic and the hierarchical structure of weight decision, and using the scaling method to construct a judgment matrix, the relative importance of each evaluation dimension is quantified. Specifically, the first step is to clarify the scaling rules and adopt the 1-9 scaling system commonly used in the analytic hierarchy process: 1 indicates that the two dimensions are equally important, 3 indicates that the former is slightly more important, 5 indicates that the former is significantly important, 7 indicates that the former is strongly important, 9 indicates that the former is extremely important, and 2, 4, 6, and 8 are the median values ​​of the corresponding levels, and they satisfy reciprocity (if A is 3 more important than B, then B is 1 / 3 more important than A), ensuring that the judgment logic is consistent.

[0035] The second step is to construct a matrix in layers: First, based on the "accuracy of node capability assessment" of the target layer, a 3×3 judgment matrix is ​​constructed for the "computing capability, transmission capability, and redundancy capability" of the criterion layer. Combined with task requirements (such as heavy computing power for deep learning tasks), a higher scaling value is assigned to computing capability. Then, based on the three criteria, sub-judgment matrices are constructed for the dimensions of the subordinate solution layer (such as CPU / GPU parameters corresponding to computing capability), and values ​​are assigned according to the "priority of efficiency impact" in the weight allocation logic.

[0036] The third step is to verify the rationality of the matrix, ensuring that there are no contradictions in the judgments of each dimension within the same level. The resulting judgment matrix transforms the qualitative description of importance into quantitative values, providing core data support for subsequent calculation of weight vectors and quantification of the contribution of each dimension, making the weight allocation more scientific.

[0037] S324. Calculate the weight vector of the assessment dimension in the multi-dimensional capability assessment dimension using the analytic hierarchy process, and normalize the weight vector to obtain the initial weight value set of the dimension. Specifically, the first step is to calculate the eigenvectors in layers, using the root method (or product method) commonly used in the analytic hierarchy process: for the 3×3 judgment matrix of the criterion layer (computation / transmission / redundancy capability) and the sub-judgment matrices of the scheme layers under each criterion, first calculate the product of the elements in each row of the matrix, and then find the nth root (n is the matrix order) to obtain the initial eigenvectors. These vectors initially reflect the relative importance ranking of each dimension.

[0038] The second step is a consistency check to avoid logical contradictions in the judgment: Calculate the largest eigenvalue λmax of the matrix, derive the consistency index CI=(λmax-n) / (n-1) through the formula, and combine it with the average random consistency index RI (look up the standard table according to the matrix order) to obtain the consistency ratio CR=CI / RI. If CR<0.1, it means that the matrix is ​​consistent; if it is not satisfied, the judgment matrix scale value needs to be adjusted until the check passes.

[0039] The third step is weight vector normalization: The feature vectors that have passed the consistency test are normalized by dividing each element by the sum of all elements in the vector, so that the sum of the weight values ​​of each dimension after normalization is 1. Combining the weights of the criterion layer and the sub-weights of the scheme layer, the initial weight value set of the multi-dimensional capability assessment dimensions is obtained by weighted summation. This set quantifies the contribution of each assessment dimension to the node capability assessment, providing the core basis for subsequent weighted assessment.

[0040] S325. Verify the rationality of the initial weight set of dimensions, and use the initial weight values ​​of dimensions that pass the rationality verification as the initial weights of the multi-dimensional capability assessment weighting rules.

[0041] Specifically, first, perform basic logic verification, review the consistency results of the analytic hierarchy process, confirm that the CR values ​​of all judgment matrices are less than 0.1, and at the same time check the matching degree between the weight distribution and the weight allocation logic. For example, in deep learning tasks, the weights of the subordinate dimensions of computing power should be significantly higher than the redundant capabilities to avoid the core dimension weights being reversed. If a logical contradiction occurs, backtrack to adjust the scale values ​​of the judgment matrices and recalculate the weights.

[0042] Secondly, conduct practical adaptability verification by constructing a test set based on historical task data: substitute the initial weights into the node capability assessment model, compare the correlation between the assessment results and the historical task execution efficiency (such as time consumption and accuracy), and if the fit between the weighted assessment score and the actual performance is less than 0.8, the weights of the core dimensions need to be fine-tuned to enhance adaptability.

[0043] Finally, dynamic scenario verification is performed. Different types of deep learning tasks (such as image training and NLP inference) are selected to test the stability of the weights in multiple scenarios to ensure that no single scenario weights fail. After verification, the initial weight value set is solidified, and the weight ratio of each dimension is clarified as the initial weight of the multi-dimensional capability evaluation weighting rule to support the accurate quantitative evaluation of subsequent node capabilities.

[0044] S33. Collect real-time operating status data of each node, and integrate the real-time operating status data with the node hardware configuration data to form a node comprehensive evaluation dataset; Specifically, firstly, computing status data such as CPU utilization, memory usage, and video memory load are collected through the hardware monitoring interface (IPMI), system commands (nvidia-smi, lscpu), and monitoring tools (Prometheus); network status data such as bandwidth utilization and data transmission latency are obtained using network monitoring tools (iftop); and stable status data such as device temperature and fan speed are extracted through thermal sensors and system logs. A "10-second timed collection plus anomaly-triggered collection" mechanism is adopted to ensure data real-time performance and anomaly detection capabilities.

[0045] Secondly, the parsed node configuration data (number of CPU cores, GPU model, etc.) is retrieved from the hardware management system. Using the "unique node identifier" as an index, the real-time status data and configuration data are aligned according to the dimension of "hardware basic parameters - real-time operating indicators" to establish a one-to-one correspondence.

[0046] Finally, outliers caused by instantaneous fluctuations are cleaned up, missing data items are filled in, and real-time data is standardized (e.g., usage rate is converted into [0, 1] values). The data is then integrated into a structured node comprehensive evaluation dataset containing "configuration parameters - real-time status - timestamps", providing comprehensive and accurate input data for subsequent capability assessment models.

[0047] S34. Construct a capability assessment model based on the Transformer architecture, input the node comprehensive assessment dataset into the capability assessment model, and obtain the comprehensive assessment results; In this embodiment of the application, the construction of a capability assessment model based on the Transformer architecture, which involves inputting a node comprehensive assessment dataset into the capability assessment model to obtain a comprehensive assessment result, includes the following steps: S341. Decompose the core component layers of the capability assessment model based on the Transformer architecture to obtain the data input layer, feature embedding layer, multi-head attention encoder layer and result output layer, and connect the data input layer, feature embedding layer, multi-head attention encoder layer and result output layer in series through the data interface. Specifically, the core components are first precisely broken down and their functional roles clearly defined: First, the data input layer, serving as the model's data entry point, is responsible for receiving the node comprehensive evaluation dataset (static hardware configuration + dynamic real-time status data) and completing data format verification and initial encapsulation; second, the feature embedding layer, whose core function is dual-path encoding, performs numerical embedding on static data and temporal embedding on dynamic data to generate high-dimensional feature vectors; third, the multi-head attention encoder layer, which mines the feature correlations of each evaluation dimension through a self-attention mechanism, strengthens the expression of high-priority dimensions, and outputs the fused comprehensive features; fourth, the result output layer, composed of a fully connected neural network, is responsible for mapping the comprehensive feature vector to a quantified evaluation value, forming the node capability evaluation result.

[0048] Secondly, for the data output formats of each layer (such as tensors with unified dimensions in the embedding layer and feature vectors in the encoder layer), customized adaptation interfaces are developed, and data transmission protocols and format specifications are clearly defined to ensure that the output data of the previous layer can be directly connected to the input port of the next layer, thus avoiding format conflicts.

[0049] Finally, the data flow logic is sequentially connected: in the order of "data input layer - feature embedding layer - multi-head attention encoder layer - result output layer", hard connections are made between layers through preset interfaces to build a complete model link. After the connection is made, data transmission test is performed to verify the continuity of data reception, processing and output of each layer, ensuring that the model can smoothly complete the entire process of operation from data input to evaluation result output, and providing stable architectural support for node capability evaluation.

[0050] S342. Divide the node comprehensive evaluation dataset into static hardware configuration data and dynamic real-time status data, and use numerical standardization to process the static hardware configuration data and time-series serialization to process the dynamic real-time status data, and summarize to obtain standardized input data. Specifically, firstly, the data is categorized according to its attribute characteristics: using "whether it changes dynamically with task execution" as the defining criterion, static hardware configuration data and dynamic real-time status data are extracted from the dataset. Static data consists of inherent hardware attributes, including fixed parameters such as the number of CPU cores, GPU model, and memory capacity, and is archived with a "unique node identifier." Dynamic data consists of real-time fluctuation indicators, covering CPU utilization, memory load, network bandwidth usage, etc., and is stored in a categorized manner with associated collection timestamps. The two types of data are linked by node identifiers to avoid confusion.

[0051] Secondly, data processing is performed by category: static data is normalized using Min-Max, mapping different dimensional parameters (such as memory "GB" and computing power "TFLOPS") to the [0,1] interval, and categorized data such as CPU model is converted into numerical form using one-hot encoding to eliminate dimensional interference; dynamic data is sorted by timestamp and then serialized into time series, constructing a fixed-length time series with "1 minute" as the time window, and filling in missing values ​​through linear interpolation to preserve the temporal correlation of the data and generate a time series matrix.

[0052] Finally, standardized input data is formed by summarizing the processed static data (feature vectors with uniform dimensions) and dynamic data (time series tensors with fixed lengths) according to "node identifier plus timestamp". The data is then integrated into standardized input data with a uniform structure using a feature splicing tool. The data dimensions and format are verified simultaneously to ensure that the data can be directly input into the model data input layer.

[0053] S343. The standardized input data is input into the model data input layer. The feature embedding layer performs dual-path encoding on the static hardware data and dynamic time series data in the standardized input data. The two types of vectors are concatenated by the feature fusion operator to obtain a node feature tensor with uniform dimension. In this embodiment of the application, the step of inputting standardized input data into the model data input layer, performing dual-path encoding on the static hardware data and dynamic time-series data in the standardized input data by the feature embedding layer, and concatenating the two types of vectors through a feature fusion operator to obtain a node feature tensor with uniform dimension includes the following steps: S3431. Input standardized input data into the model data input layer, and clarify the adaptation encoding method of the feature embedding layer for static hardware data and dynamic time series data. Specifically, firstly, using "unique node identifier + timestamp" as an index, the integrated static hardware data and dynamic time-series data are input in batches. The input layer first performs format validation (such as vector dimension and data type) to remove data with abnormal format. Then, the data encapsulation tool packages the two types of data into input units that are adapted to the embedding layer to ensure lossless data transmission.

[0054] Secondly, for static hardware data, encoding rules are formulated according to feature type. Categorical features (such as GPU model and hard disk type) are encoded using one-hot encoding and converted into binary vectors to preserve category differences. Numerical features (such as CPU frequency and memory capacity) are mapped to fixed-dimensional high-dimensional vectors through a fully connected embedding layer to maintain the quantitative correlation between values. For dynamic time-series data, a combination of positional encoding and temporal embedding is adopted: first, time step information is injected through positional encoding to avoid loss of temporal order, and then the encoded time-series data is mapped to feature vectors with the same dimension as the static data to ensure the feasibility of subsequent fusion.

[0055] Finally, the embedding dimensions of static and dynamic data are set (e.g., both are set to 256 dimensions), and the activation function (e.g., ReLU) and weight initialization method of the encoding layer are specified to ensure that the output format of the two types of data is consistent and the dimensions are matched after encoding. This lays the foundation for subsequent dual-path encoding and vector fusion of the feature embedding layer, while ensuring that the encoding results are adapted to the input requirements of the multi-head attention encoder layer.

[0056] S3432. The static hardware data in the standardized input data is encoded using one-hot encoding in the feature embedding layer according to the adaptive encoding method to generate hardware feature vectors, and the dynamic time-series data in the standardized input data is encoded using position encoding to generate time-series feature vectors. Specifically, the feature embedding layer is first invoked to load the preset dual-channel encoding module, which then connects to standardized static hardware data and dynamic time-series data respectively. For static hardware data, one-hot encoding is performed on categorical features (such as GPU model and hard drive type): first, a feature value-index mapping dictionary is constructed to convert discrete feature values ​​into unique indices, and then a binary vector of the same length as the number of feature categories is generated, with the corresponding index position set to 1 and the rest to 0; for numerical static data (such as CPU clock speed), the dimensions are first unified through linear transformation, and then concatenated with the one-hot encoding result to finally generate a hardware feature vector with fixed dimensions, preserving the integrity of hardware attributes.

[0057] For dynamic time-series data, position encoding is used to generate time-series feature vectors: First, the data is sorted by timestamp to ensure the time sequence. A position encoding matrix is ​​constructed based on a sine function to convert the position information at different time steps into high-dimensional vectors, avoiding the loss of time-series correlations in the model. Then, the position encoding vectors are added element-wise to the dynamic data (such as real-time computing load), and mapped to fixed-dimensional vectors through a fully connected network in the embedding layer. Simultaneously, LayerNorm is used for normalization to eliminate the impact of data fluctuations and generate time-series feature vectors. After encoding, the consistency of the dimensions of the two types of vectors is verified (e.g., both are set to 256 dimensions) to ensure that the hardware feature vectors and time-series feature vectors are compatible in format, providing a foundation for subsequent fusion processing.

[0058] S3433: Call the feature fusion operator to perform dimension alignment and concatenation processing on the hardware feature vector and the temporal feature vector to obtain a node feature tensor with unified dimensions.

[0059] Specifically, the original dimensions of the two types of vectors are first read (e.g., both are 256-dimensional). The dimension detection module of the feature fusion operator is used to verify the consistency of the vector dimensions. If there are dimension differences (e.g., hardware vectors are 256-dimensional and time-series vectors are 128-dimensional), the linear projection layer built into the operator is called to map the low-dimensional vectors to the target dimension (e.g., to unify them to 256-dimensional). Orthogonal initialization is used during the projection process to ensure that feature information is not lost. At the same time, the LayerNorm layer is used for normalization to eliminate the interference of dimensional differences on the fusion effect.

[0060] Secondly, the feature concatenation operator is selected, and the two types of vectors are concatenated along the feature dimension (axis=-1) in a fixed order of "hardware features first, time series features second". The 256-dimensional hardware vector and the 256-dimensional time series vector are merged into a 512-dimensional high-dimensional feature vector. During the concatenation, the "node identifier + timestamp" metadata of the vector association is retained to ensure that the features correspond one-to-one with the nodes and time series information, providing a basis for subsequent feature association calculation.

[0061] Finally, the fusion operator automatically reshapes the concatenated high-dimensional vector into a three-dimensional node feature tensor (format: [number of nodes, feature dimension, time step]), adapting it to the input requirements of the Transformer model; it simultaneously verifies the tensor dimension, data type, and numerical range, removes abnormal tensors, and finally outputs a node feature tensor with uniform dimension and close feature correlation, providing high-quality input for feature mining in the multi-head attention encoder layer.

[0062] S344. Input the node feature tensor into the multi-head attention encoder layer, set the number of attention heads, and calculate the correlation weight of each evaluation dimension feature through the self-attention mechanism to strengthen the feature expression of high priority dimensions and obtain the node comprehensive feature vector. In this embodiment of the application, the steps of inputting the node feature tensor into the multi-head attention encoder layer, setting the number of attention heads, and calculating the correlation weights of features in each evaluation dimension through a self-attention mechanism to strengthen the feature representation of high-priority dimensions and obtain the node comprehensive feature vector include the following steps: S3441. Input the node feature tensor into the multi-head attention encoder layer, preset the threshold for the number of attention heads, and match the node feature tensor with the threshold for the number of attention heads. Set the number of attention heads based on the matching result to complete the model parameter configuration. Specifically, the three-dimensional node feature tensors ([number of nodes, feature dimension, time step]) are first input into the multi-head attention encoder layer in batches according to the model input protocol. The tensor data type and dimension range are first confirmed to meet the requirements by the in-layer format verification module. Then, the tensors are flattened (such as merging the feature dimension and time step into the total feature dimension) to provide a unified calculation benchmark for head number matching.

[0063] Secondly, a threshold range for the number of attention heads is preset: Based on the engineering practice of Transformer models, a reasonable range of attention heads (2-16 heads) is set, and the threshold range is divided according to the feature dimension. Low-dimensional tensors (≤256 dimensions) correspond to a threshold of 2-4 heads, medium-dimensional tensors (257-512 dimensions) correspond to 4-8 heads, and high-dimensional tensors (>512 dimensions) correspond to 8-16 heads. At the same time, it is clear that the number of heads should be a divisor of the total feature dimension to avoid information fragmentation when splitting features.

[0064] Finally, dimension matching and head count setting: Extract the total feature dimension of the preprocessed tensor and compare it with the preset threshold range. If the tensor dimension is 512, match the mid-dimensional range and select 8 heads. Then, solidify the head count parameter and simultaneously configure related parameters such as the attention dropout ratio (e.g., 0.1) and hidden layer dimension (consistent with the feature dimension) to complete the model parameter configuration. After configuration, perform trial operation to verify that the sub-feature dimensions after head segmentation are uniform and that the encoder layer can perform attention association calculations normally.

[0065] S3442. The self-attention mechanism is used to perform correlation calculation on the features of each evaluation dimension in the node feature tensor to obtain the correlation weights corresponding to each dimension. Based on the correlation weights, the feature expression of high priority dimensions is strengthened to obtain the node comprehensive feature vector.

[0066] Specifically, the input three-dimensional tensor ([number of nodes, feature dimension, time step]) is first passed into the multi-head attention encoder layer, and then a query (Q), key (K), and value (V) matrix is ​​generated through linear transformation. The dimensions of the three matrices are consistent with the original tensor. Q corresponds to the feature to be evaluated, and K / V corresponds to the associated features and value information, providing a basis for association calculation.

[0067] Secondly, the similarity matrix between Q and K is calculated using the dot product method. The numerical deviation caused by dimensional expansion is suppressed by the scaling factor (square root of feature dimension). Then, the Softmax function is used for normalization to obtain the correlation weight of each evaluation dimension (such as computing / transmission capability). The higher the weight value, the stronger the correlation between the dimension and the node capability evaluation, and the higher the priority dimension preset in the early stage is naturally matched.

[0068] Finally, the normalized correlation weights are multiplied by the V matrix to amplify the value of high-priority features (such as GPU computing power and bandwidth metrics) and weaken low-correlation features. Subsequently, through multi-head attention fusion (splitting the outputs of each attention head and linearly mapping) and residual connection (superimposing the original tensor features), complete information is preserved and core features are strengthened. The final output is a node comprehensive feature vector with unified dimensions and prominent key points, which can meet the quantization mapping requirements of the subsequent result output layer.

[0069] S345. Input the node comprehensive feature vector into the result output layer, and map the feature vector into a quantitative evaluation value through a fully connected neural network to form a comprehensive evaluation result.

[0070] Specifically, firstly, the node comprehensive feature vectors (e.g., 256-dimensional) are batch-input into the output layer. The vector dimension and data type are first verified through the input interface to remove outliers. Then, the BatchNorm layer is used for standardization to eliminate the interference of feature distribution differences on the mapping effect and provide stable input for the fully connected network.

[0071] Secondly, the output layer adopts a "double hidden layer plus output layer" structure. The first hidden layer performs non-linear feature transformation on the input vector through the ReLU activation function to enhance the expression of core features. The second hidden layer introduces Dropout (scale 0.1) to prevent overfitting and further compress redundant features. The output layer is a single neuron structure, which maps high-dimensional features to the original quantized value of [0, 1] through the Sigmoid function. This value initially reflects the comprehensive ability level of the node.

[0072] Finally, based on the evaluation requirements, the original quantitative values ​​are calibrated to an intuitive score of [0, 100] according to the rule of "[0, 0.4) low energy, [0.4, 0.8) medium energy, [0.8, 1] high energy"; the contribution ratio of each evaluation dimension is simultaneously associated (e.g., computing power contributes 60%), forming a comprehensive evaluation result of "comprehensive score plus dimension decomposition".

[0073] S35. Preset the result threshold division rules, and use the result threshold division rules to classify the comprehensive ability assessment results and generate the ability assessment results.

[0074] Specifically, based on historical task execution data, the correlation between node capability assessment scores and task adaptation effects is statistically analyzed. Combined with the computational power requirements of different deep learning tasks (such as image training and NLP inference), the core basis for threshold setting is determined. Using a "statistical analysis plus clustering assistance" approach, the historical assessment scores are clustered using the K-means algorithm to initially divide the threshold range. Then, combined with expert experience, it is fine-tuned, and finally, four threshold rules are preset: [0, 30) for low capability, [30, 60) for average capability, [60, 85) for good capability, and [85, 100] for excellent capability. The corresponding task type and scenario for each level are clearly defined.

[0075] Secondly, the comprehensive capability assessment score (quantified value and dimensional contribution ratio) is input into the grading module. The validity of the score is first verified (e.g., whether it is in the range of [0,100]), outliers are removed and backtracked for correction. Then, the valid score is compared and matched with the preset threshold to determine the node capability level and the core supporting dimensions are labeled simultaneously (e.g., "good capability, 70% contribution of computing capability").

[0076] Finally, the "capability level plus core dimension description plus suitable task suggestions" are integrated and output in a structured format to ensure that the results are intuitive and easy to understand. This provides a clear basis for node capabilities in subsequent task allocation for multi-agent systems. At the same time, the classification results are synchronously stored in the historical scheme database to accumulate data for threshold rule iteration.

[0077] S4. Preset multi-agent collaborative allocation rules, use multi-agent negotiation algorithm to combine standardized task feature vectors and capability evaluation results to obtain task allocation scheme, and verify and adjust the task allocation scheme with historical task execution data; In this embodiment of the application, the preset multi-agent collaborative allocation rule, which uses a multi-agent negotiation algorithm combined with standardized task feature vectors and capability assessment results to obtain a task allocation scheme, and verifies and adjusts the task allocation scheme with historical task execution data, includes the following steps: S41. Preset multi-agent collaborative allocation rules and multi-agent negotiation algorithm, set the input parameters of the multi-agent negotiation algorithm as standardized task feature vector and capability evaluation results, and set the core optimization objective of the multi-agent negotiation algorithm; Specifically, firstly, based on the core principles of "matching task requirements, efficient resource utilization, and load balancing," three types of rules are formulated: priority rules (real-time prediction tasks are preferentially allocated to high-capacity nodes), adaptation rules (high-computing-power tasks are bound to nodes with outstanding computing capabilities), and constraint rules (the task load of a single node does not exceed 70% of its capacity limit to avoid overload). These rules are embedded with a conflict resolution mechanism. When multiple agents have conflicting demands, the urgency of the task is used as the basis for adjudication to ensure orderly allocation.

[0078] Secondly, the ContractNet algorithm (adapted to distributed decision-making scenarios) is selected, and the roles of intelligent agents are clearly defined. The task intelligent agent is responsible for publishing requirements, the node intelligent agents respond to bids, and the coordinating intelligent agent coordinates the review. The ContractNet algorithm has a built-in closed-loop process of "bidding-evaluation-success". In the bidding stage, the node intelligent agents quote prices based on their own capabilities, and in the evaluation stage, the scores are quantified according to the allocation rules, which improves the efficiency of negotiation.

[0079] Finally, the standardized task feature vector (including task type, computing power / precision requirements, etc.) and the node capability evaluation results (level, core dimension contribution) are set as core input parameters to ensure that the algorithm obtains complete decision-making basis. The core optimization objectives focus on four dimensions: maximizing task completion efficiency (latency reduction of more than 20%), maximizing resource utilization (node ​​computing power utilization ≥ 65%), optimizing load balancing (node ​​load variance ≤ 0.1) and achieving 100% task accuracy. By weighted summation, multiple objectives are transformed into a single optimization function, providing a clear direction for algorithm iteration.

[0080] S42. Based on the multi-agent negotiation algorithm and the core optimization objective, set up a dynamic allocation model, input the standardized task feature vector and the capability assessment results into the dynamic allocation model, and obtain the initial allocation scheme. Specifically, the Contract Network algorithm is used as the core framework to build an "input layer-decision layer-output layer" structure. The input layer is responsible for data reception and parsing; the decision layer embeds an optimization objective weighting function (efficiency 40%, resource utilization 30%, load balancing 20%, accuracy 10%), integrates multi-agent negotiation logic, and binds the bidding score with the optimization objective; the output layer defines the initial scheme format, including task-node matching relationship and expected indicators.

[0081] Then, the standardized task feature vector (including type, computing power requirements, etc.) and the node capability assessment results (level, core dimensions) are aligned using the "task ID-node ID" dual index and input into the model input layer. Simultaneously, the data integrity is verified, and missing information such as task priority and node load is supplemented to ensure sufficient basis for decision-making.

[0082] Furthermore, the task agents publish requirements in order of priority, and the node agents generate bidding information based on their own capabilities; the coordinating agent calls the decision layer algorithm, quantifies and scores according to the optimization target, selects the node with the highest score to match the task, generates the initial plan, verifies whether the node load exceeds the 70% limit, fine-tunes the overload matching relationship, and finally outputs a structured initial allocation plan containing "task allocation result, expected time consumption, and accuracy guarantee value", which provides a foundation for subsequent optimization.

[0083] S43. Extract key comparison dimensions from historical task execution data, compare the initial allocation scheme with the historical task execution data item by item, and adjust the initial allocation scheme based on the comparison results to generate a task allocation scheme. In this embodiment of the application, the steps of extracting key comparison dimensions from historical task execution data, comparing the initial allocation scheme with the historical task execution data item by item, and adjusting the initial allocation scheme based on the item-by-item comparison results to generate a task allocation scheme include the following steps: S431. Based on the core indicators of the initial allocation scheme, determine the key comparison dimensions, extract relevant data corresponding to the key comparison dimensions from the historical task execution data, and form a standardized comparison dataset. Specifically, firstly, based on the core metrics of the initial allocation scheme (task completion time, accuracy achievement rate, node computing power utilization, and load balancing), and combined with the characteristics of tasks and nodes, key comparison dimensions are determined: on the task side, these include type, computing power requirement, and priority; on the node side, they include capability level, contribution to core dimensions, and historical peak load; and on the matching side, they include task-node matching type and expected execution metrics. Each dimension is strongly correlated with the optimization objective, ensuring the comparison is targeted.

[0084] Secondly, data is filtered from the multi-agent task allocation history database according to the principle of "similar task type and matching node capability level": historical records within the past 3 months that are of the same type as the current task (such as image training) and have the same node capability level are extracted, and fields corresponding to key comparison dimensions are extracted, such as the actual time consumption, accuracy, and real-time utilization rate of the historical task, and invalid data with execution abnormalities (such as sudden failures) are removed.

[0085] Finally, the extracted historical data was cleaned, deduplicated, and missing values ​​were filled in. Min-Max normalization was used to map continuous data such as time consumption and utilization rate to the [0,1] interval. Discrete data such as task type were one-hot encoded and integrated according to the structure of "task information-node information-matching result-execution index" to form a standardized comparison dataset with unified fields and aligned dimensions, providing data support for the optimization and verification of the initial scheme.

[0086] S432. Establish a comparison mapping relationship between the initial allocation scheme and historical task execution data, compare the initial allocation scheme with the standardized comparison dataset item by item, and use the difference calculation method to quantify the data comparison deviation. Specifically, a two-way mapping is established using "task-node" matching pairs as the core index: on the task side, tasks are associated with historical task data based on the combination of "type-computing power requirement-priority" features; on the node side, nodes are matched with historical execution records of nodes of the same level based on the identifier of "capability level-core dimension contribution"; at the key indicator level, the "expected time consumption, accuracy guarantee value, and computing power utilization" of the initial plan are clearly correlated with the "actual time consumption, actual accuracy, and actual utilization" of historical data, forming a complete mapping system.

[0087] Then, the initial allocation scheme data is standardized (with dimensions and units consistent with the comparison dataset), and compared item by item in the order of "task characteristics - node characteristics - matching indicators": the task side verifies the matching degree of computing power requirements, the node side checks the adaptability of capability levels, and the matching side focuses on comparing the differences between the expected values ​​and historical values ​​of core indicators, and records the mismatch items and reasons simultaneously.

[0088] Continuous indicators (time consumption, utilization rate) are directly calculated as the absolute difference between "scheme value - historical average". Discrete indicators (task type matching) are quantified as "matching is 0, mismatching is 1". Key indicators such as time consumption and accuracy are weighted (weights are the same as the optimization target) to obtain a comprehensive deviation value. The deviation result provides a clear direction for subsequent scheme optimization. Matching pairs with a difference exceeding the threshold (such as 20%) need to be adjusted first.

[0089] S433. Preset a data deviation threshold, compare the data deviation threshold with the data comparison deviation, and adjust the standardized comparison dataset according to the comparison results to generate a task allocation scheme.

[0090] Specifically, firstly, based on historical data fluctuation patterns and task optimization goals, differentiated thresholds are set for different indicators: core indicators (task time and accuracy) are set with strict thresholds based on 3 times the standard deviation (e.g., time deviation ≤5%, accuracy deviation ≤2%), while the thresholds for secondary indicators (load balancing) are relaxed to ≤10%; at the same time, combined with task priority weighting, the threshold for real-time tasks is compressed by 30%, while the threshold for non-real-time tasks can be increased by 20%, forming a dynamic threshold system of "basic threshold plus priority coefficient".

[0091] Secondly, the quantified individual deviations and the overall weighted deviations are compared with the corresponding thresholds one by one, and the matching pairs are marked as "deviation exceeds the standard" and "deviation is acceptable". For example, if the expected time of a task deviates from the historical average by 8%, and exceeds the 5% threshold, it is judged as exceeding the standard, and the dimension and magnitude of the exceeding standard are recorded simultaneously.

[0092] Finally, for the non-compliant matching pairs, the standardized comparison dataset is backtracked to remove outdated (such as old hardware) and abnormal data, and new data of the same type is added to recalculate the baseline value. Based on the corrected dataset and the qualified deviation results, the initial plan is optimized, and the non-compliant tasks are reassigned to nodes with better capabilities. After verifying that the node load does not exceed the 70% limit, the final task allocation plan containing "task-node matching, expected indicators, and deviation range" is output and updated synchronously to the task management system.

[0093] S44. Perform a secondary comparison and verification of the task allocation scheme with historical task execution data, preset the verification adjustment threshold and verification adjustment rule set, and compare the secondary comparison and verification results with the verification adjustment threshold for threshold adjustment. Specifically, the core dimensions and data scope of the secondary verification are first clarified. The focus is on the supplementary indicators such as "task completion rate, resource waste rate, and adaptability to sudden failures" of the solution after the initial optimization. Combined with the original core indicators (time consumption and accuracy), the execution data of "same task type, same node configuration, and similar load scenarios" within the past month are extracted from the historical database. After removing extreme values, the historical average and fluctuation range of each indicator are calculated as the verification benchmark.

[0094] Secondly, preset verification and adjustment thresholds and rule sets are used, with thresholds set according to the "importance of indicators": critical indicators (real-time task response latency) threshold ≤3%, important indicators (computing power utilization) ≤8%, and general indicators (storage usage) ≤15%. The rule set is clear: slight deviations (within the threshold) are marked as requiring no adjustment; moderate deviations (1-2 times the threshold) trigger node load fine-tuning; severe deviations (more than 2 times the threshold) initiate the task reallocation process, and the reason for the adjustment is recorded simultaneously.

[0095] Finally, a second comparison and threshold adjustment are performed. The expected indicators of the solution are compared with the historical benchmark data item by item. The deviation value is calculated and compared with the verification threshold. If the response delay of a real-time task deviates by 4% (exceeding the 3% threshold), it is judged as a moderate deviation, and the rule set is called to fine-tune the resource allocation. If the deviation is qualified, the solution is retained. Finally, a verification report of "secondary verification result plus deviation level plus adjustment suggestion" is output, which provides double protection for the implementation of the solution.

[0096] S45. Match the threshold adjustment comparison results with the verification adjustment rules in the verification adjustment rule set, and adjust the task allocation scheme based on the matched verification adjustment rules.

[0097] Specifically, firstly, the structured output threshold adjustment comparison results are organized according to the format of "task ID-deviation index-deviation value-deviation level". The core problem of each matching pair is clarified, such as "task T01-response delay deviation 4%-moderate deviation". This ensures that the result dimensions are fully aligned with the verification adjustment rule set (including the fields of "deviation level-adjustment measures-applicable scenarios"), laying the foundation for matching.

[0098] Secondly, the execution rules are precisely matched using a "keyword matching plus priority sorting" mechanism: first, the "deviation level" is used as the core keyword to match the basic measures corresponding to the level in the rule set (such as matching "resource fine-tuning point" for moderate deviation); then, a second screening is performed by combining "task type plus node characteristics". For example, moderate deviation of real-time tasks is preferentially matched with the "CPU resource expansion" rule, while non-real-time tasks are matched with the "load migration" rule to ensure that the measures are targeted.

[0099] Next, the tiered execution plan is adjusted. Minor deviations (within the threshold) are only marked and the original plan is retained; moderate deviations are fine-tuned according to the rules, such as migrating one non-real-time task on a high-load node to an idle node to optimize load balancing; severe deviations (exceeding twice the threshold) are redistributed, replacing nodes with mismatched capabilities, and the expected indicators of the tasks are updated synchronously.

[0100] Finally, a closed-loop verification of the adjustment effect is performed by comparing the adjusted plan with historical data a second time to confirm that all indicator deviations have been reduced to within the threshold and that node load has not exceeded the 70% upper limit. The final output includes an optimization plan with "Adjustment Measures - Effect Description", providing a reliable basis for task implementation.

[0101] S5. The verified and adjusted task allocation scheme is sent to each node in the node hardware configuration data for task execution, and the task execution progress, computing resource utilization and task accuracy data of each node are collected in real time. In this embodiment of the application, the step of distributing the verified and adjusted task allocation scheme to each node in the node hardware configuration data for task execution, and collecting the task execution progress, computing resource utilization, and task accuracy data of each node in real time includes the following steps: S51. Decompose the verified and adjusted task allocation scheme into a dedicated execution list for each node, and send the dedicated execution list to each node in the node hardware configuration data. Specifically, firstly, the allocation scheme is decomposed according to the node dimension. Using the "unique node identifier" as the core index, all matching tasks corresponding to the node are extracted from the scheme. Cross-node association items are removed to form a single-node task set. During decomposition, the task dependency relationship is checked simultaneously. For example, if task B needs to be executed after task A is completed, the preconditions are marked in the list to avoid the execution order being chaotic.

[0102] Secondly, a standardized execution list is constructed for each node. The list adopts a three-part structure of "task information - execution requirements - resource configuration". The task information includes ID, type and priority; the execution requirements specify the start time window, precision threshold and output format; the resource configuration marks parameters such as CPU / GPU computing power quota and memory usage limit, and generates a unique check code for the list to prevent transmission or tampering errors. The format is adapted to the hardware management system interface of each node.

[0103] Finally, targeted delivery and reception confirmation are performed. Based on the communication protocol (such as HTTPAPI, MQTT) in the node hardware configuration data, the list is delivered via an encrypted channel. After delivery, a 10-second timeout retry mechanism is initiated; if no confirmation is received from a node, the list is re-pushed. Upon receiving the list, the node verifies the checksum against its local configuration. If correct, it returns a "successful reception" receipt; otherwise, it reports the specific exception (such as exceeding the hardware limit). After all nodes confirm, a delivery completion report is generated and synchronized to the task monitoring platform for real-time tracking.

[0104] S52. Preset integrity verification rules: Verify the dedicated execution list according to the integrity verification rules, load the deep learning framework and data resources required by the dedicated execution list for each node according to the verified dedicated execution list, and start each node to execute the task. In this embodiment of the application, the preset integrity verification rules, which verify the dedicated execution list according to the integrity verification rules, load the deep learning framework and data resources required by the dedicated execution list onto each node according to the verified dedicated execution list, and start each node to execute the task, include the following steps: S521. Preset integrity verification rules and define the verification dimensions of the dedicated execution list; Specifically, with the goal of "nodes can be executed directly, task information is complete, and resource configuration is not exceeded", the basis for rule formulation is extracted by combining task type (real-time / non-real-time), node hardware parameters (CPU / GPU model, memory capacity) and execution requirements (time window, precision threshold) to avoid the rules from being out of touch with the actual execution scenario.

[0105] Secondly, three main verification dimensions and their sub-indicators are defined. The first is the structural integrity dimension, ensuring that the list format is standardized: it must include basic fields such as unique node identifier, list generation time, and check code. Task items are arranged in descending order of priority, and each task must be associated with an independent ID and status identifier (pending execution / in execution). The second is the content integrity dimension, ensuring that the task information is comprehensive: it must cover core information such as task type, start time window, accuracy requirements, and output data format. Resource configuration items must clearly define quantitative indicators such as CPU / GPU computing power quota and memory usage limit. The third is the adaptation integrity dimension, ensuring that execution is feasible: the resource requirements of the verification task do not exceed the node hardware limit, the task dependencies (such as the ID of the preceding task) are clearly marked, and the node load after aggregation does not exceed 70% of the threshold.

[0106] Finally, general rules cover all lists (such as required fields not being empty, check code matching); specific rules are for special scenarios (such as real-time tasks needing to check "time window error ≤ 1 second", and high-computing-power tasks needing to check "GPU memory reservation ≥ 20%)", while clarifying the verification process: first structural verification, then content and adaptation verification, and anomalies are marked with "missing type plus correction suggestions", providing a clear direction for list correction.

[0107] S522. Perform integrity verification on the dedicated execution list received by each node based on integrity verification rules and verification dimensions; Specifically, after receiving the dedicated execution list, the node calls the built-in verification module to verify in the order of "structure-content-adaptation": the structure layer checks whether the node identifier, check code and other required fields are complete, and whether the list format matches the hardware system interface; the content layer checks whether core information such as task ID, start time, and precision requirements are missing, and whether the dependency relationships are clearly marked; the adaptation layer obtains the node's computing power, memory and other parameters in real time through the hardware interface, and compares whether the resource requirements in the list exceed the limits (such as GPU memory requirements ≤ 80% of the actual capacity). The verification results are synchronously generated into a report containing "pass / fail plus details of exceptions".

[0108] If the verification passes, the corresponding deep learning framework and data resources will be loaded for each node according to the requirements of the dedicated execution list; Specifically, if the verification passes, resource loading is executed immediately. Based on the task type in the list, the appropriate deep learning framework is automatically matched and loaded (e.g., PyTorch for CV tasks, TensorFlow for NLP tasks), ensuring that the framework version is consistent with the task dependencies; data resources are pulled through an encrypted channel, preprocessed and partitioned for storage as required by the list, while reserving 10% of system resources to cope with sudden demands. After loading is complete, the "ready" status is reported to the monitoring platform.

[0109] If the verification fails, the dedicated execution list will be reissued until the verification passes and the resource loading is completed. Specifically, if the verification fails, a re-issuance process is triggered: the node reports the details of the abnormal items (such as "computing power demand exceeds the limit") to the allocation system. After the system corrects the error, it regenerates the list and encrypts it before issuing it, initiating a 3-retry mechanism. If the verification still fails after 3 attempts, manual intervention is triggered to locate the error in the list or the node's hardware failure. The resource loading process is repeated until the verification passes, ensuring that the task execution is based on a reliable foundation.

[0110] S523. After each node has completed loading the deep learning framework and data resources and confirmed that there are no errors, start each node to execute the corresponding task.

[0111] Specifically, firstly, after each node completes the framework and data loading, it automatically pushes a "resource ready" confirmation message to the central task monitoring platform. The message includes core credentials such as the loaded framework version, data integrity check code, and real-time hardware resource utilization (e.g., CPU / GPU utilization ≤ 10%). The platform then uses the "node ID" as an index to build a status summary table, marks nodes that have not responded, and triggers a 5-second timeout reminder to ensure that no node is missed.

[0112] Secondly, the platform double-checks the node status against the dedicated execution list: first, credential verification, checking that the framework version and data verification code are consistent with the list; second, hardware verification, checking through remote interface that the node has sufficient reserved resources such as memory and video memory (e.g., reserved ≥20% to cope with peak tasks) and that there are no other background processes consuming resources. If there are any mismatches, the node is immediately notified to reload and the cause is traced.

[0113] Subsequently, for tasks without dependencies, the platform issues a unified start command, and the nodes start the tasks sequentially according to the list priority after receiving the command. For tasks with prerequisite dependencies (such as task B depending on the output of task A), the subsequent nodes are triggered to execute only after the prerequisite node reports "task started successfully". The start command uses an encrypted signature to prevent the command from being tampered with.

[0114] Finally, at the moment the task starts, the platform synchronously collects the task process ID and real-time log output port of each node, establishes a one-to-one monitoring link between "node and task", refreshes the task running status (such as GPU computing power call and data reading progress) every second, ensures that the task is executed as expected, and triggers alarms immediately in case of abnormality.

[0115] S53. Preset data acquisition rules and event-triggered acquisition rules, collect the computing resource utilization and task execution progress of each node at regular intervals according to the data acquisition rules, and collect task accuracy data according to the event-triggered acquisition rules; Specifically, firstly, two types of data collection rules are preset in layers. The first is data collection rules (timed type): the collection indicators are clearly defined as CPU utilization, memory usage, and task execution progress (such as "50% complete"). The cycle is set according to the dynamic nature of the indicators. Resource utilization (which changes rapidly) is collected once every 5 seconds, and task execution progress is collected once every 30 seconds. The unified data format is "node ID-timestamp-indicator name-value". The data is pulled in real time through the node's built-in agent program. The second is event-triggered collection rules (on-demand type): "task completes 1 batch, reaches accuracy verification node, task execution abnormality" are set as trigger events. When the event occurs, the node automatically collects accuracy data (such as model inference accuracy and data error value) and reports it with an event type label.

[0116] Secondly, for timed data collection, instructions are issued by the central monitoring platform. The Agent reads the node hardware monitoring interface and task logs periodically, and the data is encrypted and transmitted back in real time. For event-triggered data collection, no platform instructions are required. After the node detects the trigger condition, it immediately starts the accuracy detection module, generates a data packet containing "accuracy value - confidence level", and actively pushes it to the platform.

[0117] Finally, the platform verifies the continuity of timestamps and the reasonableness of values ​​in the received data (e.g., utilization rate ≤ 100%). Abnormal data is marked and the Agent is triggered to re-collect the data to ensure its authenticity and reliability, providing a basis for task monitoring and adjustment.

[0118] S54. Structure and store the data on computing resource utilization, task execution progress, and task accuracy.

[0119] Specifically, firstly, data is categorized according to its characteristics and structured standards are established, dividing the data into three categories: resource (CPU utilization, memory usage), progress (task completion percentage, current execution stage), and precision (batch accuracy, error value, confidence level). Fixed fields are defined for each data category: resource category includes "node ID-collection timestamp-indicator type-value-unit"; progress category includes "task ID-node ID-timestamp-completion rate-current step"; precision category includes "task ID-batch number-timestamp-precision value-verification node". The timestamp format (YYYY-MM-DDHH:MM:SS) and value unit (e.g., utilization rate is %, precision is decimal) are standardized.

[0120] Secondly, the collected data is deduplicated (removing duplicate records within 1 second) and outlier filtered (such as values ​​with utilization > 100%). Linear interpolation is used to complete missing data. Unstructured logs (such as task step descriptions) are converted into structured tags (such as "data preprocessing-01") using ETL tools to ensure that field values ​​meet preset standards.

[0121] Finally, real-time data (such as resource utilization) is stored in a Redis cache and retained for one hour for real-time monitoring; historical data is stored in MySQL by "daily partition," with resource and progress data linked by "node ID plus task ID," and precision data bound to "task ID plus batch number"; massive raw precision logs (such as image recognition error details) are stored in HDFS, and the storage path is recorded in MySQL. A composite index (node ​​ID, task ID, timestamp) is created to improve query efficiency, while data is automatically backed up to off-site storage daily to ensure data security.

[0122] S6. Preset execution anomaly threshold, compare historical task execution data with task execution progress, computing resource utilization and task accuracy data based on the execution anomaly threshold, add tags based on the comparison results and store them in the multi-agent task allocation historical scheme database.

[0123] Specifically, differentiated thresholds are set according to indicator type: for resource-related indicators (CPU / GPU utilization), a "fluctuation threshold" (±15% of historical average) and a "limit threshold" (≥95% or ≤10%) are set; for progress-related indicators, a "lag threshold" (the percentage of time lagging behind the plan by 10%) is set; for accuracy-related indicators, a "compliance threshold" is set according to task type (e.g., CV task accuracy ≥95%, NLP task BLEU value ≥0.85). At the same time, task priorities are differentiated, with real-time task thresholds compressed by 20% to ensure the sensitivity of core tasks.

[0124] Historical execution data of the same task type and node configuration are extracted from the database, and the historical average and fluctuation range of each indicator are calculated. The real-time collected resource utilization, task progress, and accuracy data are compared with historical benchmarks and abnormal thresholds one by one. If the resource utilization exceeds the limit threshold, the progress lags by more than 10%, or the accuracy is lower than the standard, it is judged as abnormal. Core tags (normal / resource abnormal / progress lag / accuracy not up to standard) are added according to the comparison results, and secondary tags are added to indicate the reason (such as "resource abnormal - GPU overload"). Detailed information such as the time of occurrence of the abnormality and the deviation value are recorded synchronously.

[0125] The data structure integrates "task node information, real-time data, comparison results, and tags" into a unified data structure. A joint index is established using "task ID, node ID, and timestamp". The initial allocation scheme and adjustment records are associated and stored in the database to provide data support for subsequent algorithm optimization and threshold iteration.

[0126] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A deep learning task allocation method for multi-agent collaboration, characterized in that, Includes the following steps: S1. Acquire deep learning task data, node hardware configuration data, and historical task execution data, and set up a database of historical multi-agent task allocation schemes; S2. Extract the core feature parameters of the deep learning task data, and pre-set the task feature mapping rules. Then, convert the core feature parameters into standardized task feature vectors according to the task feature mapping rules. S3. Based on the node hardware configuration data, set multi-dimensional capability assessment weighting rules, and adopt the Transformer architecture model to evaluate the real-time capabilities of each node in the node hardware configuration data and generate capability assessment results. S4. Preset multi-agent collaborative allocation rules, use multi-agent negotiation algorithm to combine standardized task feature vectors and capability evaluation results to obtain task allocation scheme, and verify and adjust the task allocation scheme with historical task execution data; S5. The verified and adjusted task allocation scheme is sent to each node in the node hardware configuration data for task execution, and the task execution progress, computing resource utilization and task accuracy data of each node are collected in real time. S6. Preset execution anomaly threshold, compare historical task execution data with task execution progress, computing resource utilization and task accuracy data based on the execution anomaly threshold, add tags based on the comparison results and store them in the multi-agent task allocation historical scheme database.

2. The multi-agent collaborative deep learning task allocation method according to claim 1, characterized in that, The process of setting multi-dimensional capability evaluation weighting rules based on node hardware configuration data and using the Transformer architecture model to evaluate the real-time capabilities of each node in the node hardware configuration data and generate capability evaluation results includes the following steps: S31. Analyze the specific configuration of the node hardware configuration data and clarify the multi-dimensional capability assessment dimensions; S32. Preset weight allocation logic, combine the weight allocation logic with the analytic hierarchy process to set up multi-dimensional capability assessment weighting rules, and allocate initial weights to the multi-dimensional capability assessment dimensions based on the multi-dimensional capability assessment weighting rules. S33. Collect real-time operating status data of each node, and integrate the real-time operating status data with the node hardware configuration data to form a node comprehensive evaluation dataset; S34. Construct a capability assessment model based on the Transformer architecture, input the node comprehensive assessment dataset into the capability assessment model, and obtain the comprehensive assessment results; S35. Preset the result threshold division rules, and use the result threshold division rules to classify the comprehensive ability assessment results and generate the ability assessment results.

3. The method for multi-agent collaborative deep learning task allocation according to claim 1, characterized in that, The preset multi-agent collaborative allocation rule uses a multi-agent negotiation algorithm combined with standardized task feature vectors and capability assessment results to obtain a task allocation scheme. The task allocation scheme is then verified and adjusted against historical task execution data, including the following steps: S41. Preset multi-agent collaborative allocation rules and multi-agent negotiation algorithm, set the input parameters of the multi-agent negotiation algorithm as standardized task feature vector and capability evaluation results, and set the core optimization objective of the multi-agent negotiation algorithm; S42. Based on the multi-agent negotiation algorithm and the core optimization objective, set up a dynamic allocation model, input the standardized task feature vector and the capability assessment results into the dynamic allocation model, and obtain the initial allocation scheme. S43. Extract key comparison dimensions from historical task execution data, compare the initial allocation scheme with the historical task execution data item by item, and adjust the initial allocation scheme based on the comparison results to generate a task allocation scheme. S44. Perform a secondary comparison and verification of the task allocation scheme with historical task execution data, preset the verification adjustment threshold and verification adjustment rule set, and compare the secondary comparison and verification results with the verification adjustment threshold for threshold adjustment. S45. Match the threshold adjustment comparison results with the verification adjustment rules in the verification adjustment rule set, and adjust the task allocation scheme based on the matched verification adjustment rules.

4. The multi-agent collaborative deep learning task allocation method according to claim 1, characterized in that, The process of distributing the verified and adjusted task allocation scheme to each node in the node hardware configuration data for task execution, and collecting real-time data on task execution progress, computing resource utilization, and task accuracy of each node, includes the following steps: S51. Decompose the verified and adjusted task allocation scheme into a dedicated execution list for each node, and send the dedicated execution list to each node in the node hardware configuration data. S52. Preset integrity verification rules: Verify the dedicated execution list according to the integrity verification rules, load the deep learning framework and data resources required by the dedicated execution list for each node according to the verified dedicated execution list, and start each node to execute the task. S53. Preset data acquisition rules and event-triggered acquisition rules, collect the computing resource utilization and task execution progress of each node at regular intervals according to the data acquisition rules, and collect task accuracy data according to the event-triggered acquisition rules; S54. Structure and store the data on computing resource utilization, task execution progress, and task accuracy.

5. The method for multi-agent collaborative deep learning task allocation according to claim 2, characterized in that, The preset weight allocation logic combines the weight allocation logic with the analytic hierarchy process (AHP) to set multi-dimensional capability assessment weighting rules, and assigns initial weights to the multi-dimensional capability assessment dimensions based on the multi-dimensional capability assessment weighting rules, including the following steps: S321. Based on the degree of impact of the evaluation dimensions on task execution efficiency as the core basis for defining the logic, a weight allocation logic is preset, and the priority of dimensions is clarified in combination with the type of deep learning task. S322. Taking the accuracy of node capability assessment as the target layer, computing power, transmission power, and redundancy capability as the criteria layer, and multi-dimensional capability assessment dimensions as the scheme layer, a hierarchical structure of weighted decision-making is constructed by combining the analytic hierarchy process and the subordinate relationship between each level is clarified. S323. Based on the weight allocation logic and the hierarchical structure of weight decision, and using the scaling method to construct a judgment matrix, the relative importance of each evaluation dimension is quantified. S324. Calculate the weight vector of the assessment dimension in the multi-dimensional capability assessment dimension using the analytic hierarchy process, and normalize the weight vector to obtain the initial weight value set of the dimension. S325. Verify the rationality of the initial weight set of dimensions, and use the initial weight values ​​of dimensions that pass the rationality verification as the initial weights of the multi-dimensional capability assessment weighting rules.

6. The method for multi-agent collaborative deep learning task allocation according to claim 2, characterized in that, The process of constructing a capability assessment model based on the Transformer architecture, inputting the node comprehensive assessment dataset into the capability assessment model, and obtaining the comprehensive assessment results includes the following steps: S341. Decompose the core component layers of the capability assessment model based on the Transformer architecture to obtain the data input layer, feature embedding layer, multi-head attention encoder layer and result output layer, and connect the data input layer, feature embedding layer, multi-head attention encoder layer and result output layer in series through the data interface. S342. Divide the node comprehensive evaluation dataset into static hardware configuration data and dynamic real-time status data, and use numerical standardization to process the static hardware configuration data and time-series serialization to process the dynamic real-time status data, and summarize to obtain standardized input data. S343. The standardized input data is input into the model data input layer. The feature embedding layer performs dual-path encoding on the static hardware data and dynamic time series data in the standardized input data. The two types of vectors are concatenated by the feature fusion operator to obtain a node feature tensor with uniform dimension. S344. Input the node feature tensor into the multi-head attention encoder layer, set the number of attention heads, and calculate the correlation weight of each evaluation dimension feature through the self-attention mechanism to strengthen the feature expression of high priority dimensions and obtain the node comprehensive feature vector. S345. Input the node comprehensive feature vector into the result output layer, and map the feature vector into a quantitative evaluation value through a fully connected neural network to form a comprehensive evaluation result.

7. The method for multi-agent collaborative deep learning task allocation according to claim 3, characterized in that, The process of extracting key comparison dimensions from historical task execution data, comparing the initial allocation scheme with the historical task execution data item by item, and adjusting the initial allocation scheme based on the comparison results to generate a task allocation scheme includes the following steps: S431. Based on the core indicators of the initial allocation scheme, determine the key comparison dimensions, extract relevant data corresponding to the key comparison dimensions from the historical task execution data, and form a standardized comparison dataset. S432. Establish a comparison mapping relationship between the initial allocation scheme and historical task execution data, compare the initial allocation scheme with the standardized comparison dataset item by item, and use the difference calculation method to quantify the data comparison deviation. S433. Preset a data deviation threshold, compare the data deviation threshold with the data comparison deviation, and adjust the standardized comparison dataset according to the comparison results to generate a task allocation scheme.

8. The multi-agent collaborative deep learning task allocation method according to claim 4, characterized in that, The preset integrity verification rules, which verify the dedicated execution list according to the integrity verification rules, load the deep learning framework and data resources required by the dedicated execution list onto each node according to the verified dedicated execution list, and start each node to execute the task, include the following steps: S521. Preset integrity verification rules and define the verification dimensions of the dedicated execution list; S522. Perform integrity verification on the dedicated execution list received by each node based on integrity verification rules and verification dimensions; If the verification passes, the corresponding deep learning framework and data resources will be loaded for each node according to the requirements of the dedicated execution list. If the verification fails, the dedicated execution list will be reissued until the verification passes and the resource loading is completed. S523. After each node has completed loading the deep learning framework and data resources and confirmed that there are no errors, start each node to execute the corresponding task.

9. The multi-agent collaborative deep learning task allocation method according to claim 6, characterized in that, The process of inputting standardized input data into the model data input layer, performing dual-channel encoding on the static hardware data and dynamic time-series data in the standardized input data by the feature embedding layer, and concatenating the two types of vectors through a feature fusion operator to obtain a node feature tensor with uniform dimensions includes the following steps: S3431. Input standardized input data into the model data input layer, and clarify the adaptation encoding method of the feature embedding layer for static hardware data and dynamic time series data. S3432. The static hardware data in the standardized input data is encoded using one-hot encoding in the feature embedding layer according to the adaptive encoding method to generate hardware feature vectors, and the dynamic time-series data in the standardized input data is encoded using position encoding to generate time-series feature vectors. S3433: Call the feature fusion operator to perform dimension alignment and concatenation processing on the hardware feature vector and the temporal feature vector to obtain a node feature tensor with unified dimensions.

10. The multi-agent collaborative deep learning task allocation method according to claim 6, characterized in that, The process of inputting node feature tensors into a multi-head attention encoder layer, setting the number of attention heads, and calculating the correlation weights of features in each evaluation dimension through a self-attention mechanism to enhance the feature representation of high-priority dimensions, thereby obtaining a comprehensive node feature vector, includes the following steps: S3441. Input the node feature tensor into the multi-head attention encoder layer, preset the threshold for the number of attention heads, and match the node feature tensor with the threshold for the number of attention heads. Set the number of attention heads based on the matching result to complete the model parameter configuration. S3442. The self-attention mechanism is used to perform correlation calculation on the features of each evaluation dimension in the node feature tensor to obtain the correlation weights corresponding to each dimension. Based on the correlation weights, the feature expression of high priority dimensions is strengthened to obtain the node comprehensive feature vector.

Images