A task dynamic decomposition management system and method based on an AI framework

Abstract

The present invention discloses a task dynamic decomposition management system and method based on an AI framework, which relates to the technical field of task management and includes: dividing task parameters into multiple dimensional features, fusing the multi-dimensional features through a spatio-temporal attention network to construct a three-dimensional feature tensor; recursively decomposing the three-dimensional feature tensor through an adaptive quadratic screening algorithm to output a decoupled modal set; predicting resource load based on a long short-term memory network and quantifying the modal demand level, constructing a bipartite graph matching model, and adaptively allocating resource instances through dynamic matching; collecting real-time time performance and resource consumption data of task execution, calculating the modal deviation amount, triggering dynamic re-decomposition if the modal deviation amount exceeds the deviation threshold, and reallocating resources based on the updated modal set, so as to dynamically capture task features, efficiently decompose them, and accurately allocate resources, thereby improving task execution efficiency and resource utilization rate.

Description

Technical Field

[0001] The present invention relates to the technical field of task management, and specifically to a task dynamic decomposition management system and method based on an AI framework. Background Art

[0002] With the rapid development of information technology, task decomposition management plays a crucial role in fields such as big data processing, cloud computing, and high-performance computing. First-principles thinking is a problem-solving method that involves breaking down complex problems into the most basic and fundamental facts. By understanding these core principles, solutions can be built from scratch without relying on assumptions or traditional methods. First-principles thinking is used to decompose the user's goals or problems into indivisible parts. Dynamic task decomposition involves dynamically decomposing tasks into subtasks to achieve more efficient and adaptive problem-solving. This method is crucial for handling complex real-world problems because requirements may change over time.

[0003] However, with the increase in task complexity and the diversification of computing resources, task decomposition methods have gradually exposed problems such as insufficient flexibility and low resource utilization. Especially when facing real-time changing task characteristics, they seem powerless. For example, when the data volume suddenly fluctuates or the resource load changes significantly, the task decomposition method cannot dynamically adjust the decomposition granularity, resulting in low task execution efficiency and resource waste. Some decomposition methods based on a single machine learning model (such as reinforcement learning strategies) have improved flexibility to a certain extent, but still have the problem of high modal coupling. These models fail to fully decouple the multi-dimensional attributes of tasks (such as computational complexity, data dependence, timeliness), resulting in conflicts between subtasks and further affecting the efficiency and quality of task execution.

[0004] In addition, when dealing with large-scale and high-complexity tasks, task decomposition methods are prone to falling into the "curse of dimensionality", that is, as the number of task feature dimensions increases, the computational complexity and resource consumption increase exponentially, making task management extremely difficult. Task decomposition methods are also prone to ignoring the dependency relationships and temporal characteristics between tasks, resulting in frequent conflicts and resource contention problems between tasks. Summary of the Invention

[0005] (1) Technical Problems to be Solved

[0006] Aiming at the deficiencies of the prior art, the present invention provides a task dynamic decomposition management system and method based on an AI framework, aiming to achieve dynamic capture, efficient decomposition, and precise resource allocation of task characteristics by introducing technologies such as spatio-temporal attention networks, adaptive secondary screening algorithms, long short-term memory networks, and dynamic matching mechanisms, thereby improving task execution efficiency and resource utilization.

[0007] (2) Technical Solutions

[0008] To achieve the above object, the present invention is realized by the following technical solutions: A task dynamic decomposition management method based on an AI framework, comprising:

[0009] Dividing task parameters into multiple dimensions and extracting corresponding features, fusing the multi-dimensional features through a spatio-temporal attention network, and constructing a three-dimensional feature tensor;

[0010] Recursively decomposing the three-dimensional feature tensor through an adaptive quadratic screening algorithm, merging redundant modes through cosine similarity test, and outputting a decoupled mode set;

[0011] Predicting resource load based on a long short-term memory network and quantifying the mode demand level, constructing a bipartite graph matching model, and adaptively allocating resource instances through dynamic matching. If multiple modes compete for the same resource instance, an auction mechanism is started;

[0012] Real-time collecting the time performance and resource consumption data of task execution, calculating the mode deviation amount. If the mode deviation amount exceeds the deviation threshold, trigger dynamic re-decomposition, and re-allocate resources based on the updated mode set.

[0013] Furthermore, a spatio-temporal attention network architecture is used for spatio-temporal feature fusion. The spatio-temporal attention network architecture includes an input layer, a spatial attention layer, a temporal attention layer, and a fusion layer;

