Edge cloud collaborative adaptive workflow scheduling method and system

Abstract

The invention relates to a side cloud collaborative adaptive workflow scheduling method and system, and belongs to the technical field of distributed computing and artificial intelligence. The method comprises the following steps of: firstly, in a macroscopic candidate screening stage, reducing problem granularity through task clustering, and obtaining balance between utilization and exploration based on a weighted distance probabilistic preferential strategy; then, in a collaborative scheduling decision-making stage, a global network state diagram is constructed through a graph neural network, deep spatial features of nodes and neighborhoods of the nodes are extracted, context-aware state representation is formed, and a reinforcement learning agent makes an optimal collaborative decision in multiple options such as local execution, edge migration or cloud unloading according to the state representation; and finally, in a local adaptive optimization stage, performing fine-grained optimization after the task is issued, dynamically adjusting a scheduling frequency and a multi-target weight through an online learning mechanism, realizing balance between a task deadline and a resource utilization rate, and ensuring efficient and robust execution of a node level.

Description

TECHNICAL FIELD

[0001] The present application relates to a kind of edge cloud collaborative adaptive workflow scheduling method and system, belong to distributed computing and artificial intelligence technical field. BACKGROUND

[0002] With the development of Internet of Things, 5G / 6G communication and smart city applications, efficient scheduling of workflows with complex dependencies under edge-cloud collaboration architecture has become a core challenge, especially in smart transportation and other scenarios, the distribution of task requests in time and space is extremely uneven, which can easily lead to overload of some edge servers, resulting in high service delay. This scheduling problem not only constitutes an NP-hard problem due to the exponential growth of the solution space, but also must deal with the optimization of multiple conflicting objectives such as workflow internal dependencies, dynamic network load, and delay / resource utilization / cost.

[0003] Although existing deep reinforcement learning (DRL) and other methods have been tried in this field, there are still obvious limitations: first, methods based on geometric division such as Voronoi diagrams can simplify the problem, but their division method is rigid and difficult to adapt to the rapid changes in node load and network state in real time. Second, independent DRL methods are usually deployed on a single edge node, with a limited decision-making perspective limited to "local execution" or "cloud offloading" vertical mode, lacking global awareness of the entire edge network topology and state, and unable to perform more efficient "edge-edge" horizontal collaborative scheduling, resulting in uneven resource utilization and suboptimal scheduling.

[0004] Therefore, there is an urgent need for a unified scheduling method that can quickly filter optimal candidate resources from a macro perspective and make intelligent collaborative decisions based on a global network perspective from a micro perspective. SUMMARY

[0005] To overcome the shortcomings of the prior art, the present application provides an edge cloud collaborative adaptive workflow scheduling method and system, which introduces graph structure modeling and multi-agent collaborative learning mechanism, which can more accurately capture the topological correlation and global state changes between nodes, suitable for dynamic workflow scenarios. In the complex edge-cloud collaborative computing system, through three levels of macro candidate screening, micro collaborative decision-making and local dynamic optimization, the adaptive balance of task completion rate, resource utilization and migration cost (including delay and bandwidth overhead) and other multiple objectives is achieved.

[0006] The technical solution of the present application is as follows: An edge cloud collaborative adaptive workflow scheduling method is applied to a collaborative architecture including a device layer (Device Layer), an edge layer (Edge Layer) and a cloud layer (Cloud Layer), and the steps are as follows: (1) Macro candidate screening: After a large number of original workflow tasks are generated at the device layer, they are first gathered to the central scheduler. The central scheduler aggregates and processes these tasks internally to form workflow task blocks. Macro candidate node screening is performed on the task blocks to obtain a set of candidate nodes. (2) Micro-level collaborative scheduling: Graph neural networks (GNN) are used to give deep reinforcement learning (DRL) agents a global network view, thereby achieving efficient and intelligent edge-to-edge collaborative scheduling within the candidate node set. (3) Local dynamic optimization: When a workflow task block is assigned to the target edge node for execution, the resource manager of the edge node takes over the task and adopts a resource allocation mechanism based on priority segmentation and sliding window as the basic framework for local execution. On the basic framework, a joint optimization strategy with dynamic target weighting is introduced.

[0007] According to a preferred embodiment of the present invention, in step (1), specifically: (11) Workflow task clustering: In order to cope with the high scheduling complexity caused by a large number of concurrent workflows gathered to the central scheduler, the original tasks with similar computational characteristics, data dependencies or generation locations are aggregated into workflow task blocks through a preprocessing process to reduce the scheduling granularity. The clustering process adopts the task clustering algorithm known in the field, such as the incremental flow clustering method based on the weighted distance of multi-dimensional task attributes, which comprehensively considers the task deadline, computational amount and spatial location attributes to dynamically generate task blocks.

[0008] (12) Candidate node selection based on probabilistic optimization: After the task block is formed, a fast candidate node selection process is performed for the task block. A probabilistic intelligent selection strategy is adopted to achieve a balance between optimal resource utilization and suboptimal node exploration.

[0009] According to a further preferred embodiment of the present invention, in step (11), computational pattern similarity is introduced as a key criterion. To resolve the fuzzy concept of similarity, computational pattern similarity is quantitatively defined. First, the computational pattern of each task (including computational resource preferences and runtime environment dependency features) is represented as a high-dimensional feature vector C. pattern This vector is used to encode the proportion of different computing power units such as CPU and GPU required by the task, as well as the dependence on specific software libraries or operating environments (e.g., represented by one-hot encoding). Subsequently, the similarity of patterns is calculated using cosine similarity metric. This function is used to calculate the similarity score between two feature vectors, and its formula is as follows:

[0010] in, represent The L2 norm, also known as the Euclidean length or modulus, is the square root of the sum of the squares of each element in a vector, representing the "size" or "strength" of the vector in multidimensional space. This design ensures internal consistency in the computational requirements of task blocks, thus facilitating the matching of edge nodes with corresponding computational capabilities.

[0011] Therefore, the calculation pattern similarity as a key criterion specifically means: a new task i When attempting to join an existing task block, compute the new task. i eigenvectors The cosine similarity between the computational pattern centroid and the existing computational pattern centroid of the task block. The computational pattern centroid is the mean of all feature vectors within the task block. This similarity score is denoted as Sim(i, block). When Sim(i, block) is higher than a preset similarity threshold r, sim (e.g. r) sim When >0.9), new task Only then are aggregations allowed; After clustering, the central scheduler calculates representative features at two levels for each task block: one is the geographic centroid p, where p is the source location coordinates of a task block containing m original tasks. m y m The coordinates (x, y) of the geographic centroid p are obtained by averaging all coordinates. p y p ):

[0012]

[0013] Geographical center This serves as a representative geographic location for this logical task block, used to characterize the spatial location of the task block in subsequent weighted distance calculations. Second, the centroid of the computational pattern. The final feature vector obtained by averaging the core computational attributes of each task within the task block is the centroid of the computational pattern. The core computational attributes are a vector, specifically including: the total computational amount of the task, the deadline of the task, the resource preference ratio of CPU / GPU computing power, and the dependence on specific software libraries or operating environments (which can be represented by one-hot encoding). The centroid of the computational pattern is used to characterize the overall computational requirements of the task block in the subsequent scheduling stage (such as step (2)).

[0014] According to a preferred embodiment of the present invention, the specific process in step (12) is as follows: (121) Calculate the weighted distance of each node: For the task block i to be scheduled Bk and every available edge node EN j Calculating a weighted distance that takes into account both physical distance and node resources involves two steps: a: Edge node weight assignment, for the j-th edge node EN j Assign weights Weight R is the current remaining computing resources of this edge node. j A function of (t), i.e. Weight It reflects the overall weight of a node in terms of computing power, storage, or network capabilities. The larger the weight value, the more available resources the edge node has and the stronger its service capabilities. b: Weighted distance calculation, defining task block i Bk The geographic centroid p and each edge node EN j Center position q j The weighted distance is D w (p,q) j );

[0015] Where d(p,q) j ) represents task block i Bk With the center position q of the edge node j The Euclidean distance between them, and the weighted distance, measures the overall matching degree between the task block and the edge node; (122) Convert the weighted distance into a competitiveness score: calculate the EN of each edge node. j Relative to task block i Bk After weighting the distance, this cost-based indicator (the smaller the distance, the better) is transformed into a benefit-based indicator (the higher the score, the better), which is denoted as the competitiveness score. The competitiveness score is calculated using the reciprocal of the weighted distance, i.e. ,in, Represents edge node EN j For the currently scheduled task block i Bk To avoid numerical instability or division-by-zero errors when the weighted distance approaches zero, a very small positive constant is introduced into the denominator for the competitiveness score. (equal to 10) -9 As a smoothing term, the optimized formula is obtained: This processing maintains the strong inverse relationship between the score and the weighted distance, effectively avoids numerical anomalies, and ensures the stability and robustness of the calculation process. Ultimately, the competitiveness score can intuitively and quantitatively reflect the attractiveness of each edge node to the current task block. (123) Constructing a probability distribution and sampling candidate nodes: Based on the competitiveness scores of edge nodes, a probability distribution is constructed, and a set of candidate nodes is selected through weighted random sampling. Specifically: A: The probability distribution is constructed by using the competitiveness scores of all N edge nodes to create a discrete probability distribution. This is achieved by applying the EN values ​​of the edge nodes. j The probability P of being selected is obtained by normalizing the competitiveness score. j The calculation formula is: ,in, It is the sum of the competitiveness scores calculated by all N edge nodes for the same task block. Through normalization, it is ensured that the sum of the probabilities of all edge nodes being selected is 1 (i.e., ...). Thus, an effective probability distribution is formed; B: After obtaining the probability distribution of all edge nodes through the weighted random sampling process, K weighted random samplings without replacement are performed to select the final set of candidate nodes. (124) Anomaly Handling and Backup Mechanism: To ensure the stable operation of the entire scheduling process under any extreme conditions, a deterministic backup plan is designed. When an anomaly is detected during the execution of weighted random sampling (e.g., all nodes are overloaded, the network is down or there is an anomaly, resulting in an infinite weighted distance, or numerical underflow or floating-point arithmetic error occurs during probability calculation), the anomaly handling and backup mechanism is automatically triggered, immediately suspending the probabilistic sampling process and switching to the backup plan: First, obtain the original weighted distances of all edge nodes that have been calculated. Subsequently, these weighted distances are sorted in ascending order. If the weighted distances are equal (e.g., all are infinite), their relative order is determined according to a preset deterministic rule (e.g., ascending order by node ID). Finally, the top K nodes in this sorted list are deterministically selected as the final candidate node set.