[0014] Among them, the input layer receives multi-dimensional features;

[0015] The spatial attention layer uses a graph attention network to model the dependencies between tasks, constructs a graph of the task set, calculates the spatial correlation weights between tasks, and outputs spatially enhanced features;

[0016] The temporal attention layer introduces a time sliding window, extracts historical task time series data, and a long short-term memory network unit processes the historical task time series data to generate a hidden state, and outputs temporally enhanced features;

[0017] The spatially enhanced features and the temporally enhanced features are concatenated to obtain a fused feature vector , representing the fused feature vector of the i th task, representing the task parameter set, d representing the feature vector dimension.

[0018] Furthermore, the task set is stacked into a three-dimensional feature tensor according to a time window , n representing the number of tasks, k representing the number of time slices.

[0019] Further, perform extreme value detection on each time slice of the three-dimensional feature tensor to extract the set of local maximum points and the set of minimum points ;

[0020] Use cubic spline interpolation to connect and respectively to generate the upper envelope and the lower envelope ;

[0021] Calculate the mean of the upper envelope and the lower envelope, that is, the mean envelope , and separate the mode from the three-dimensional feature tensor : , t represents the moment;

[0022] Repeat the above process until the decomposition stop criterion is met: when , terminate the current mode decomposition, represents the preset tolerance threshold.

[0023] Further, for each generated mode, calculate its energy entropy. If the energy proportion of this mode is less than the mode energy threshold, stop the decomposition and retain the residual R , otherwise, use the residual R as the new input to continue the decomposition;

[0024] Calculate the cosine similarity between adjacent modes. If the cosine similarity is greater than the mode similarity threshold, perform mode merging, update the energy entropy of the merged mode, and delete redundant modes;

[0025] For each mode perform feature analysis, calculate the feature mean, select the feature dimension corresponding to the maximum value in the feature means as the dominant feature dimension for marking, and output the decoupled mode set , M is the number of modes.

[0026] Further, collect the historical resource utilization time series, use the long short-term memory network to predict the mean and variance of the resource load prediction for the next time window , and generate the resource load probability distribution through Monte Carlo sampling ;

[0027] Construct a three-dimensional capacity vector for each resource instance to predict the available capacity of each instance for the next time window : , where represents the three-dimensional capacity vector of the s th resource instance, Denotes element-wise multiplication.

[0028] Furthermore, for each modality, extract its dominant feature dimension, quantify its demand level by linear interpolation, and construct the m demand matrix of the th modality. Construct a bipartite graph model, where the left nodes are the set of task modalities and the right nodes are the set of resource instances. Calculate the matching degree between the m th modality and the s th resource instance as the edge weight.

[0029] Furthermore, for each modality, select the resource instance with the highest matching degree. If the matching degree is less than the edge weight threshold, trigger resource preemption, add the occupied resources to the candidate pool. For the residual modality, split the residual modality into independent subtasks and try to match idle resources one by one. If there is insufficient resources, delay the execution and add it to the next cycle task queue;

[0030] If multiple modalities compete for the same resource instance, start the auction mechanism, and the highest bidder gets the resource instance, and the losers enter the next round of matching.

[0031] Furthermore, collect runtime data during task execution, including monitoring metrics in two dimensions of time performance and resource consumption;

[0032] Based on the collected monitoring metrics, calculate the deviation amount of each modality to measure the deviation degree between its actual execution effect and the expectation. If the deviation amount of the current modality exceeds the preset deviation threshold, decompose the current modality again and adjust the modality similarity threshold and the limit decomposition depth.

[0033] A task dynamic decomposition management system based on an AI framework, including:

[0034] Feature extraction and fusion module, which divides task parameters into multiple dimensions and extracts corresponding features, fuses the multi-dimensional features through a spatio-temporal attention network, and constructs a three-dimensional feature tensor;

[0035] Task modality decomposition module, based on double-threshold initialization, recursively decomposes the three-dimensional feature tensor through an adaptive quadratic screening algorithm, merges redundant modalities through cosine similarity test, and outputs a decoupled modality set;

[0036] Resource prediction and allocation module, which predicts resource load based on a long short-term memory network and quantifies the modality demand level, constructs a bipartite graph matching model, and adaptively allocates resource instances through dynamic matching. If multiple modalities compete for the same resource instance, start the auction mechanism;

[0037] The monitoring and dynamic adjustment module collects the time performance and resource consumption data of task execution in real time, calculates the modal deviation amount. If the modal deviation amount exceeds the deviation threshold, it triggers dynamic re-decomposition and reallocates resources based on the updated modal set.

[0038] (3) Beneficial effects

[0039] The present invention provides a task dynamic decomposition management system and method based on an AI framework, having the following beneficial effects:

[0040] (1) Through the fusion of multi-dimensional feature extraction and spatio-temporal attention network, a three-dimensional feature tensor is constructed, effectively improving the environmental adaptability of task decomposition, reducing the modal coupling degree, and providing a rich feature basis for subsequent optimization, which is beneficial to realizing efficient resource utilization and closed-loop optimization.

[0041] (2) Through the adaptive secondary screening algorithm, the decomposition granularity can be dynamically adjusted according to real-time task characteristics, enabling task decomposition to better adapt to environmental changes and task fluctuations, improving the flexibility and efficiency of task management. Through the recursive decomposition and cosine similarity test of the three-dimensional feature tensor, the multi-dimensional attributes of tasks can be effectively decoupled, reducing conflicts between subtasks.

[0042] (3) By predicting resource load through a long short-term memory network, the resource demand trend in the next period of time can be grasped more accurately. The dominant feature dimensions are extracted for each modality and their demand levels are quantified, which helps to more precisely evaluate the resource demand degree of different modalities. By constructing a bipartite graph matching model to match task modalities with resource instances, accurate docking of tasks and resources is achieved, improving resource utilization rate and task execution efficiency.

[0043] (4) By collecting the time performance and resource consumption data of task execution in real time, deviations during task execution, such as queuing delay, execution timeout, and improper resource allocation, can be accurately captured. When it is detected that the modal deviation amount exceeds the threshold, a dynamic re-decomposition mechanism is triggered, which helps to timely adjust the task decomposition strategy and resource allocation plan. Description of the drawings

[0044] Figure 1 It is a schematic diagram of the steps of the task dynamic decomposition management method based on the AI framework of the present invention;

[0045] Figure 2 It is a schematic diagram of the adaptive secondary screening process of the present invention;

[0046] Figure 3 It is a schematic diagram of the structure of the task dynamic decomposition management system based on the AI framework of the present invention. Detailed implementation manners

[0047] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0048] Please refer to Figure 1 and Figure 2 , the present invention provides a task dynamic decomposition management method based on an AI framework, including the following steps:

[0049] Step 1: Divide task parameters into multiple dimensions and extract corresponding features, and fuse the multi-dimensional features through a spatio-temporal attention network to construct a three-dimensional feature tensor;

[0050] The said Step 1 includes the following contents:

[0051] Step 101: After the user submits a task goal, the intent extraction agent identifies the core requirements (such as compute-intensive tasks, real-time data processing tasks, etc.) through natural language processing technology, and the instant analysis agent verifies the input context, and divides the task parameters into four types of dimensions, including the computing dimension, the data dimension, the timeliness dimension, and the resource dimension. Among them, the computing dimension includes the number of CPU / GPU instructions and the floating-point operation volume, the data dimension includes the input / output data volume and the cross-node dependency weight, the timeliness dimension includes the deadline and the maximum tolerable delay, and the resource dimension includes the storage bandwidth requirement and the type of hardware accelerator;

[0052] It should be noted that the system generates agent instances on demand through the Agent Generation Service. This service creates dedicated agents by calling predefined agent templates (such as coordinator templates, data interaction templates) based on the task decomposition results input by the user. All agent instances are uniformly managed through the Agent Registry. Each agent will be assigned a unique ID after generation;

[0053] The functions of the agents are defined by their templates. For example:

[0054] Intent extraction agent: Generated based on a natural language processing (NLP) toolchain (such as BERT), used to extract the core goal from the user input; Instant analysis agent: Integrated with real-time data analysis (such as a stream processing engine), used to verify the timeliness of the task context;