[0016] According to a preferred embodiment of the present invention, in step (2), specifically: (21) System state awareness: In order to realize context-aware decision-making, the current state of candidate nodes and their interrelationships are represented in a structured way. Traditional DRL methods usually flatten all state information into a long vector. This method will lose the topological association information between nodes. To overcome this defect, the state is dynamically constructed into a graph structure. (22) GNN feature extraction: In order to enable deep reinforcement learning agents to understand the complex relationships of graph structure data and perform effective relational reasoning, graph neural networks (GNN) are introduced as state encoders. Its core function is to generate an intelligent profile for each node in the graph (including candidate edge nodes and cloud nodes), that is, a low-dimensional vector representation containing its own state and surrounding network environment information. The information propagation of graph neural networks strictly follows the actual connections in the graph, naturally learning and reflecting the real connectivity and isolation relationships between nodes. (23) DRL Cooperative Scheduling Decision: After obtaining the system state encoded by the graph neural network and containing contextual information, the final cooperative scheduling decision is achieved using the deep reinforcement learning Actor-Critic framework.

[0017] According to a preferred embodiment of the present invention, in step (21), specifically: (211) Definition and structure of graphs: At each decision moment, for the task block to be scheduled, a dynamic and focused subgraph G is constructed. t = (V, E, X) t The specific composition is as follows: Node set (V): The nodes in the graph not only include the K candidate edge nodes selected in step (1), but also always include cloud nodes as a special, resource-rich backup node. Therefore, the total number of nodes is K+1. Edge set (E): The edges in the graph represent the logical communication links between nodes. The central scheduler dynamically constructs the edge set based on the real-time network detection data (such as connectivity and latency) provided by the monitoring agents of each edge node. Feature set (X) t ): The dynamic information carrier of the graph, containing the real-time state features of nodes and edges at each decision time t, composed of node feature vectors and edge feature vectors, used to comprehensively describe the state of the graph to the GNN model. Node Feature Vector: Each node is associated with a feature vector that describes its current resource status. This vector includes five core metrics: computing resource load (e.g., the combined utilization percentage of CPU and GPU), remaining computing capacity (the part remaining after subtracting the used computing power from the node's total computing power), memory utilization (the percentage of currently used physical memory to the total memory), task queue length (the number of tasks waiting to be processed), and node type identifier (a binary identifier, e.g., 0 for edge nodes and 1 for cloud centers, used to distinguish node types).

[0018] Edge feature vector: Each edge is associated with a feature vector to describe its current network status, including two core metrics: available bandwidth (the remaining available bandwidth monitored in real time on the link) and network latency (round-trip communication latency between two nodes).

[0019] (212) Construct a state graph. The monitoring agents deployed on each edge node periodically report the node's own state and the link state to other candidate nodes to the central scheduler. When the central scheduler receives a new task block and completes the macro-candidate screening, it aggregates this latest real-time information to construct the state graph G for the task block at the current decision moment. t .

[0020] According to a preferred embodiment of the present invention, in step (22), the graph neural network implementation process simulates a multi-round information exchange and integration process. In each layer, each node will: send its current profile information to all directly connected neighboring nodes; then, collect the information sent by all neighboring nodes; and finally, combine its own information to update and form a richer and more comprehensive new profile. After propagation through H layers (a pre-set total number of iterations, such as 2 or 3 layers), the final vector representation of each node not only retains its original state features but also integrates its H layers. By incorporating topological features and resource load information within the hop neighborhood, the originally independent node states are transformed into deep feature representations with context awareness, thereby enabling a more accurate characterization of the node's position, role, and interaction with other nodes in the local network environment. The multi-layer propagation process of a graph neural network is formally represented by the following update formula:

[0021] Where, N j It is the edge node EN j The neighborhood group, Representing neighbor node EN i The current image (feature vector) at the h-th layer can be viewed as the neighbor node EN. i In this round, we need to share with the edge node EN. j Information, W h It is a trainable weight matrix shared among all nodes in layer h, with dimensions [input feature dimension, output feature dimension]. It acts like a smart filter, using linear transformation to adjust the weights from neighboring nodes EN. i Original portrait sent Extract, transform, and focus on nodes The most useful information It is a normalization constant, c ji It is a symmetric normalization factor related to node degree, and its specific calculation formula is as follows: Where Degree(j) and Degree(i) represent neighbor node EN respectively. i and edge node ENj The degree (i.e., the number of edges directly connected to a node) is a normalization constant. Introducing this constant balances information transfer, preventing high-degree nodes from having excessively high information weight and low-degree nodes from having excessively low information weight, thus stabilizing the learning process. It is a non-linear activation function (such as ReLU) that enables nodes to learn and express more complex, non-linear relationships between nodes when integrating information. Represents edge node EN j After a complete round of information exchange, interpretation, summarization, and reflection, a new profile is formed for the next layer (the h+1th layer); According to a preferred embodiment of the present invention, in step (23), specifically: (231) Actor-Critic framework: The Actor-Critic dual network structure works together. The Actor network is responsible for generating the scheduling strategy, receiving the state representation output by the graph neural network, and determining the specific scheduling action accordingly, that is, allocating the workflow task blocks to the appropriate nodes. The Critic network is responsible for value evaluation. Based on the state representation, it estimates the long-term value of the current state or taking a specific action in the current state, and provides guidance signals for the Actor network's strategy update. Through this collaborative mechanism, the agent can continuously optimize the existing scheduling scheme while exploring new strategies. (232) State space: The state input of a deep reinforcement learning agent is the final feature vector set of all candidate nodes (including cloud nodes) generated by the graph neural network. This feature set integrates contextual information such as network topology and resource load, providing a high-dimensional structured input for subsequent policy decisions. (233) Action space: In order to achieve collaborative task scheduling, the action space is designed to cover the probability distribution of all candidate nodes (K edge nodes and 1 cloud node). Specifically, the Actor network outputs a vector with dimension K+1, each element of which corresponds to a candidate node. Its value represents the probability of scheduling the current task block to that node, and the node with the highest probability is selected as the execution target. (234) Reward Function: To achieve an adaptive balance among multiple objectives such as task completion rate, resource utilization rate, and migration cost, a multi-objective reward function with dynamically adjusted weights is designed. The priority of each optimization objective is flexibly adjusted according to the running stage. Considering that reinforcement learning algorithms aim to maximize cumulative rewards, while this invention needs to minimize the comprehensive cost (including migration overhead, task timeout penalty, and resource imbalance penalty), the immediate reward r is... t Defined as the negative of the total cost, this allows the agent to equivalently minimize the total cost while maximizing the reward:

[0022] Among them, w1, w2, and w3 are weighting coefficients; For migration costs, Total response delay = CL t +FL t CL t To calculate latency (the time it takes for a workflow task block to complete processing on the target node). Forwarding delay (the network time required for a workflow task block to be successfully transmitted from the central scheduler to the finally selected target node). Penalties are applied to cloud services. This is a task completion rate penalty term used to ensure tasks are completed on time. It is an event-driven, binary penalty term. , where C miss It is a penalty constant used to severely punish the behavior of missing deadlines; This is a resource utilization penalty term used to encourage the system to achieve global load balancing. After executing the scheduling decision, the new load states of all K+1 candidate nodes are predicted, and their variances are calculated.

[0023] in, This is a penalty for resource utilization. It is the standard function for calculating variance. It is a set; The larger the variance, the greater the load difference between nodes, the more unbalanced the system, and the higher the penalty value. Through this mechanism, the AI ​​tends to choose scheduling schemes that can make the overall load of the cluster more balanced, thereby improving the overall resource utilization.

[0024] (235) Policy learning: Deep reinforcement learning agents construct an adaptive policy optimization mechanism based on temporal-difference error (TD-error) through continuous interaction with the environment. This mechanism is driven by the action kernel and the evaluation kernel. The two form a closed-loop update structure of prediction-feedback-correction between decision-making and evaluation, realizing the dynamic iteration and global convergence of the policy. ① The learning cycle mechanism strictly follows a chronological order and includes the following steps: State evaluation and action selection: The action kernel and the evaluation kernel simultaneously receive the current system state s encoded by the GNN. t The action core outputs the action probability distribution and selects the optimal action. The evaluation kernel provides a value assessment of the current state and outputs a priori prediction of its long-term value, V(s).t ); Environmental interaction and feedback acquisition: The system executes the selected action. The environment generates immediate feedback signals, including the immediate reward r for this action. t and the next state to enter s t+1 ; Next state value assessment: The assessment kernel receives the new state s t+1 It then performs a value assessment and outputs its long-term return forecast V(s). t+1 (i) refers to an ex-post assessment of potential future benefits; Timing differential error calculation: Timing differential error The gap between actual returns and prior predictions is quantified using the following formula:

[0025] in, This is a discount factor used to weigh the importance of future returns. This indicates that the actual effect of the action is better than expected (positive reinforcement signal). This indicates that the result is lower than expected (a negative penalty signal); Parameter updates and strategy changes: utilizing As a learning signal, the action kernel and evaluation kernel parameters are updated synchronously through backpropagation, thereby achieving synergistic optimization of strategy and value estimation; ② To achieve synergistic optimization of the action kernel and the evaluation kernel, the following joint loss function is designed:

[0026] Among them, A pro Indicates the action check of the selected action. log probability ; The evaluation kernel part minimizes the squared prediction error term. It continuously approximates the true value function V(s), thereby improving the estimation accuracy of long-term returns and providing a stable and reliable value benchmark for strategy optimization; The action core section utilizes timing differential error signals. Perform a strategy update: when When (indicating a return exceeding expectations), the gradient descent process will prompt the action kernel to increase the probability of choosing the current action. ;when If the return is lower than expected, then reduce the probability of choosing it. ③ Policy Convergence and Performance Evolution: During long-term cyclic training, the action kernel and the evaluation kernel converge through... The signals form a continuous game and cooperative relationship. The evaluation kernel continuously corrects the estimation error of the state value, while the action kernel relies on the feedback from the evaluation kernel to continuously adjust the policy distribution. When the two reach a balance, the policy gradually converges to the optimal solution.