[0055] Specifically, use system monitoring tools (such as Linux perf, NVIDIA Nsight) to capture the number of CPU / GPU instructions and floating-point operations, estimate the floating-point operations (FLOPs) through task configuration files or compiler optimizers (such as LLVM), extract the input / output data volume from task metadata or distributed file system (such as HDFS) logs, analyze the cross-node dependencies between tasks through task DAG (Directed Acyclic Graph), for example, use the communication records of Apache Airflow or Kubernetes Pods, read the deadline from the SLA configuration file submitted by the task, set the maximum tolerable latency according to requirements, obtain the storage bandwidth requirements through the task configuration file, parse the hardware accelerator type from the task container image or scheduler policy (such as CUDA, OpenCL, TPU support tags), and represent the hardware accelerator type through one-hot encoding;

[0056] Step 102: Use a spatio-temporal attention network architecture for spatio-temporal feature fusion. The spatio-temporal attention network architecture includes an input layer, a spatial attention layer, a temporal attention layer, and a fusion layer. Among them,

[0057] The input layer receives multi-dimensional feature vectors , where represents the multi-dimensional feature vector of the i-th task, represents the set of task parameters, d represents the dimension of the feature vector;

[0058] The spatial attention layer uses a graph attention network to model the dependencies between tasks, constructs a graph from the task set, and the edge weights are determined by the strength of the cross-node dependencies (such as the percentage of the output data volume of task A to the input data volume of task B), and calculates the spatial association weights between tasks: , and the spatial association weight formula measures the task dependency strength by calculating the dot product between task feature vectors. Among them, represents the dependency strength between task i and task j, and outputs the spatially enhanced features: , n represents the number of tasks;

[0059] The temporal attention layer introduces a time sliding window (such as a window size of 10 minutes), extracts the historical task time series data, and the LSTM unit processes the historical task time series data to generate hidden states , and calculates the temporal weights: , and the temporal weight formula is generated from the hidden state of the LSTM to capture the temporal characteristics of task execution. Among them, represents the temporal weight, t represents the moment, represents the temporal projection matrix, Denote the bias term, and output the time-series enhanced features: ;

[0060] The hidden state is obtained through recursive calculation at each time step. The initial hidden state , which can be a zero vector or randomly initialized. At each time step, the LSTM calculates a new based on the current input and the previous hidden state : , represents the input features at the current time step; is randomly generated during network initialization and is optimized through backpropagation and gradient descent training;

[0061] Step 103: Concatenate the spatial enhanced features and the time-series enhanced features to obtain a fused feature vector: ;

[0062] Step 104: Stack the task set into a three-dimensional tensor according to a time window (such as five minutes), where k represents the number of time slices (default k = 6, that is, a 30-minute window). The tensor slicing structure: the first dimension is the task instance (when the number of tasks exceeds 1000, it is stored in blocks by time or space), the second dimension is the fused feature dimension (such as d = 16 dimensions), and the third dimension is the time series ( k = 6 consecutive time slices);

[0063] Step 105: For computationally intensive features (such as the amount of floating-point operations), use Min-Max normalization to map them to the [0, 1] interval, and use one-hot encoding for categorical features (such as hardware type);

[0064] When in use, combine the content of Steps 101 to 105:

[0065] Through the fusion of multi-dimensional feature extraction and spatio-temporal attention networks, a three-dimensional feature tensor is constructed, which effectively improves the environmental adaptability of task decomposition, reduces the modal coupling degree, and provides a rich feature basis for subsequent optimization, which is beneficial to achieving efficient resource utilization and closed-loop optimization.

[0066] Step Two: Based on double-threshold initialization, recursively decompose the three-dimensional feature tensor through an adaptive quadratic screening algorithm, merge redundant modes through cosine similarity test, and output a decoupled mode set;

[0067] The above Step Two includes the following content:

[0068] Step 201: Initialize the modal similarity threshold (default 0.8) and the modal energy threshold (default 5%). The threshold settings are based on the statistical results of historical task execution data. The task decomposition agent, based on first principles thinking, uses adaptive quadratic screening to dynamically decompose the three-dimensional feature tensor, including:

[0069] Perform extreme value detection on each time slice of the three-dimensional feature tensor, and extract the set of local maximum points and the set of minimum points ;

[0070] Use cubic spline interpolation to connect and respectively to generate the upper envelope and the lower envelope ;

[0071] Calculate the mean of the upper envelope and the lower envelope, that is, the mean envelope , and separate the modes from the three-dimensional feature tensor: , denotes the m th mode;

[0072] Repeat the above process until the decomposition stop criterion is met: when , terminate the current modal decomposition, denotes the norm, denotes the preset tolerance threshold, default 1e-6;

[0073] Step 203: For each generated mode, calculate its energy entropy: , the energy entropy formula measures the "energy" intensity of the mode and reflects its impact on the overall task. Among them, denotes the task i in the mode m feature vector, the total energy is the sum of all modes and the residual energy. If the energy ratio of this mode is less than the modal energy threshold, the energy ratio is the ratio of the energy entropy of this mode to the total energy, stop the decomposition and retain the residual , M denotes the number of modes, otherwise, use the residual as the new input to continue the decomposition and update the modal count ;

[0074] Step 204: Calculate the cosine similarity between adjacent modes: , where, here denotes taking the modulus. If the cosine similarity is greater than the modal similarity threshold, perform modal merging: , update the energy entropy of the merged mode, and delete the redundant mode , and finally obtain several modes and a residualR Output decoupled mode set ;

[0075] Step 205: For each mode Perform feature analysis and calculate the feature mean : , , where calculating the mean along the row direction, selecting the feature dimension corresponding to the maximum value in the feature means, and marking it as the dominant feature dimension. For example, if dimension 3 (floating-point operation volume) is greater than 0.9, it is marked as "GPU-intensive", and if dimension 7 (storage bandwidth) is greater than 0.8, it is marked as "high I / O throughput";

[0076] Step 206: The proxy generation service creates dedicated proxies according to the mode results:

[0077] Computation-intensive proxy: Processes modes with high floating-point operation volumes (marked as "GPU-intensive");

[0078] I / O-intensive proxy: Processes modes with high storage bandwidth requirements (marked as "high I / O throughput");

[0079] Real-time proxy: Processes modes sensitive to deadlines;

[0080] Proxy registration: Register the generated proxy instances and assign unique IDs;

[0081] When in use, combine the content of Steps 201 to 205:

[0082] Through the adaptive quadratic screening algorithm, it can dynamically adjust the decomposition granularity according to the real-time task characteristics, enabling the task decomposition to better adapt to environmental changes and task fluctuations, improving the flexibility and efficiency of task management. Through the recursive decomposition and cosine similarity test of the three-dimensional feature tensor, it can effectively decouple the multi-dimensional attributes of tasks and reduce conflicts between subtasks.

[0083] Step 3: Predict the resource load based on the long short-term memory network and quantify the mode demand level, construct a bipartite graph matching model, and adaptively allocate resource instances through dynamic matching. If multiple modes compete for the same resource instance, start the auction mechanism;

[0084] The said Step 3 includes the following content:

[0085] Step 301: The coordinator proxy analyzes the data and execution order dependencies between proxies, constructs a directed dependency graph, performs topological sorting using the Kahn algorithm to generate an acyclic execution sequence, and detects circular dependencies (trigger an alarm if any);

[0086] Step 302: Collect the historical resource utilization time series, including CPU, memory, network bandwidth, etc., and use the long short-term memory network to predict the predicted mean and variance of the resource load in the next time window (such as 5 minutes), and generate the resource load probability distribution through Monte Carlo sampling: , the formula predicts the mean and variance of the future resource load through LSTM, and Monte Carlo sampling generates normal distribution samples to simulate resource fluctuations, where N represents the normal distribution, μ represents the predicted mean of the resource load, σ represents the predicted variance of the resource load;

[0087] Step 303: Construct a three-dimensional capacity vector for each resource instance (such as a server node): , where represents the s th resource instance, represents the idle CPU, represents the remaining memory, represents the available bandwidth, and predict the available capacity of each instance in the next time window : , where represents element-wise multiplication;

[0088] Step 304: Extract the dominant feature dimension for each modality and quantify its demand level by linear interpolation: , where represents the eigenvalue of the m th dimension of the d th modality, represents the eigenvalue of the d th dimension of all modalities;

[0089] Step 305: Construct the demand matrix of the m th modality , where , represents the demand matrix 's s th column vector composed of all row elements, respectively represent the CPU demand level, memory demand level, and GPU demand level, T represents matrix transpose, represents the proportion of the modality task number (i.e., the proportion of the number of tasks of the m th modality in the total number of current tasks);

[0090] Step 306: Construct a bipartite graph model, where the left nodes are the task modality set, the right nodes are the resource instance set, and calculate the matching degree between the , the edge weight consists of two parts. Cosine similarity: measures the matching degree between resource demand and resource supply. Energy proportion: higher energy modes have higher priorities to ensure that critical tasks are allocated resources first. Among them, represents the energy weight coefficient (default value 0.2), , represents the total energy;