[0027] According to a preferred embodiment of the present invention, in step (3), the joint optimization strategy uses an online learning model to optimize the window length. The local scheduling strategy continuously adjusts two key parameters—the target weight w—in conjunction with the task arrival rate. This allows the strategy to adapt not only to the task arrival rate but also to the task type (e.g., automatically increasing the weight of "task completion rate" when tasks are urgent). This maintains high efficiency and stable performance under varying task conditions. The detailed steps of the joint optimization process are as follows: Joint optimization of adaptive window and target weights: performance is highly dependent on two key parameters, window length. The frequency and granularity of scheduling are determined, and the target weights are optimized. This determines whether the optimization focus is on task timeliness or resource economy. These two parameters are no longer fixed values, but are jointly and continuously adjusted by an online learning algorithm based on Bayesian optimization. The entire optimization process is constructed into a closed loop of modeling -> decision-making -> execution -> update. (31) Modeling and expanding the performance prediction model, using Gaussian Process Regression (GPR) as the performance prediction model; (32) Decision: After obtaining the performance prediction (including expected value and uncertainty) of Gaussian process regression, a sampling function is used to determine the next parameter combination to be tried. Select the optimal parameter combination ; (33) Execution and Update: Applying the optimal parameter combination Configure the local scheduler and execute a complete scheduling cycle. After the cycle ends, observe the actual performance during the cycle. This refers to the actual average task violation rate and resource utilization rate, using real data points. It is added to the historical database, and then the Gaussian process regression learning model uses this complete historical database containing real data points to update.

[0028] According to a preferred embodiment of the present invention, in step (31), specifically: (311) Learning Objective: Gaussian process regression learns from a two-dimensional input A complex mapping relationship y=f(x) to a scalar output (performance metric y) is modeled as a Gaussian process (GP) distribution:

[0029] Where M(x) is the mean function, which is usually set to zero to indicate no prior preference; For the kernel function, a "similarity" is defined between the performance outputs corresponding to different parameter combinations. To capture the periodic and non-periodic features in the task pattern, a window length is defined. The following composite kernel is used in terms of dimension:

[0030] In the formula, the first part is the periodic kernel. and 'Indicates the length of the sliding window with periodic similarity. The signal variance is the overall variation of the control function output value (i.e., system performance). The length scale controls the smoothness of the function, defining the distance over which input values ​​(window length) are still considered relevant, thus determining how drastic the performance changes with the window length and characterizing the smoothness of the periodic parts. The period is used to capture periodic patterns in task modes, and its value defines the time interval at which the performance function repeats itself.

[0031] The second part is the Gaussian kernel: For signal variance, Using length as a scale, it characterizes the smoothness of the non-periodic portion. The larger the size, the smoother the change; The smaller the size, the more drastic the change; This composite kernel function can simultaneously model both periodic features and non-periodic perturbations in the task arrival pattern, thereby achieving an accurate characterization of the relationship between sliding window length and performance.

[0032] (312) Definition of performance index y: In order to achieve a balance of multiple objectives, the performance index y is defined as a weighted function that integrates task completion and resource utilization. The weighted function is the unknown mapping function that Gaussian process regression attempts to learn and approximate in step (311). In practice, the better the scheduling, the higher the y-value.

[0033] in, , The target weights are selected by the intelligent decision-making module; The average task violation rate is represented in the window. The percentage of tasks that were not completed on time is calculated as follows:

[0034] in, This represents the total number of tasks within the time window, and v(i) is the violation indicator function. v(i) = 1 when a task is not completed on time, and 0 otherwise. This represents the sum of v(i) of all tasks within the window, i.e., the total number of tasks that have violated the rules within the window; This represents the on-time completion rate of tasks; This represents the average resource utilization rate; it is indicated in the window. The computing resource usage of all edge nodes is calculated as follows:

[0035] in, This represents the total number of edge nodes participating in the computation. For edge node EN j In the time window The actual amount of computing resources used, i.e., the resources already used. For edge nodes in the time window The total amount of computing resources that can be provided, i.e., available resources. The EN of a single edge node was calculated. j The resource utilization rate provided within the window will affect all... Add up the utilization rates of each edge node, and then divide by . This yields the average resource utilization rate of all edge nodes.

[0036] An edge-cloud collaborative adaptive workflow scheduling system includes: The filtering module is used to gather the raw workflow tasks generated by the device layer to the central scheduler. The central scheduler aggregates and processes the tasks internally to form workflow task blocks, and performs macro-level candidate node filtering on the task blocks to obtain a set of candidate nodes. The micro-cooperative scheduling module utilizes graph neural networks to give deep reinforcement learning agents a global network perspective, thereby achieving edge-to-edge cooperative scheduling within the candidate node set. The local dynamic optimization module takes over the task when a workflow task block is assigned to a target edge node for execution. The resource manager of the edge node takes over the task and adopts a resource allocation mechanism based on priority segmentation and sliding window as the basic framework for local execution. On this basic framework, a joint optimization strategy with dynamic target weighting is introduced.

[0037] The beneficial effects of this invention are as follows: This invention constructs a three-stage progressive decision-making system, including macro-level candidate screening, collaborative scheduling decision-making, and local adaptive optimization. First, in the macro-level candidate screening stage, task clustering reduces the problem granularity, and a probabilistic optimization strategy based on weighted distance achieves a balance between utilization and exploration, quickly selecting high-quality candidate nodes for each task block, thus initially simplifying the global scheduling problem. Next, in the collaborative scheduling decision-making stage, a global network state graph is constructed using a graph neural network (GNN), extracting deep spatial features of nodes and their neighborhoods to form a "context-aware" state representation. The reinforcement learning agent then makes the optimal collaborative decision among multiple options such as local execution, edge migration, or cloud offloading. Finally, in the local adaptive optimization stage, fine-grained optimization is performed after the task is issued. An online learning mechanism dynamically adjusts the scheduling frequency and multi-objective weights, achieving a balance between task deadlines and resource utilization, ensuring efficient and robust execution at the node level. Attached Figure Description

[0038] Figure 1 This is a flowchart of the method of the present invention; Figure 2 This is a flowchart of the weighted random sampling without replacement process of the present invention. Figure 3 This is a flowchart of the candidate node selection process based on probabilistic optimization according to the present invention. Figure 4 This is a flowchart of the state graph construction process for GNN-oriented decision-making in this invention; Figure 5 This is a flowchart of the GNN feature extraction process of the present invention; Figure 6 This is a flowchart of the DRL collaborative scheduling decision-making process of the present invention; Figure 7 Local dynamic optimization of the online learning process flowchart. Detailed Implementation

[0039] The present invention will be further described below with reference to the embodiments and accompanying drawings, but is not limited thereto.

[0040] Example 1: This embodiment provides an edge-cloud collaborative adaptive workflow scheduling method, such as... Figure 1As shown, this architecture is applied to a collaborative structure comprising a Device Layer, an Edge Layer, and a Cloud Layer. The bottom Device Layer integrates numerous IoT devices (such as cameras and sensors) responsible for data collection and initial processing. The middle Edge Layer consists of geographically dispersed Edge Nodes (ENs) with independent computing and storage capabilities, providing low-latency local responses; this layer interconnects with the Device Layer via wired / wireless connections. The top Cloud Layer comprises a Cloud Data Center, responsible for global resource scheduling and optimization control, and communicates with the Edge Layer via wired connections. These three layers are tightly interconnected through a multimodal network composed of fiber optics, 5G / Wi-Fi, and other technologies.

[0041] Unlike traditional three-layer structures, this embodiment introduces Graph Neural Networks (GNNs) and Collaborative Reinforcement Learning (CRL) mechanisms into the edge layer. This enables edge nodes to share topology-aware information and decision-making experience, thereby achieving cross-node adaptive scheduling optimization. Specifically, the core scheduling optimization method of this embodiment is deployed in the edge layer. By combining task awareness, resource monitoring, and transmission modeling, it utilizes GNNs to achieve structured state representation and leverages reinforcement learning agents for policy optimization, thereby achieving efficient workflow scheduling and improved resource utilization in a multimodal network environment.

[0042] The scheduling method steps are as follows: (1) Macro candidate screening: After a large number of original workflow tasks are generated at the device layer, they are first gathered to the central scheduler. The central scheduler aggregates and processes these tasks internally to form workflow task blocks. Macro candidate node screening is performed on the task blocks to obtain a set of candidate nodes. (11) Workflow task clustering: In order to cope with the high scheduling complexity caused by a large number of concurrent workflows gathered to the central scheduler, the original tasks with similar computational characteristics, data dependencies or generation locations are aggregated into workflow task blocks through a preprocessing process to reduce the scheduling granularity. The clustering process adopts the task clustering algorithm known in the field, such as the incremental flow clustering method based on the weighted distance of multi-dimensional task attributes, which comprehensively considers the task deadline, computational amount and spatial location attributes to dynamically generate task blocks.

[0043] To address the ambiguity of the concept of similarity, computational pattern similarity is quantitatively defined by introducing computational pattern similarity as a key criterion. First, the computational pattern of each task (including computational resource preferences and runtime environment dependencies) is represented as a high-dimensional feature vector C. patternThis vector is used to encode the proportion of different computing power units such as CPU and GPU required by the task, as well as the dependence on specific software libraries or operating environments (e.g., represented by one-hot encoding). Subsequently, the similarity of patterns is calculated using cosine similarity metric. This function is used to calculate the similarity score between two feature vectors, and its formula is as follows:

[0044] in, represent The L2 norm, also known as the Euclidean length or modulus, is the square root of the sum of the squares of each element in a vector, representing the "size" or "strength" of the vector in multidimensional space. This design ensures internal consistency in the computational requirements of task blocks, thus facilitating the matching of edge nodes with corresponding computational capabilities.