[0091] The default value 0.2 is determined by experimental tuning and is used to balance the matching degree and modal importance. If is too high, resource allocation will favor high-energy modes, which may cause delays in low-energy tasks; if it is too low, the priority differences between modes may be ignored;

[0092] Step 307: For each mode, select the resource instance with the highest matching degree. If the matching degree is less than the edge weight threshold (default 0.6), trigger resource preemption, add the occupied resources to the candidate pool. For the residual mode, split the residual mode into independent subtasks and try to match idle resources one by one. If there are insufficient resources, delay the execution and add it to the next cycle task queue;

[0093] Step 308: If multiple modes compete for the same resource instance, start the auction mechanism. The mode bids: , and the highest bidder gets the resource instance, and the losers enter the next round of matching;

[0094] Step 309: Group the independent agents into the same execution level and use asynchronous programming (such as asyncio in Python) to achieve parallel execution;

[0095] When in use, combine the content of Step 301 to Step 309:

[0096] Predicting resource load through a long short-term memory network can more accurately grasp the resource demand trend in the future for a period of time, extract the dominant feature dimensions for each mode and quantify its demand level, which helps to more precisely evaluate the resource demand degree of different modes. By constructing a bipartite graph matching model to match task modes with resource instances, the precise docking of tasks and resources is achieved, improving resource utilization and task execution efficiency.

[0097] Step Four: Real-time collect the time performance and resource consumption data of task execution, calculate the modal deviation amount. If the modal deviation amount exceeds the deviation threshold, trigger dynamic re-decomposition and re-allocate resources based on the updated modal set.

[0098] The said Step Four includes the following content:

[0099] Step 401: During the task execution, continuously collect fine-grained runtime data through lightweight monitoring agents deployed on computing nodes. The monitoring metrics cover two dimensions: time performance and resource consumption.

[0100] Time performance: Record the actual start time and end time of each subtask, and compare them with the expected timeline to quantify deviations such as queuing delay and execution timeout. For example, if a task is expected to be completed within 5 minutes but actually takes 8 minutes due to resource contention, the system will capture a 3-minute delay deviation.

[0101] Resource consumption: Real-time track metrics such as peak CPU / GPU utilization, memory occupancy, and network bandwidth usage. For example, if a certain modality task is allocated 4-core CPU resources but only 2 cores are actually used during operation, the system will mark the inefficient situation of over-allocation of resources.

[0102] Step 402: Based on the collected metrics, calculate the deviation amount for each modality to measure the degree of deviation of its actual execution effect from the expectation: , the formula combines time deviation and resource deviation to reflect the actual deviation degree of task execution, where represents the number of tasks of the m th modality, represents the actual completion time of the i th task, represents the expected completion time of the i th task, represents the actual resource occupancy of the i th task, The i th task's expected resource occupancy, α , β represent weights, , which can be adjusted;

[0103] The weights are optimized through historical data analysis. If the system pays more attention to task timeliness (such as in real-time computing scenarios), then increase α ; if resource utilization is a key indicator (such as cloud computing cost optimization), then increase β；

[0104] Time deviation term: Compare the actual completion time of the task with the expected deadline, and calculate the average delay ratio. For example, if the 10 tasks of a certain modality are on average delayed by 20%, this item will get a higher score.

[0105] Resource deviation term: Compare the predicted resource requirements with the actual occupancy, and analyze the degree of resource mismatch. For example, if a certain modality is expected to require 80% GPU utilization but actually only reaches 50%, it indicates that there is waste in resource allocation.

[0106] Step 403: If the deviation of the current modality exceeds the preset deviation threshold, decompose the current modality again according to the decomposition process in Step 2, adjust the modality similarity threshold (for example, adjust 0.8 to 0.7), and limit the decomposition depth. For example, set the maximum number of sub-modalities (the number of modalities after decomposition) to 5. The setting of the deviation threshold is based on the statistical analysis of historical task data;

[0107] Step 404: Reallocate resources using the method in Step 3 based on the updated modality set;

[0108] Step 405: The synthesis agent integrates the outputs of all agents, and the alignment verification agent checks whether the final result meets the expected goals (such as deadlines, resource requirements), and outputs a globally optimized task execution plan, including resource allocation details, resource occupancy reports, and execution timelines;

[0109] When in use, combine the content of Steps 401 to 405:

[0110] By collecting real-time time performance and resource consumption data of task execution, deviations during task execution can be accurately captured, such as queuing delays, execution timeouts, and improper resource allocation. When the modality deviation amount is detected to exceed the threshold, a dynamic re-decomposition mechanism will be triggered, which helps to adjust the task decomposition strategy and resource allocation plan in a timely manner.

[0111] Please refer to Figure 3 , the present invention provides a task dynamic decomposition management system based on an AI framework, including: a feature extraction and fusion module, a task modality decomposition module, a resource prediction and allocation module, and a monitoring and dynamic adjustment module;

[0112] Among them, the feature extraction and fusion module divides task parameters into multiple dimensions and extracts corresponding features, fuses the multi-dimensional features through a spatio-temporal attention network, and constructs a three-dimensional feature tensor;

[0113] The task modality decomposition module, based on double-threshold initialization, recursively decomposes the three-dimensional feature tensor through an adaptive quadratic screening algorithm, merges redundant modalities through cosine similarity tests, and outputs a decoupled modality set;

[0114] The resource prediction and allocation module predicts resource loads and quantifies modality demand levels based on a long short-term memory network, constructs a bipartite graph matching model, and adaptively allocates resource instances through dynamic matching. If multiple modalities compete for the same resource instance, an auction mechanism is started;

[0115] The monitoring and dynamic adjustment module collects real-time time performance and resource consumption data of task execution, calculates the modality deviation amount, triggers dynamic re-decomposition if the modality deviation amount exceeds the threshold, and reallocates resources based on the updated modality set.

[0116] In the application, several formulas involved are calculated by taking their numerical values after dimensionless treatment. The formula is obtained by collecting a large amount of data for software simulation to get a formula closest to the actual situation, and the coefficients in the formula are set by those skilled in the art according to the actual situation.

[0117] The above embodiments can be implemented in whole or in part by software, hardware, firmware or any combination thereof. When implemented using software, the above embodiments can be implemented in whole or in part in the form of a computer program product. Those of ordinary skill in the art can realize that the units and algorithm steps of each example described in combination with the embodiments disclosed herein can be implemented by the combination of electronic hardware, computer software and electronic hardware. Whether these functions are executed in a hardware or software manner depends on the specific application and design constraints of the technical solution.

[0118] The units described as separate components may or may not be physically separated. The components shown as units may or may not be physical units, and may be located in one place or distributed to multiple network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0119] As described above, the above is only the specific implementation manner of this application, but the protection scope of this application is not limited thereto. Any person skilled in the art within the technical scope disclosed in this application can easily think of changes or substitutions, which should all be covered within the protection scope of this application.

Claims

1. A task dynamic decomposition management method based on an AI framework, characterized in that: Including: Dividing task parameters into multiple dimensions and extracting corresponding features, fusing the multi-dimensional features through a spatio-temporal attention network, and constructing a three-dimensional feature tensor; Recursively decomposing the three-dimensional feature tensor through an adaptive quadratic screening algorithm, merging redundant modes through cosine similarity tests, and outputting a decoupled mode set; Predicting resource load based on a long short-term memory network and quantifying the modal demand level, constructing a bipartite graph matching model, and adaptively allocating resource instances through dynamic matching. If multiple modes compete for the same resource instance, start an auction mechanism; Collecting time performance and resource consumption data of task execution in real time, calculating the modal deviation amount. If the modal deviation amount exceeds the deviation threshold, trigger dynamic re-decomposition, and re-allocate resources based on the updated mode set.

2. The task dynamic decomposition management method based on the AI framework according to claim 1, wherein: Using a spatio-temporal attention network architecture for spatio-temporal feature fusion, the spatio-temporal attention network architecture includes an input layer, a spatial attention layer, a temporal attention layer, and a fusion layer; Among them, the input layer receives multi-dimensional features; The spatial attention layer uses a graph attention network to model the dependencies between tasks, constructs a graph of the task set, calculates the spatial correlation weights between tasks, and outputs spatially enhanced features; The temporal attention layer introduces a time sliding window, extracts historical task time series data, and a long short-term memory network unit processes the historical task time series data to generate a hidden state, and outputs temporally enhanced features; The spatial enhanced features and the temporal enhanced features are concatenated to obtain a fused feature vector , denotes the fused feature vector of the i th task, denotes the set of task parameters, d denotes the dimension of the feature vector.