[0045] Therefore, the calculation pattern similarity as a key criterion specifically means: a new task i When attempting to join an existing task block, compute the new task. i eigenvectors The cosine similarity between the computational pattern centroid and the existing computational pattern centroid of the task block. The computational pattern centroid is the mean of all feature vectors within the task block. This similarity score is denoted as Sim(i, block). When Sim(i, block) is higher than a preset similarity threshold r, sim (e.g. r) sim When >0.9), new task Only then are aggregations allowed; After clustering, the central scheduler calculates representative features at two levels for each task block: one is the geographic centroid p, where p is the source location coordinates of a task block containing m original tasks. m y m The coordinates (x, y) of the geographic centroid p are obtained by averaging all coordinates. p y p ):

[0046]

[0047] Geographical center This serves as a representative geographic location for this logical task block, used to characterize the spatial location of the task block in subsequent weighted distance calculations. Second, the centroid of the computational pattern. The final feature vector obtained by averaging the core computational attributes of each task within the task block is the centroid of the computational pattern. The core computational attributes are a vector, specifically including: the total computational amount of the task, the deadline of the task, the resource preference ratio of CPU / GPU computing power, and the dependence on specific software libraries or operating environments (which can be represented by one-hot encoding). The centroid of the computational pattern is used to characterize the overall computational requirements of the task block in the subsequent scheduling stage (such as step (2)).

[0048] (12) Candidate node selection based on probabilistic optimization: After the task block is formed, a fast candidate node selection process is performed for the task block. A probabilistic intelligent selection strategy is adopted to achieve a balance between optimal resource utilization and suboptimal node exploration. The specific process is as follows: (121) Calculate the weighted distance of each node: For the task block i to be scheduled Bk and every available edge node EN j Calculating a weighted distance that takes into account both physical distance and node resources involves two steps: a: Edge node weight assignment, for the j-th edge node EN j Assign weights Weight R is the current remaining computing resources of this edge node. j A function of (t), i.e. Weight It reflects the overall weight of a node in terms of computing power, storage, or network capabilities. The larger the weight value, the more available resources the edge node has and the stronger its service capabilities. b: Weighted distance calculation, defining task block i Bk The geographic centroid p and each edge node EN j Center position q j The weighted distance is D w (p,q) j );

[0049] Where d(p,q) j ) represents task block i Bk With the center position q of the edge node j The Euclidean distance between them, and the weighted distance, measures the overall matching degree between the task block and the edge node; (122) Convert the weighted distance into a competitiveness score: calculate the EN of each edge node. j Relative to task block i BkAfter weighting the distance, this cost-based indicator (the smaller the distance, the better) is transformed into a benefit-based indicator (the higher the score, the better), which is denoted as the competitiveness score. The competitiveness score is calculated using the reciprocal of the weighted distance, i.e. ,in, Represents edge node EN j For the currently scheduled task block i Bk To avoid numerical instability or division-by-zero errors when the weighted distance approaches zero, a very small positive constant is introduced into the denominator for the competitiveness score. (equal to 10) -9 As a smoothing term, the optimized formula is obtained: This processing maintains the strong inverse relationship between the score and the weighted distance, effectively avoids numerical anomalies, and ensures the stability and robustness of the calculation process. Ultimately, the competitiveness score can intuitively and quantitatively reflect the attractiveness of each edge node to the current task block. (123) Constructing a probability distribution and sampling candidate nodes: Based on the competitiveness scores of edge nodes, a probability distribution is constructed, and a set of candidate nodes is selected through weighted random sampling. Specifically: A: The probability distribution is constructed by using the competitiveness scores of all N edge nodes to create a discrete probability distribution. This is achieved by applying the EN values ​​of the edge nodes. j The probability P of being selected is obtained by normalizing the competitiveness score. j The calculation formula is: ,in, It is the sum of the competitiveness scores calculated by all N edge nodes for the same task block. Through normalization, it is ensured that the sum of the probabilities of all edge nodes being selected is 1 (i.e., ...). Thus, an effective probability distribution is formed; B: After obtaining the probability distribution of all edge nodes through the weighted random sampling process, K weighted random samplings without replacement are performed to select the final set of candidate nodes. First, create a candidate pool containing all edge nodes and their initial probability distributions; Subsequently, the core sampling step is implemented by simulating the roulette wheel selection process. Based on the probability of each edge node in the candidate pool, a cumulative probability distribution array is calculated. This array is equivalent to dividing each edge node on the roulette wheel into sectors of different sizes—the higher the probability of a node, the larger the corresponding sector area. Then, a random floating-point number is generated in the interval [0, 1) as a pointer when the roulette wheel stops, and this pointer is compared with the boundary of the cumulative probability distribution to determine the specific sector it falls into, thereby selecting the corresponding edge node. Since nodes with higher probabilities have wider sectors, they are more likely to be selected. Since this process is sampling without replacement, when an edge node is selected and removed from the candidate pool, the sum of the probabilities of the remaining nodes will no longer be 1. To ensure the fairness and effectiveness of subsequent sampling, the probabilities of the remaining nodes need to be renormalized: that is, the original probability of each remaining edge node in the candidate pool is divided by the sum of the original probabilities of the remaining edge nodes to obtain their updated probabilities in the new round of sampling.

[0050] Ultimately, after K rounds of "building cumulative probability -> random location -> removing nodes -> probability renormalization", the system selects K non-repeating candidate edge nodes to form the final set. This set tends to prioritize the optimal node while retaining the flexibility to explore suboptimal nodes.

[0051] It should be noted that the number of candidate nodes K is a key hyperparameter. It is not dynamically calculated by the algorithm, but is pre-set based on a core performance trade-off. This trade-off is the balance between decision accuracy and decision speed in step (2). At the same time, although this weighted sampling process requires K rounds of iteration, its time cost is extremely low. Compared to the traversal and evaluation of all N nodes in the entire network in the early stage of the process and the neural network inference in the subsequent second step, this... The sampling computation performed in memory by each round is almost negligible. Therefore, the choice of K value is mainly limited by the computational power of process two, rather than the performance of this sampling step itself.

[0052] Figure 2 It demonstrates the specific implementation process of weighted random sampling without replacement, which aims to select a final candidate set of K nodes from N initial nodes based on their probability distribution.

[0053] (124) Anomaly Handling and Backup Mechanism: To ensure the stable operation of the entire scheduling process under any extreme conditions, a deterministic backup plan is designed. When an anomaly is detected during the execution of weighted random sampling (e.g., all nodes are overloaded, the network is down or there is an anomaly, resulting in an infinite weighted distance, or numerical underflow or floating-point arithmetic error occurs during probability calculation), the anomaly handling and backup mechanism is automatically triggered, immediately suspending the probabilistic sampling process and switching to the backup plan: First, obtain the original weighted distances of all edge nodes that have been calculated. Subsequently, these weighted distances are sorted in ascending order. If the weighted distances are equal (e.g., all are infinite), their relative order is determined according to a preset deterministic rule (e.g., ascending order by node ID). Finally, the top K nodes in this sorted list are deterministically selected as the final candidate node set.

[0054] Through this process, even if the probability calculation stage fails or the data is abnormal, a set of candidate nodes with a fixed size and valid results can still be output, thus ensuring that the scheduling task is not interrupted. This mechanism plays a safety fallback role in the overall architecture, effectively avoiding task failures caused by unexpected calculation errors, abnormal resource status, or data distortion, and significantly improving the robustness and reliability of the system.

[0055] Figure 3 This paper demonstrates a candidate node selection method based on probabilistic optimization, the core of which is to evaluate all edge nodes by calculating weighted distances and constructing probability distributions.

[0056] In summary, through this comprehensive process integrating competitiveness score conversion, probabilistic optimal sampling, and robustness assurance mechanisms, a small but high-quality set of candidate nodes is quickly and dynamically generated for each task block. This set will be passed as input to Process Two (the micro-level collaborative scheduling decision module), where the GNN+DRL model will perform the final refined collaborative scheduling within this intelligently filtered and significantly simplified decision space.

[0057] (2) Micro-level collaborative scheduling: Graph neural networks (GNN) are used to give deep reinforcement learning (DRL) agents a global network view, thereby achieving efficient and intelligent edge-to-edge collaborative scheduling within the candidate node set. (21) System State Awareness: To achieve context-aware decision-making, the current state of candidate nodes and their interrelationships are represented in a structured manner. Traditional DRL methods typically flatten all state information into a long vector, which loses the topological association information between nodes. To overcome this defect, the state is dynamically constructed into a graph structure, specifically: (211) Definition and structure of graphs: At each decision moment, for the task block to be scheduled, a dynamic and focused subgraph G is constructed. t = (V, E, X) t The specific composition is as follows: Node set (V): The nodes in the graph not only include the K candidate edge nodes selected in step (1), but also always include cloud nodes as a special, resource-rich backup node. Therefore, the total number of nodes is K+1. Edge set (E): The edges in the graph represent logical communication links between nodes. The central scheduler dynamically constructs the edge set based on the real-time network probe data (such as connectivity and latency) provided by the monitoring agents of each edge node. Specifically, if there is a valid connection between two candidate edge nodes or between an edge node and a cloud node, then there is an edge between their corresponding nodes in the graph. At the same time, the network quality indicators (i.e., available bandwidth and network latency) contained in the probe data will be extracted as the real-time features of this edge (i.e., the edge feature vector defined in the next section c). Feature set (X) t ): The dynamic information carrier of the graph, containing the real-time state features of nodes and edges at each decision time t, composed of node feature vectors and edge feature vectors, used to comprehensively describe the state of the graph to the GNN model. Node Feature Vector: Each node is associated with a feature vector that describes its current resource status. This vector includes five core metrics: computing resource load (e.g., the combined utilization percentage of CPU and GPU), remaining computing capacity (the part remaining after subtracting the used computing power from the node's total computing power), memory utilization (the percentage of currently used physical memory to the total memory), task queue length (the number of tasks waiting to be processed), and node type identifier (a binary identifier, e.g., 0 for edge nodes and 1 for cloud centers, used to distinguish node types).

[0058] Edge feature vector: Each edge is associated with a feature vector to describe its current network status, including two core metrics: available bandwidth (the remaining available bandwidth monitored in real time on the link) and network latency (round-trip communication latency between two nodes).

[0059] (212) Construct a state graph. The monitoring agents deployed on each edge node periodically report the node's own state and the link state to other candidate nodes to the central scheduler. When the central scheduler receives a new task block and completes the macro-candidate screening, it aggregates this latest real-time information to construct the state graph G for the task block at the current decision moment. t ; Figure 4This paper demonstrates the state graph construction process for GNN-oriented decision-making. It describes how the scheduler, after receiving a task and its K candidate nodes, aggregates real-time state data generated by the monitoring agents of each node to dynamically construct a state graph G for the current decision. t And finally deliver it to GNN.

[0060] (22) GNN feature extraction: In order to enable deep reinforcement learning agents to understand the complex relationships of graph structure data and perform effective relational reasoning, graph neural networks (GNN) are introduced as state encoders. Its core function is to generate an intelligent profile for each node in the graph (including candidate edge nodes and cloud nodes), that is, a low-dimensional vector representation containing its own state and surrounding network environment information. The information propagation of graph neural networks strictly follows the actual connections in the graph, naturally learning and reflecting the real connectivity and isolation relationships between nodes. The implementation process of a graph neural network simulates a multi-round information exchange and integration process. In each layer, each node: sends its current profile information to all directly connected neighboring nodes; then, collects information from all neighboring nodes; and finally, combines its own information to update and form a richer and more comprehensive new profile. After propagation through H layers (a pre-defined total number of iterations, such as 2 or 3 layers), the final vector representation of each node not only retains its original state features but also incorporates its H layers. By incorporating topological features and resource load information within the hop neighborhood, the originally independent node states are transformed into deep feature representations with context awareness, thereby enabling a more accurate characterization of the node's position, role, and interaction with other nodes in the local network environment. The multi-layer propagation process of a graph neural network is formally represented by the following update formula:

[0061] Where, N j It is the edge node EN j The neighborhood group, Representing neighbor node EN i The current image (feature vector) at the h-th layer can be viewed as the neighbor node EN. i In this round, we need to share with the edge node EN. j Information, W h It is a trainable weight matrix shared among all nodes in layer h, with dimensions [input feature dimension, output feature dimension]. It acts like a smart filter, using linear transformation to adjust the weights from neighboring nodes EN. i Original portrait sent Extract, transform, and focus on nodes The most useful information It is a normalization constant, c ji It is a symmetric normalization factor related to node degree, and its specific calculation formula is as follows: Where Degree(j) and Degree(i) represent neighbor node EN respectively. i and edge node EN j The degree (i.e., the number of edges directly connected to a node) is a normalization constant. Introducing this constant balances information transfer, preventing high-degree nodes from having excessively high information weight and low-degree nodes from having excessively low information weight, thus stabilizing the learning process. It is a non-linear activation function (such as ReLU) that enables nodes to learn and express more complex, non-linear relationships between nodes when integrating information. Represents edge node EN j After a complete round of information exchange, interpretation, summarization, and reflection, a new profile is formed for the next layer (the h+1th layer); The total number of iterations, H, is a key hyperparameter of the GNN, set empirically or experimentally to control the scope of information propagation (i.e., the number of neighbor hops a node can perceive). It is typically set to 2 or 3 layers to balance model performance and computational cost; the optimal value can be obtained through experimental tuning. After these H iterations, the final output of the GNN is a set of final feature vectors for all candidate nodes in the graph (K candidate edge nodes + 1 cloud node). These vectors have low dimensionality but extremely high information density, forming the final "intelligent profile" of each node. They will serve as the state input for the DRL agent, used to make accurate collaborative scheduling decisions in the future.

[0062] Figure 5 This demonstrates the feature extraction process of a Graph Neural Network (GNN), i.e., the information propagation mechanism. It depicts a multi-layered iterative process in which each node gradually generates its own feature vector, which is richer in contextual information, by aggregating and transforming the features of its neighboring nodes, until a preset total number of layers is reached.

[0063] (23) DRL Cooperative Scheduling Decision: After obtaining the system state encoded by the graph neural network, which contains contextual information, the final cooperative scheduling decision is achieved using the deep reinforcement learning Actor-Critic framework. Specifically: (231) Actor-Critic framework: The Actor-Critic dual network structure works together. The Actor network is responsible for generating the scheduling strategy, receiving the state representation output by the graph neural network, and determining the specific scheduling action accordingly, that is, allocating the workflow task blocks to the appropriate nodes. The Critic network is responsible for value evaluation. Based on the state representation, it estimates the long-term value of the current state or taking a specific action in the current state, and provides guidance signals for the Actor network's strategy update. Through this collaborative mechanism, the agent can continuously optimize the existing scheduling scheme while exploring new strategies. (232) State space: The state input of a deep reinforcement learning agent is the final feature vector set of all candidate nodes (including cloud nodes) generated by the graph neural network. This feature set integrates contextual information such as network topology and resource load, providing a high-dimensional structured input for subsequent policy decisions. (233) Action space: In order to achieve collaborative task scheduling, the action space is designed to cover the probability distribution of all candidate nodes (K edge nodes and 1 cloud node). Specifically, the Actor network outputs a vector with dimension K+1, each element of which corresponds to a candidate node. Its value represents the probability of scheduling the current task block to that node, and the node with the highest probability is selected as the execution target. Compared to discrete action spaces that only support "local execution" or "vertical offloading to the cloud", the introduction of a continuous probability distribution allows the action space to simultaneously characterize "horizontal migration" behavior (i.e., the redistribution of workflow task blocks among edge nodes). This design effectively improves the flexibility and accuracy of scheduling strategies, enabling the system to achieve better global scheduling decisions in multi-node collaborative scenarios.

[0064] To further clarify the classification of scheduling results, the concept of a primary candidate node is defined: it refers to the edge node with the smallest weighted distance in the macro-screening stage, representing the initial optimal selection based on macro-indicators. The final decision result of the deep reinforcement learning agent based on this is the result of the initial selection. It can be divided into the following three collaborative modes according to the node type corresponding to the maximum probability output: Local execution mode: When the node with the highest probability selected by the agent is consistent with the main candidate node, it means that the workflow task block has reached a consensus in the two stages of macro screening and intelligent decision-making, and is finally executed locally on that node; Collaborative offloading mode (horizontal migration): When the node with the highest probability is an edge node other than the main candidate node in the candidate set, it is considered as collaborative offloading mode, which means that workflow task blocks are dynamically redistributed among edge nodes; Cloud processing mode (vertical offloading): When the node with the highest probability is a cloud node, it is considered to be in cloud processing mode, which means that the system chooses to offload the workflow task block to the cloud for execution; (234) Reward Function: To achieve an adaptive balance among multiple objectives such as task completion rate, resource utilization rate, and migration cost, a multi-objective reward function with dynamically adjusted weights is designed. The priority of each optimization objective is flexibly adjusted according to the running stage. Considering that reinforcement learning algorithms aim to maximize cumulative rewards, while this invention needs to minimize the comprehensive cost (including migration overhead, task timeout penalty, and resource imbalance penalty), the immediate reward r is... t Defined as the negative of the total cost, this allows the agent to equivalently minimize the total cost while maximizing the reward:

[0065] Here, w1, w2, and w3 are weighting coefficients used to balance different optimization objectives. It is important to note that, to ensure these cost items with different physical units and significant numerical differences are effectively balanced by the weighting coefficients, the system will first perform a weighting process before calculating the total cost. , and Each component is normalized, and by dynamically tracking the range of these values, they are each scaled to a comparable numerical range (e.g., [0, 1]), resulting in the final r. t These costs are calculated based on normalized values, thus ensuring that the DRL agent can make a meaningful comprehensive trade-off for all objectives. For migration costs, This section measures the overall time and resource overhead of a scheduling decision, and includes two parts: total response latency and cloud usage penalty. Total response latency = CL t +FL t CL t To calculate latency (the time it takes for a workflow task block to complete processing on the target node). Forwarding delay (the network time required for a workflow task block to be successfully transmitted from the central scheduler to the finally selected target node). The penalty for using the cloud refers to the situation where, if an agent chooses to offload workflow task blocks to the cloud, then... This is a preset positive value (this value can be determined based on the estimated economic cost of using cloud services or the average time cost of a typical edge collaboration). If an edge node is selected, Through this mechanism, the AI ​​learns that it must pay close attention to the direct time costs (computation and forwarding latency) and resource overhead (cloud usage penalties) of decision-making, and is thus guided to prioritize nodes with the lowest overall response latency and the greatest economic benefits.

[0066] This is a task completion rate penalty term used to ensure tasks are completed on time. It is an event-driven, binary penalty term. , where C miss C is a penalty constant used to strongly punish the act of missing a deadline. To ensure the absolute priority of this penalty, C... miss The value is set to a value significantly higher than the theoretical maximum value of other cost items, for example, when each cost item has been normalized to... Given the interval, C miss It can be set to a fixed value much greater than 1 (such as 10 or 100), which ensures w2·C miss The severity of the penalty in this category is numerically overwhelmingly greater than... and The sum of the maximum possible values; through this mechanism, the AI ​​learns that timeout is the most unacceptable outcome, and thus proactively prioritizes task completion rate. This is a resource utilization penalty term used to encourage the system to achieve global load balancing. After executing the scheduling decision, the new load states of all K+1 candidate nodes are predicted, and their variances are calculated.

[0067] in, This is a penalty for resource utilization. It is the standard function for calculating variance. It is a set representing the new resource load state (e.g., measured as a normalized percentage of compute resource utilization) of each of the K+1 candidate nodes (K edge nodes and 1 cloud node) after the system predicts that the current scheduling action will be performed. The larger the variance, the greater the load difference between nodes, the more unbalanced the system, and the higher the penalty value. Through this mechanism, the AI ​​tends to choose scheduling schemes that can make the overall load of the cluster more balanced, thereby improving the overall resource utilization.

[0068] (235) Policy learning: Deep reinforcement learning agents construct an adaptive policy optimization mechanism based on temporal-difference error (TD-error) through continuous interaction with the environment. This mechanism is driven by the action kernel and the evaluation kernel. The two form a closed-loop update structure of prediction-feedback-correction between decision-making and evaluation, realizing the dynamic iteration and global convergence of the policy. ① The learning cycle mechanism strictly follows a chronological order and includes the following steps: State evaluation and action selection: The action kernel and the evaluation kernel simultaneously receive the current system state s encoded by the GNN.t The action core outputs the action probability distribution and selects the optimal action. The evaluation kernel provides a value assessment of the current state and outputs a priori prediction of its long-term value, V(s). t ); Environmental interaction and feedback acquisition: The system executes the selected action. The environment generates immediate feedback signals, including the immediate reward r for this action. t and the next state to enter s t+1 ; Next state value assessment: The assessment kernel receives the new state s t+1 It then performs a value assessment and outputs its long-term return forecast V(s). t+1 (i) refers to an ex-post assessment of potential future benefits; Timing differential error calculation: Timing differential error The gap between actual returns and prior predictions is quantified using the following formula:

[0069] in, This is a discount factor used to weigh the importance of future returns. This indicates that the actual effect of the action is better than expected (positive reinforcement signal). This indicates that the result is lower than expected (a negative penalty signal); Parameter updates and strategy changes: utilizing As a learning signal, the action kernel and evaluation kernel parameters are updated synchronously through backpropagation, thereby achieving synergistic optimization of strategy and value estimation; ② To achieve synergistic optimization of the action kernel and the evaluation kernel, the following joint loss function is designed:

[0070] Among them, A pro Indicates the action check of the selected action. log probability probability The generation process is as follows: After receiving the current state s, the action kernel neural network's output layer generates an initial score for all K+1 candidate actions (i.e., each candidate node), which is then normalized to a probability distribution using the Softmax function, thus transforming it into an effective probability distribution. That is, the action that is ultimately selected and executed in this distribution. The specific probability value corresponding to it; The evaluation kernel part minimizes the squared prediction error term. It continuously approximates the true value function V(s), thereby improving the estimation accuracy of long-term returns and providing a stable and reliable value benchmark for strategy optimization; The action core section utilizes timing differential error signals. Perform a strategy update: when When (indicating a return exceeding expectations), the gradient descent process will prompt the action kernel to increase the probability of choosing the current action. ;when When (indicating lower-than-expected returns), the probability of selection is reduced, through this method based on... The adaptive probability adjustment mechanism of the signal allows the action core to gradually strengthen high-quality strategies and suppress inefficient behaviors during continuous iteration, thereby achieving dynamic convergence of the overall strategy toward the direction of optimal long-term returns. ③ Policy Convergence and Performance Evolution: During long-term cyclic training, the action kernel and the evaluation kernel converge through... The signals form a continuous game and cooperative relationship. The evaluation kernel continuously corrects the estimation error of the state value, while the action kernel relies on the feedback from the evaluation kernel to continuously adjust the policy distribution. When the two reach a balance, the policy gradually converges to the optimal solution.

[0071] Figure 6 This paper details the dynamic learning and decision-making loop of Actor-Critic reinforcement learning, demonstrating how the Actor and Critic kernels work together by calculating temporal difference errors. The core learning signals are used to synchronously update their respective networks, thereby gradually converging the overall policy to the optimal state.

[0072] (3) Local dynamic optimization: When a workflow task block is assigned to the target edge node for execution, the resource manager of the edge node takes over the task and adopts a resource allocation mechanism based on priority segmentation and sliding window as the basic framework for local execution. This basic framework is implemented using technologies known in the field, such as prioritizing tasks through critical path analysis and earliest deadline first (EDF) algorithms, and prioritizing high-priority tasks within the dynamic time window. A joint optimization strategy with dynamic target weighting is introduced on the basic framework.

[0073] The joint optimization strategy uses an online learning model to optimize the window length. The local scheduling strategy continuously adjusts two key parameters—the target weight w—in conjunction with the task arrival rate. This allows the strategy to adapt not only to the task arrival rate but also to the task type (e.g., automatically increasing the weight of "task completion rate" when tasks are urgent). This maintains high efficiency and stable performance under varying task conditions. The detailed steps of the joint optimization process are as follows: Joint optimization of adaptive window and target weights: performance is highly dependent on two key parameters, window length. The frequency and granularity of scheduling are determined, and the target weights are optimized. This determines whether the optimization focus is on task timeliness or resource economy. These two parameters are no longer fixed values, but are jointly and continuously adjusted by an online learning algorithm based on Bayesian optimization. The entire optimization process is constructed into a closed loop of modeling -> decision-making -> execution -> update. (31) Modeling and expanding the performance prediction model: Gaussian Process Regression (GPR) is adopted as the performance prediction model. GPR is a powerful nonparametric model that can not only predict the expected performance value under given parameters, but also quantify the uncertainty (variance) of the prediction, thus providing a basis for the subsequent "exploration-exploitation" balance. Specifically: (311) Learning Objective: Gaussian process regression learns from a two-dimensional input A complex mapping relationship y=f(x) to a scalar output (performance metric y) is modeled as a Gaussian process (GP) distribution:

[0074] Where M(x) is the mean function, which is usually set to zero to indicate no prior preference; For the kernel function, a "similarity" is defined between the performance outputs corresponding to different parameter combinations. To capture the periodic and non-periodic features in the task pattern, a window length is defined. The following composite kernel is used in terms of dimension:

[0075] In the formula, the first part is the periodic kernel. and 'Indicates the length of the sliding window with periodic similarity. The signal variance is the overall variation of the control function output value (i.e., system performance). The length scale controls the smoothness of the function, defining the distance over which input values ​​(window length) are still considered relevant, thus determining how drastic the performance changes with the window length and characterizing the smoothness of the periodic parts. The period is used to capture periodic patterns in task modes, and its value defines the time interval at which the performance function repeats itself.

[0076] The second part is the Gaussian kernel: For signal variance, Using length as a scale, it characterizes the smoothness of the non-periodic portion. The larger the size, the smoother the change; The smaller the size, the more drastic the change; This composite kernel function can simultaneously model both periodic features and non-periodic perturbations in the task arrival pattern, thereby achieving an accurate characterization of the relationship between sliding window length and performance.

[0077] (312) Definition of performance index y: In order to achieve a balance of multiple objectives, the performance index y is defined as a weighted function that integrates task completion and resource utilization. The weighted function is the unknown mapping function that Gaussian process regression attempts to learn and approximate in step (311). In practice, the better the scheduling, the higher the y-value.

[0078] in, , The target weights are selected by the intelligent decision-making module; The average task violation rate is represented in the window. The percentage of tasks that were not completed on time is calculated as follows:

[0079] in, This represents the total number of tasks within the time window, and v(i) is the violation indicator function. v(i) = 1 when a task is not completed on time, and 0 otherwise. This represents the sum of v(i) of all tasks within the window, i.e., the total number of tasks that have violated the rules within the window; This represents the on-time completion rate of tasks; This represents the average resource utilization rate; it is indicated in the window. The computing resource usage of all edge nodes is calculated as follows:

[0080] in, This represents the total number of edge nodes participating in the computation. For edge node EN j In the time window The actual amount of computing resources used, i.e., the resources already used. For edge nodes in the time window The total amount of computing resources that can be provided, i.e., available resources. The EN of a single edge node was calculated. j The resource utilization rate provided within the window will affect all... Add up the utilization rates of each edge node, and then divide by . This yields the average resource utilization rate of all edge nodes.

[0081] (32) Decision: After obtaining the performance prediction (including expected value and uncertainty) of Gaussian process regression, a sampling function is used to determine the next parameter combination to be tried. Select the optimal parameter combination Specifically: (321) Balancing exploration and utilization: The core of the acquisition function is to achieve a balance between exploration (trying those parameter regions where the model is not yet certain but may have surprises) and utilization (directly selecting those parameters with the highest model prediction performance); (322) UCB Acquisition Function: The classic Upper Confidence Bound (UCB) is used as the acquisition function, and its formula is as follows:

[0082] in, It is the expected performance value of Gaussian process regression prediction, representing the utilization of... It is the standard deviation of the performance uncertainty in Gaussian process regression prediction, representing exploration. It is a hyperparameter used to control the degree of exploration. It is not a fixed value, but changes dynamically with the number of learning iterations n to achieve a smooth transition from exploration to utilization. The calculation method is as follows:

[0083] Where n represents the number of iterations executed in the online learning process, and as n increases, the exploration rate increases. It will change dynamically. Indicates the initial optimization (i.e.) The intensity of exploration (at any time). This represents the long-run exploration rate after optimization convergence. The purpose is to ensure that the algorithm retains a certain degree of exploratory capability after long-term operation and reaching stability (convergence), in order to adapt to the dynamic changes that may occur in the task arrival pattern over time. This is a time-scale parameter used to control the exploration rate from its initial value. The short-term rate of decay begins to decline. This is another time-scale parameter used to control the convergence of the exploration rate to its final value. The long-term rate; (323) Decision-making process: At each decision-making moment, in Find the combination that maximizes the UCB score from all possible combinations. This combination represents the parameters the system will use in the next execution cycle. This means that the decision-making process not only determines the optimal scheduling time window length. (Thus affecting the frequency and granularity of scheduling), and simultaneously determining the optimal target weight. (Used to weigh the importance of task completion rate and resource utilization rate in performance indicators).

[0084] (33) Execution and Update: Applying the optimal parameter combination Configure the local scheduler and execute a complete scheduling cycle. After the cycle ends, observe the actual performance during the cycle. This refers to the actual average task violation rate and resource utilization rate, using real data points. Added to the historical database, the Gaussian process regression learning model is then updated using this complete historical database containing real data points. These updates adjust the model's performance function. Its cognition is more accurate, and its next prediction ( and This will also make it more reliable.

[0085] Figure 7 The core online learning closed-loop process of the local adaptive scheduling phase is demonstrated. Through this continuous "modeling -> decision -> execution -> update" closed loop, the local scheduling strategy can adapt to the constantly changing task arrival patterns and system states, and always dynamically find and operate on the optimal parameter combination.