3. The method for dynamically decomposing and managing tasks based on an AI framework according to claim 2, wherein: Stack the task set according to the time window into a three-dimensional feature tensor , n where represents the number of tasks, k and represents the number of time slices.

4. The method for dynamically decomposing and managing tasks based on an AI framework according to claim 3, wherein: Perform extreme value detection on each time slice of the three-dimensional feature tensor to extract the set of local maximum points and the set of minimum points ; Use cubic spline interpolation to connect and respectively to generate the upper envelope and the lower envelope ; Calculate the mean of the upper envelope and the lower envelope, that is, the mean envelope and separate the mode from the three-dimensional feature tensor : , t represents the moment; Repeat the above process until the decomposition stop criterion is satisfied: when is reached, terminate the current modal decomposition, where represents a preset tolerance threshold value.

5. The method for dynamically decomposing and managing tasks based on an AI framework according to claim 4, wherein: For each generated mode, calculate its energy entropy. If the energy proportion of this mode is less than the mode energy threshold, stop the decomposition and retain the residual. R , otherwise, use the residual R as the new input and continue the decomposition; Calculating the cosine similarity between adjacent modes. If the cosine similarity is greater than the modal similarity threshold, perform modal merging, update the energy entropy of the merged mode, and delete redundant modes; For each modality perform feature analysis, calculate the feature mean, select the feature dimension corresponding to the maximum value in the feature means, mark it as the dominant feature dimension, and output the decoupled modality set , M where 6. The method for dynamically decomposing and managing tasks based on an AI framework according to claim 1, wherein: Collect the historical resource utilization time series, and use the long short-term memory network to predict the resource load prediction mean and variance of the next time window Generate the resource load probability distribution through Monte Carlo sampling ; Construct a three-dimensional capacity vector for each resource instance to predict the next time window The available capacity of each instance : , where represents the three-dimensional capacity vector of the s th resource instance, and represents element-wise multiplication.

7. The method for dynamically decomposing and managing tasks based on an AI framework according to claim 6, wherein: Extract the dominant feature dimension for each modality, quantify its requirement level by linear interpolation, and construct the requirement matrix for the m th modality ; construct a bipartite graph model, where the left nodes are the set of task modalities, the right nodes are the set of resource instances, and calculate the matching degree between the m th modality and the s th resource instance as the edge weight.

8. The method for dynamically decomposing and managing tasks based on an AI framework according to claim 7, wherein: For each mode, select the resource instance with the highest matching degree. If the matching degree is less than the edge weight threshold, trigger resource preemption, add the occupied resources to the candidate pool. For the residual mode, split the residual mode into independent subtasks, and try to match idle resources one by one. If there are insufficient resources, delay execution and add it to the next cycle task queue; If multiple modes compete for the same resource instance, start an auction mechanism, and the highest bidder obtains the resource instance, and the losers enter the next round of matching.

9. The method for dynamically decomposing and managing tasks based on an AI framework according to claim 1, wherein: Collecting runtime data during task execution, including monitoring metrics in two dimensions of time performance and resource consumption; Based on the collected monitoring metrics, calculate the deviation amount of each modality to measure the degree of deviation between its actual execution effect and the expectation. When the deviation amount of the current modality exceeds the preset deviation threshold, decompose the current modality again and adjust the modality similarity threshold and the limit decomposition depth.

10. A task dynamic decomposition management system based on an AI framework, for implementing the method according to any one of claims 1 to 9, characterized in that: Including: A feature extraction and fusion module that divides task parameters into multiple dimensions and extracts corresponding features, fuses the multi-dimensional features through a spatio-temporal attention network, and constructs a three-dimensional feature tensor; A task modality decomposition module that, based on double-threshold initialization, recursively decomposes the three-dimensional feature tensor through an adaptive quadratic screening algorithm, merges redundant modalities through cosine similarity tests, and outputs a decoupled modality set; A resource prediction and allocation module that predicts resource loads based on a long short-term memory network and quantifies the modality demand level, constructs a bipartite graph matching model, and adaptively allocates resource instances through dynamic matching. If multiple modalities compete for the same resource instance, start an auction mechanism; A monitoring and dynamic adjustment module that collects real-time data on the time performance and resource consumption of task execution, calculates the modality deviation amount, triggers dynamic re-decomposition if the modality deviation amount exceeds the deviation threshold, and re-allocates resources based on the updated modality set.

Images