[0086] In summary, this embodiment proposes an edge-cloud collaborative adaptive workflow scheduling method based on graph neural networks and deep reinforcement learning. By constructing a three-level progressive system of "macro-candidate screening - collaborative scheduling decision - local adaptive optimization", a closed-loop scheduling mechanism from global resource awareness to local policy execution is realized. This method integrates task clustering simplified modeling, global state awareness through GNN feature encoding, DRL-driven multi-objective intelligent decision-making, and Bayesian optimization for online adaptive adjustment, effectively improving task completion rate and resource utilization, and significantly enhancing the system's adaptability and stability in complex dynamic network environments.

[0087] Example 2: This embodiment provides an edge-cloud collaborative adaptive workflow scheduling system, including: The filtering module is used to gather the raw workflow tasks generated by the device layer to the central scheduler. The central scheduler aggregates and processes the tasks internally to form workflow task blocks, and performs macro-level candidate node filtering on the task blocks to obtain a set of candidate nodes. The micro-cooperative scheduling module utilizes graph neural networks to give deep reinforcement learning agents a global network perspective, thereby achieving edge-to-edge cooperative scheduling within the candidate node set. The local dynamic optimization module takes over the task when a workflow task block is assigned to a target edge node for execution. The resource manager of the edge node takes over the task and adopts a resource allocation mechanism based on priority segmentation and sliding window as the basic framework for local execution. On this basic framework, a joint optimization strategy with dynamic target weighting is introduced.

Claims

1. A method for edge-cloud collaborative adaptive workflow scheduling, characterized in that, To apply this to a collaborative architecture that includes device, edge, and cloud layers, the steps are as follows: (1) Macro candidate screening: After the device layer generates the original workflow tasks, they are first gathered to the central scheduler. The central scheduler aggregates and processes the tasks internally to form workflow task blocks. Macro candidate node screening is performed on the task blocks to obtain a set of candidate nodes. (2) Micro-cooperative scheduling: Graph neural networks are used to give deep reinforcement learning agents a global network view, thereby achieving edge-to-edge cooperative scheduling within the candidate node set. (3) Local dynamic optimization: When a workflow task block is assigned to the target edge node for execution, the resource manager of the edge node takes over the task and adopts a resource allocation mechanism based on priority segmentation and sliding window as the basic framework for local execution. On the basic framework, a joint optimization strategy with dynamic target weighting is introduced.

2. The edge-cloud collaborative adaptive workflow scheduling method as described in claim 1, characterized in that, In step (1), specifically: (11) Workflow task clustering: Through the preprocessing process, original tasks with similar computational features, data dependencies or generation locations are aggregated into workflow task blocks to reduce scheduling granularity; (12) Candidate node selection based on probabilistic optimization: After the task block is formed, a fast candidate node selection process is performed for the task block. A probabilistic intelligent selection strategy is adopted to achieve a balance between optimal resource utilization and suboptimal node exploration.

3. The edge-cloud collaborative adaptive workflow scheduling method as described in claim 2, characterized in that, In step (11), computational pattern similarity is introduced as a key criterion. To resolve the fuzzy concept of similarity, computational pattern similarity is quantitatively defined. First, the computational pattern of each task is represented as a high-dimensional feature vector C. pattern This vector is used to encode the proportion of different computing power units required by the task, as well as its dependence on specific software libraries or operating environments; Subsequently, the similarity of patterns is calculated using cosine similarity metric. This function is used to calculate the similarity score between two feature vectors, and its formula is as follows: in, represent The L2 norm, also known as the Euclidean length or modulus; Therefore, the calculation pattern similarity as a key criterion specifically means: a new task i When attempting to join an existing task block, compute the new task. i eigenvectors The cosine similarity between the computational pattern centroid and the existing computational pattern centroid of the task block. The computational pattern centroid is the mean of all feature vectors within the task block. This similarity score is denoted as Sim(i, block). When Sim(i, block) is higher than a preset similarity threshold r, sim At that time, new tasks Only then are aggregations allowed; After clustering, the central scheduler calculates representative features at two levels for each task block: one is the geographic centroid p, where p is the source location coordinates of a task block containing m original tasks. m y m The coordinates (x, y) of the geographic centroid p are obtained by averaging all coordinates. p y p ): Second, the centroid of the computational pattern. The final feature vector obtained by averaging the core computational attributes of each task within the task block is the centroid of the computational pattern. The core computational attributes are a vector, specifically including: the total computational load of the task, the deadline of the task, the resource preference ratio of computing power, and the dependence on specific software libraries or operating environments.

4. The edge-cloud collaborative adaptive workflow scheduling method as described in claim 3, characterized in that, In step (12), the specific process is as follows: (121) Calculate the weighted distance of each node: For the task block i to be scheduled Bk and every available edge node EN j Calculating a weighted distance that takes into account both physical distance and node resources involves two steps: a: Edge node weight assignment, for the j-th edge node EN j Assign weights Weight R is the current remaining computing resources of this edge node. j A function of (t), i.e. The larger the weight value, the more available resources the edge node has and the stronger its service capabilities. b: Weighted distance calculation, defining task block i Bk The geographic centroid p and each edge node EN j Center position q j The weighted distance is D w (p,q) j ); Where d(p,q) j ) represents task block i Bk With the center position q of the edge node j The Euclidean distance between them; (122) Convert the weighted distance into a competitiveness score: calculate the EN of each edge node. j Relative to task block i Bk After weighting the distance, this cost-based indicator is transformed into a revenue-based indicator, denoted as the competitiveness score. The competitiveness score is calculated using the reciprocal of the weighted distance, i.e. ,in, Represents edge node EN j For the currently scheduled task block i Bk To avoid numerical instability or division-by-zero errors when the weighted distance approaches zero, a positive constant is introduced into the denominator for the competitiveness score. As a smoothing term, the optimized formula is obtained: The competitiveness score intuitively and quantitatively reflects the attractiveness of each edge node to the current task block; (123) Constructing a probability distribution and sampling candidate nodes: Based on the competitiveness scores of edge nodes, a probability distribution is constructed, and a set of candidate nodes is selected through weighted random sampling. Specifically: A: The probability distribution is constructed by using the competitiveness scores of all N edge nodes to create a discrete probability distribution. This is achieved by applying the EN values ​​of the edge nodes. j The probability P of being selected is obtained by normalizing the competitiveness score. j The calculation formula is: ,in, It is the sum of the competitiveness scores calculated by all N edge nodes for the same task block. Through normalization, it is ensured that the sum of the probabilities of all edge nodes being selected is 1, thus forming an effective probability distribution. B: After obtaining the probability distribution of all edge nodes through the weighted random sampling process, K weighted random samplings without replacement are performed to select the final set of candidate nodes. (124) Anomaly Handling and Backup Mechanism: To ensure the stable operation of the entire scheduling process under any extreme conditions, a deterministic backup plan is designed. When an anomaly is detected during the execution of weighted random sampling, the anomaly handling and backup mechanism is automatically triggered, immediately terminating the probabilistic sampling process and switching to the backup plan: First, obtain the original weighted distances of all edge nodes that have been calculated. Subsequently, these weighted distances are sorted in ascending order. If the weighted distances are equal, their relative order is determined according to a preset deterministic rule. Finally, the top K nodes in this sorted list are deterministically selected as the final candidate node set.

5. The edge-cloud collaborative adaptive workflow scheduling method as described in claim 4, characterized in that, In step (2), specifically: (21) System state awareness: In order to realize context-aware decision-making, the current state of candidate nodes and their interrelationships are represented in a structured way, and the state is dynamically constructed into a graph structure; (22) GNN feature extraction: In order to enable deep reinforcement learning agents to understand the complex relationships of graph structure data and perform effective relational reasoning, graph neural networks are introduced as state encoders. Their core function is to generate an intelligent profile for each node in the graph, that is, a low-dimensional vector representation containing its own state and surrounding network environment information. The information propagation of graph neural networks is carried out along the actual connections in the graph, naturally learning and reflecting the real connectivity and isolation relationships between nodes. (23) DRL Cooperative Scheduling Decision: After obtaining the system state encoded by the graph neural network and containing contextual information, the cooperative scheduling decision is implemented using the deep reinforcement learning Actor-Critic framework.

6. The edge-cloud collaborative adaptive workflow scheduling method as described in claim 5, characterized in that, In step (21), specifically: (211) Definition and structure of graphs: At each decision moment, for the task block to be scheduled, a dynamic and focused subgraph G is constructed. t = (V, E, X) t The specific composition is as follows: Node set (V): The nodes in the graph not only include the K candidate edge nodes selected in step (1), but also always include cloud nodes as a special, resource-rich backup node. Therefore, the total number of nodes is K+1. Edge set (E): The edges in the graph represent logical communication links between nodes. The central scheduler dynamically constructs the edge set based on the real-time network detection data provided by the monitoring agents of each edge node. Feature set (X) t ): The dynamic information carrier of the graph, containing the real-time state features of nodes and edges at each decision time t, composed of node feature vectors and edge feature vectors, used to comprehensively describe the state of the graph to the GNN model. Node Feature Vector: Each node is associated with a feature vector to describe its current resource status. This vector includes five core metrics: computing resource load, remaining computing capacity, memory utilization, task queue length, and node type identifier. Edge feature vector: Each edge is associated with a feature vector to describe its current network status, including two core metrics: available bandwidth and network latency; (212) Construct a state graph. The monitoring agents deployed on each edge node periodically report the node's own state and the link state to other candidate nodes to the central scheduler. When the central scheduler receives a new task block and completes the macro-candidate screening, it aggregates the latest real-time information and constructs the state graph G for the task block at the current decision moment. t ; In step (22), the graph neural network implementation process simulates a multi-round information exchange and integration process. In each layer, each node will: send its current profile information to all directly connected neighbor nodes; then, collect the information sent by all neighbor nodes; and finally, combine its own information to update and form a new profile. After propagation through H layers, the final vector representation of each node not only retains its original state features but also integrates its H layers. By incorporating topological features and resource load information within the hop neighborhood, the originally independent node states are transformed into deep feature representations with context awareness. The multi-layer propagation process of a graph neural network is formally represented by the following update formula: Where, N j It is the edge node EN j The neighborhood group, Representing neighbor node EN i In the current image at layer h, W h It is a trainable weight matrix, shared among all nodes in the h-th layer, with dimensions [input feature dimension, output feature dimension] . It is a normalization constant, c ji It is a symmetric normalization factor related to node degree, and its specific calculation formula is as follows: Where Degree(j) and Degree(i) represent neighbor node EN respectively. i and edge node EN j The degree, It is a non-linear activation function. Represents edge node EN j This forms a new image on the next layer.

7. The edge-cloud collaborative adaptive workflow scheduling method as described in claim 6, characterized in that, In step (23), specifically: (231) Actor-Critic framework: The Actor-Critic dual network structure works together. The Actor network is responsible for generating the scheduling strategy, receiving the state representation output by the graph neural network, and determining the specific scheduling action accordingly, that is, allocating the workflow task blocks to the appropriate nodes; the Critic network is responsible for value evaluation, estimating the long-term value of the current state or taking a specific action in the current state based on the state representation, and providing guidance signals for the strategy update of the Actor network. (232) State space: The state input of a deep reinforcement learning agent is the final feature vector set of all candidate nodes generated by the graph neural network, which incorporates contextual information; (233) Action space: The action space is designed to cover the probability distribution of all candidate nodes. Specifically, the Actor network outputs a vector of dimension K+1, where each element corresponds to a candidate node. The value of each element represents the probability of scheduling the current task block to that node. The node with the highest probability is selected as the execution target. (234) Reward Function: A multi-objective reward function with dynamically adjusted weights is designed, which will adjust the immediate reward r t Defined as the negative of the total cost, this allows the agent to equivalently minimize the total cost while maximizing the reward: Among them, w1, w2, and w3 are weighting coefficients; For migration costs, Total response delay = CL t +FL t CL t To calculate the delay, Due to forwarding delay; Penalties are applied to cloud services. This is a task completion rate penalty term used to ensure tasks are completed on time. It is an event-driven, binary penalty term. , where C miss It is a penalty constant used to severely punish the behavior of missing deadlines; This is a resource utilization penalty term used to encourage the system to achieve global load balancing. After executing the scheduling decision, the new load states of all K+1 candidate nodes are predicted, and their variances are calculated. in, This is a penalty for resource utilization. It is the standard function for calculating variance. It is a set; The larger the variance, the greater the load difference between nodes, the more unbalanced the system, and the higher the penalty value. (235) Policy learning: Deep reinforcement learning agents construct an adaptive policy optimization mechanism based on temporal difference error through continuous interaction with the environment. This mechanism is driven by the action kernel and the evaluation kernel. The two form a closed-loop update structure of prediction-feedback-correction between decision-making and evaluation, realizing the dynamic iteration and global convergence of the policy. ① The learning cycle mechanism strictly follows a chronological order and includes the following steps: State evaluation and action selection: The action kernel and the evaluation kernel simultaneously receive the current system state s encoded by the GNN. t The action core outputs the action probability distribution and selects the optimal action. The evaluation kernel provides a value assessment of the current state and outputs a priori prediction of its long-term value, V(s). t ); Environmental interaction and feedback acquisition: The system executes the selected action. The environment generates immediate feedback signals, including the immediate reward r for this action. t and the next state to enter s t+1 ; Next state value assessment: The assessment kernel receives the new state s t+1 It then performs a value assessment and outputs its long-term return forecast V(s). t+1 (i) refers to an ex-post assessment of potential future benefits; Timing differential error calculation: Timing differential error The gap between actual returns and prior predictions is quantified using the following formula: in, This is a discount factor used to weigh the importance of future returns. This indicates that the actual effect of the action was better than expected. This indicates that the result was lower than expected; Parameter updates and strategy changes: utilizing As a learning signal, the action kernel and evaluation kernel parameters are updated synchronously through backpropagation, thereby achieving synergistic optimization of strategy and value estimation; ② To achieve synergistic optimization of the action kernel and the evaluation kernel, the following joint loss function is designed: Among them, A pro Indicates the action check of the selected action. log probability ; The evaluation kernel part minimizes the squared prediction error term. This continuously approximates the true value function V(s), thereby improving the accuracy of long-term return estimation. The action core section utilizes timing differential error signals. Perform a strategy update: when At that time, the gradient descent process will cause the action kernel to increase the probability of selecting the current action. ;when If so, then reduce its selection probability; ③ Policy Convergence and Performance Evolution: During long-term cyclic training, the action kernel and the evaluation kernel converge through... The signals form a continuous game and cooperative relationship. The evaluation kernel continuously corrects the estimation error of the state value, while the action kernel relies on the feedback from the evaluation kernel to continuously adjust the policy distribution. When the two reach a balance, the policy gradually converges to the optimal solution.

8. The edge-cloud collaborative adaptive workflow scheduling method as described in claim 7, characterized in that, In step (3), the joint optimization strategy uses an online learning model to optimize the window length. The local scheduling strategy continuously adjusts two key parameters—the target weight w—in conjunction with the target weight w. This allows the strategy to adapt not only to the arrival rate of tasks but also to the type of task, thus maintaining high efficiency and stable performance under varying task conditions. The detailed steps of the joint optimization process are as follows: Joint optimization of adaptive window and target weights: performance is highly dependent on two key parameters, window length. The frequency and granularity of scheduling are determined, and the target weights are optimized. This determines whether the optimization focus is on task timeliness or resource economy. These two parameters are no longer fixed values, but are jointly and continuously adjusted by an online learning algorithm based on Bayesian optimization. The entire optimization process is constructed into a closed loop of modeling -> decision-making -> execution -> update. (31) Modeling and expanding the performance prediction model, using Gaussian process regression as the performance prediction model; (32) Decision: After obtaining the performance prediction of Gaussian process regression, a sampling function is used to determine the next parameter combination. Select the optimal parameter combination ; (33) Execution and Update: Applying the optimal parameter combination Configure the local scheduler and execute a complete scheduling cycle. After the cycle ends, observe the actual performance during the cycle. This refers to the actual average task violation rate and resource utilization rate, using real data points. It is added to the historical database, and then the Gaussian process regression learning model uses this complete historical database containing real data points to update.

9. The edge-cloud collaborative adaptive workflow scheduling method as described in claim 8, characterized in that, In step (31), specifically: (311) Learning Objective: Gaussian process regression learns from a two-dimensional input A complex mapping relationship y=f(x) to a scalar output is modeled as a Gaussian process distribution: Where M(x) is the mean function; For the kernel function, to capture periodic and non-periodic features in the task pattern, within the window length... The following composite kernel is used in terms of dimension: In the formula, the first part is the periodic kernel. and 'Indicates the length of the sliding window with periodic similarity. The variance of the signal is the overall variation of the output value of the control function. The length scale controls the smoothness of the function; It is a periodic measure used to capture periodic patterns in task modes; The second part is the Gaussian kernel: For signal variance, Using length as a scale, it characterizes the smoothness of the non-periodic portion. The larger the size, the smoother the change; The smaller the size, the more drastic the change; (312) Definition of performance index y: In order to achieve a balance of multiple objectives, the performance index y is defined as a weighted function that integrates task completion and resource utilization. The weighted function is the unknown mapping function that Gaussian process regression attempts to learn and approximate in step (311). In practice, the better the scheduling, the higher the y-value. in, , The target weights are selected by the intelligent decision-making module; The average task violation rate is represented in the window. The percentage of tasks that were not completed on time is calculated as follows: in, This represents the total number of tasks within the time window, and v(i) is the violation indicator function. v(i) = 1 when a task is not completed on time, and 0 otherwise. This represents the sum of v(i) of all tasks within the window, i.e., the total number of tasks that have violated the rules within the window; This represents the on-time completion rate of tasks; This represents the average resource utilization rate; it is indicated in the window. The computing resource usage of all edge nodes is calculated as follows: in, This represents the total number of edge nodes participating in the computation. For edge node EN j In the time window The actual amount of computing resources used, i.e., the resources already used. For edge nodes in the time window The total amount of computing resources that can be provided, i.e., available resources. The EN of a single edge node was calculated. j The resource utilization rate provided within the window will affect all... Add up the utilization rates of each edge node, and then divide by . This yields the average resource utilization rate of all edge nodes. In step (32), specifically: (321) Balancing exploration and utilization: The core of the acquisition function is to achieve a balance between exploration and utilization; (322) UCB Acquisition Function: The upper confidence bound is used as the acquisition function, and its formula is: in, It is the expected performance value of Gaussian process regression prediction, representing the utilization of... It is the standard deviation of the performance uncertainty in Gaussian process regression prediction, representing exploration. It is a hyperparameter used to control the degree of exploration. It is not a fixed value, but changes dynamically with the number of learning iterations n to achieve a smooth transition from exploration to utilization. The calculation method is as follows: Where n represents the number of iterations executed in the online learning process, and as n increases, the exploration rate increases. It will change dynamically. This indicates the initial exploration intensity for optimization. This represents the long-term exploration rate after optimization and convergence. This is a time-scale parameter used to control the exploration rate from its initial value. The short-term rate of decay begins to decline. This is another time-scale parameter used to control the convergence of the exploration rate to its final value. The long-term rate; (323) Decision-making process: At each decision-making moment, in Find the combination that maximizes the UCB score among all combinations. .

10. An edge-cloud collaborative adaptive workflow scheduling system, characterized in that, include: The filtering module is used to gather the raw workflow tasks generated by the device layer to the central scheduler. The central scheduler aggregates and processes the tasks internally to form workflow task blocks, and performs macro-level candidate node filtering on the task blocks to obtain a set of candidate nodes. The micro-cooperative scheduling module utilizes graph neural networks to give deep reinforcement learning agents a global network perspective, thereby achieving edge-to-edge cooperative scheduling within the candidate node set. The local dynamic optimization module takes over the task when a workflow task block is assigned to a target edge node for execution. The resource manager of the edge node takes over the task and adopts a resource allocation mechanism based on priority segmentation and sliding window as the basic framework for local execution. On this basic framework, a joint optimization strategy with dynamic target weighting is introduced.

Images