Complex manufacturing system cloud edge computing resource collaborative scheduling method based on adaptive task division and decision joint optimization

Abstract

The invention discloses an adaptive task division and decision joint optimization-based cloud edge computing resource collaborative scheduling method for a complex manufacturing system. The method comprises the following steps of 1, constructing a hierarchical cloud-edge collaborative computing network model; constructing a multi-objective optimization model, and defining an objective function and constraint conditions; 2, dynamically predicting and calculating a resource state through a resource sensing module based on an LSTM neural network, and generating a node resource prediction matrix; 3, dividing a calculation task generated by the manufacturing system into fine-granularity, medium-granularity and coarse-granularity subtask sets by adopting a multi-granularity subtask division algorithm (MSPA), and mapping the subtasks to corresponding calculation nodes; 4, constructing a task unloading decision model based on the D3QN, and dynamically selecting unloading nodes and an execution sequence of the subtasks in combination with a multi-objective optimization reward function; and 5, iteratively optimizing parameters of the D3QN model through a target network updating mechanism and a self-adaptive exploration strategy to realize real-time dynamic adjustment of a task scheduling decision.

Description

Technical Field

[0001] The present invention belongs to the technical field of resource scheduling, and specifically provides a method for collaborative scheduling of cloud-edge computing resources in a complex manufacturing system based on adaptive task division and decision joint optimization. Background Art

[0002] In modern complex manufacturing scenarios, industrial manufacturing systems generate a large number of computing task requirements for manufacturing production processes. Traditionally, the computing of tasks in complex manufacturing systems mainly relies on centralized control systems and local servers. These systems usually adopt preset, static scheduling strategies, such as first-come, first-served (FCFS) or priority scheduling. However, as the scale of tasks increases, the limited computing power of local control systems and servers is difficult to bear the computing requirements of large data volume tasks. Therefore, some computing-intensive tasks that occupy a large amount of computing resources are offloaded to remote centralized cloud servers such as Alibaba Cloud ECS and Tencent Cloud CVM for execution. This method allows devices with weaker computing power to complete tasks with high computing requirements. However, with the advancement of Industry 4.0, the intelligent transformation of factories has accelerated, and the types and number of smart devices in smart factories have shown exponential growth. As a result, the computing tasks generated in complex manufacturing systems are highly random, dynamic, large-scale and parallel, and demand real-time. The traditional cloud computing paradigm faces serious delay bottleneck problems, and the large-scale transmission of tasks will bring serious bandwidth pressure to the backbone communication network, making it difficult to meet the computing task requirements of highly heterogeneous computing tasks.

[0003] In order to solve the limitations of the traditional cloud computing paradigm, the edge computing paradigm has been proposed as an effective way to offload computing. Edge computing deploys computing nodes close to smart devices to sink computing power to the edge of the network, effectively avoiding round-trip delays in the cloud, speeding up task computing response time, and alleviating the load on the backbone communication network.

[0004] Although traditional cloud computing and edge computing paradigms provide convenient and effective computing solutions for many other fields, non-collaborative cloud or edge architectures still have limitations such as poor flexibility and scalability when facing industrial application scenarios such as complex manufacturing systems. Therefore, cloud-edge collaboration, as an emerging multi-layer collaborative architecture, aims to address some of the shortcomings of single-layer architectures and provide a more efficient and flexible computing solution for various computing applications. In the cloud-edge collaborative architecture, a large number of computing nodes will participate in the collaboration. Dividing computing-intensive tasks into subtasks of appropriate granularity and reasonably scheduling them to various computing nodes for execution can significantly optimize resource utilization, improve task processing efficiency, and reduce response delays.

[0005] Research on fine-grained task division:

[0006] In the edge computing environment, the method of task decomposition not only needs to consider the dependencies of tasks, but also must take into account factors such as the limitations of computing resources and network latency. However, most existing methods rely on predefined rules and static algorithms when dealing with task decomposition, lacking dynamic adaptation and flexibility, and unable to efficiently utilize node resources. In addition, current edge computing resource scheduling algorithms often fail to fully consider the complex dependencies between tasks and the dynamic changes of resources, resulting in low resource utilization efficiency and affecting the overall performance of the system.

[0007] Research on Computing Task Offloading Scheduling:

[0008] When the number of tasks and computing nodes is large, if no scheduling is performed, it will lead to starvation or overload of some computing nodes. Therefore, after tasks are divided into sub-tasks, an effective computing task offloading scheduling method is extremely important. According to the relevant research on computing task offloading by domestic and foreign scholars, the current methods for computing task offloading are mainly divided into traditional optimization algorithms and artificial intelligence algorithms.

[0009] For traditional optimization algorithms, the more widely used ones are Mixed Integer Programming (MIP) and Genetic Algorithm (GA). MIP is a mathematical optimization method used to solve linear programming problems containing integer variables. In edge computing, the resource allocation problem can often be modeled as an MIP problem. Although MIP can guarantee finding the global optimal solution, its solution complexity is relatively high. For large-scale problems, the solution time may grow exponentially, and the MIP model requires precise mathematical expressions, making it difficult to apply in environments with complex manufacturing systems where the constraint conditions are complex and modeling is difficult. GA is a heuristic search algorithm that simulates the biological evolution process and gradually optimizes the solution of the problem through operations such as selection, crossover, and mutation. However, since GA cannot guarantee finding the global optimal solution and is limited by its performance stability and convergence speed, it is difficult to meet the requirements of scenarios with high real-time requirements such as complex manufacturing systems.

[0010] The artificial intelligence algorithms applied in this field are mainly deep learning methods and deep reinforcement learning methods. Deep learning (DL) is a machine learning method that uses artificial neural networks with multiple layers to learn from large amounts of data. Each layer extracts features from the previous layer, thereby constructing a hierarchical representation of the data. Although DL models are very powerful, DL models usually require a large amount of labeled data for training, and it is difficult to obtain enough data for training in actual engineering problems. Moreover, in actual manufacturing systems, the environmental parameters are significantly dynamic, and it is difficult for DL models to ensure high enough operating performance and lack the ability of online adaptability. Therefore, in response to the above problems, deep reinforcement learning is introduced into computing offloading. Deep reinforcement learning (DRL) is a method that combines reinforcement learning (RL) with deep learning. In DRL, the agent learns the optimal policy to maximize the cumulative reward by interacting with the environment. However, the current research on task scheduling based on DRL only targets single-layer system architectures and mainly focuses on single-threaded task processing. When facing the parallel task scheduling of a large number of industrial computing nodes in a multi-layer architecture, DRL often has difficulty in effective training and convergence. In addition, most of the existing research focuses on single-objective optimization, while in actual engineering scenarios, it is often necessary to jointly optimize multiple conflicting objective functions.

[0011] In summary, the existing computational resource collaborative scheduling methods have the following limitations:

[0012] (1) The current fine-grained task decomposition research for cloud-edge collaboration does not divide sub-tasks with appropriate granularity according to computing resources, and it is difficult to make full use of the computing advantages under the multi-layer collaborative architecture.

[0013] (2) Traditional scheduling optimization algorithms have high computational complexity, are difficult to meet real-time requirements, and have weak model generalization ability.

[0014] (3) The scheduling methods based on deep learning rely on a large amount of labeled data. In actual engineering problems, it is difficult to obtain a large amount of real engineering data for training artificial intelligence models, and they lack the ability of online adaptability, and the model generalization and robustness are limited.

[0015] (4) Ordinary DRL methods have difficulty in effective convergence when facing the multi-node parallel distributed architecture under cloud-edge collaboration, and lack the adaptive exploration mechanism and concurrent task offloading scheduling method for the multi-layer architecture in complex manufacturing scenarios. Due to the above various reasons, the existing methods are difficult to be directly applied to complex manufacturing scenarios. Summary of the Invention

[0016] In view of this, the purpose of the present invention is to provide a cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making, and to propose a multi-granularity subtask partitioning algorithm (MSPA) based on LSTM neural network resource perception and a parallel scheduling algorithm based on competitive double deep Q network (D3QN), optimize for multi-objective functions, and achieve hierarchical task scheduling and dynamic adaptive computing resources.

[0017] To achieve the above object, the present invention provides the following technical solutions:

[0018] A cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making, comprising the following steps:

[0019] Step 1: Construct a hierarchical cloud-edge collaborative computing network model, which includes a three-layer architecture of intelligent production units, edge servers, and cloud industrial platforms; quantify task processing delay, energy consumption, and timeout penalty, construct a multi-objective optimization model, and define objective functions and constraints;

[0020] Step 2: Through a resource perception module based on the LSTM neural network, dynamically predict the computing resource status of edge servers and cloud industrial platforms, and generate a node resource prediction matrix;

[0021] Step 3: Based on the resource prediction matrix, use the multi-granularity subtask partitioning algorithm (MSPA) to divide the computing tasks generated by the manufacturing system into fine-grained, medium-grained, and coarse-grained subtask sets, and map the subtasks to the corresponding computing nodes according to the node resource status;

[0022] Step 4: Construct a task offloading decision model based on the competitive double deep Q network (D3QN), and combine with the multi-objective optimization reward function to dynamically select the offloading nodes and execution order of subtasks. The reward function includes the weighted sum of task delay factor, energy consumption factor, and timeout penalty term;

[0023] Step 5: Through the target network update mechanism and adaptive exploration strategy, iteratively optimize the parameters of the D3QN model to achieve real-time dynamic adjustment of task scheduling decisions.

[0024] Further, in the above step 1, the principle of the hierarchical cloud-edge collaborative computing network model is: within the time interval t, there is a set of N intelligent production units a set of K industrial computing nodes Each edge computing node manages the nearby intelligent production units; the task generated by the i-th intelligent production unit is described as Ω i ={D i , C i , Δ max}, D iRepresents the data size of the task, C i Represents the total number of cpu cycles required for the computing task, Δ max Represents the maximum tolerable delay of the task; each task is divided into subtasks of different sizes Unloaded to different computing nodes for parallel execution, Represents the computing time limit constraint of subtask k.

[0025] Furthermore, in the first step, the multi-objective optimization model is expressed as:

[0026]

[0027] Where: u i Is the utility function; w is the weight coefficient; α and β are the proportionality coefficients; Represents task Ω i The computing delay required for local processing; Task Ω i The total delay; Represents task Ω i The energy consumption of local computing; Represents task Ω i The total energy consumption; Δ max Represents the maximum tolerable delay of the task; and:

[0028] Task Ω i The total delay Is expressed as:

[0029]

[0030] Where: Represents task Ω i The computing delay required for local processing; Represents the delay required to directly unload task Ω i From the local production terminal to the affiliated edge computing node m; Represents task Ω i The delay required for execution after unloading; o is the unloading decision vector;

[0031] Task Ω i The total energy consumption Is expressed as:

[0032]

[0033] Where: Represents task Ω i The energy consumption of local computing; E t And E r Are the transmission energy consumption and reception energy consumption of communication between the intelligent production unit, edge computing node and industrial cloud platform respectively; Indicates task Ω i The computing energy consumption after unloading to each computing node;

[0034] Taking the minimum of task execution cost and task execution delay as the optimization goal, the objective function and constraint conditions are obtained:

[0035] max u i (t)

[0036] s.t. w ∈ [0, 1]

[0037] i ∈ [1, N]

[0038] α, β > 0

[0039] Where: N is the number of intelligent production units in the set u.

[0040] Furthermore, in the second step, the method for predicting the node resource prediction matrix based on the LSTM neural network is:

[0041] Construct a feature matrix with input features including historical queue delay sequence, industrial computing node load, task arrival rate, and channel state historical data T is the time window length, and d is the feature dimension;

[0042] Input the matrix X into the LSTM neural network, and the output of the LSTM neural network is expressed as:

[0043] h t = σ(x t , h t―1 , c t―1 )

[0044] Where: h t and c t respectively represent the hidden state and state of the LSTM cell at time step t; h t―1 and c t―1 respectively represent the hidden state and state of the LSTM cell at time step t - 1; σ is the sigmoid function; x t represents the slice of the matrix X at the same time step, containing the resource usage of all nodes;

[0045] Input the hidden state h t of the last time step of the LSTM neural network into the fully connected layer to obtain:

[0046] Y = W fc × h t + b fc

[0047] Where: Y is the predicted node resource prediction matrix of the industrial computing node; Wfc is the weight matrix of the fully connected layer; b fc is the bias vector of the fully connected layer.

[0048] Furthermore, in the third step, the process of dividing the computing task by using the multi-granularity sub-task division algorithm follows the principle of hierarchical dynamic programming, including:

[0049] Fine-grained division layer: Abstract the computing task into a directed acyclic graph, and construct a set of minimum computing units according to the data locality principle, satisfying the constraints:

[0050]

[0051] where: d f is the data transfer volume of the fine-grained computing unit; η is the network bandwidth utilization threshold to ensure that the data transfer time does not exceed the total delay budget; B (i) is the memory bandwidth; Δ max is the maximum tolerable delay of the task; is the network delay;

[0052] Medium-grained aggregation layer: Dynamically aggregate fine-grained units into medium-grained sub-tasks based on the node computing power, satisfying the constraints:

[0053]

[0054] where: c f is the computing volume of the fine-grained computing unit; γ is the computing resource elasticity factor used to balance the node load and delay constraints;; is the node computing power;

[0055] Coarse-grained fusion layer: Use the delay-sensitive critical path analysis method to fuse the coupled units with strong timing constraints into coarse-grained sub-tasks, satisfying the constraints:

[0056]

[0057] where: d s is the total data transfer volume of the sub-task group; s c is constructed by using the delay-sensitive critical path analysis method; c s is the total computing volume of the sub-task group; μ is the data-computation trade-off coefficient.

[0058] Furthermore, construct a multi-granularity discrimination function to divide the computing task. The multi-granularity discrimination function is:

[0059]

[0060] where: ω C , ω D and ω τThey are the weighted coefficients for calculating density, data scale, and latency sensitivity respectively; and:

[0061] When it is divided into fine-grained subtasks;

[0062] When it is divided into medium-grained subtasks;

[0063] When it is divided into coarse-grained subtasks;

[0064] θ f and θ c are threshold parameters dynamically adjusted through online Bayesian optimization.

[0065] Furthermore, in the third step, the method of mapping subtasks to corresponding computing nodes is as follows:

[0066] Adopt a multi-objective optimization heuristic mapping strategy, divide the nodes into three levels according to the resource situation, corresponding to the three granularities of tasks, and construct a two-dimensional optimization objective function:

[0067]

[0068] Where: is the subtask mapping decision matrix; α and β are dynamic weight coefficients; is the expected queue delay of node i at time slot t based on LSTM prediction; Q i (t) is the real-time task queue of node i at time slot t; N is the total number of available nodes; is for node i k the reciprocal of the main frequency computing efficiency; i k is the target node index assigned to subtask k; K is the total number of subtasks;

[0069] The node allocation constraint is:

[0070]

[0071] Where: represents the mapping relationship of subtask k to node i;

[0072] Adopt the Pareto front search strategy to obtain the optimal mapping relationship between subtasks and computing nodes.

[0073] Furthermore, in the fourth step, the task offloading decision model is:

[0074] Transform the computing task scheduling problem into a Markov decision model, and define the Markov decision as:

[0075] MDP=(S,A,P,R,γ)

[0076] Where: S is the current state space; A is the action space; P is the transition probability, that is, for each state s and action a, the probability of transferring to a new state s′ after executing this action, denoted as P(s′∣s,a); R is the reward function; γ is the discount factor;

[0077] The action space A is:

[0078]

[0079] o i =[o1(t), o2(t), …, o n (t)], o n (t) ∈ {0, 1}

[0080] s i =[s1(t), s2(t), …, s n (t)], 0 ≤ s n (t) ≤ Ω i

[0081] Where: o i is the offloading decision vector; s i is the task allocation vector for node i; N level is the set of nodes with different resource levels; Ω i is the main computing task;

[0082] The state space S is constructed using the resource information perceived by the multi-granularity subtask partitioning algorithm, denoted as:

[0083]

[0084] Where: represents the computing resource information of node i at time t; represents the set of tasks waiting at time t; represents the task queue information of node i at time t; represents the occupancy information of the communication bandwidth at time t;

[0085] The reward function R is:

[0086]

[0087] Where: R i represents the reward function of the agent; w is the weight parameter used to adjust the inclination ratio of delay and energy consumption; α and β are scaling factors.

[0088] Furthermore, the competitive double deep Q-network adopts a Dueling network structure, including a state value branch and an advantage function branch, and generates Q values through an aggregation formula:

[0089]

[0090] The ε-greedy strategy is used to select actions. There is a probability of ε for random exploration, otherwise select

[0091] The Q-value update function is:

[0092]

[0093] where: Q eval is the estimated value of the action selected by the evaluation network; Q target is the estimated value of the target network; γ is the discount factor.

[0094] Furthermore, in step 5, the parameter update method of the D3QN model is as follows: The target network adopts a hard update mechanism based on the time difference loss function, and the evaluation network is optimized by minimizing the time difference loss between the predicted Q-value and the target Q-value. The loss function is defined in the form of mean square error:

[0095]

[0096] where: θ is the parameter of the evaluation network; θ ― is the parameter of the target network; is the experience replay buffer;

[0097] The real-time dynamic adjustment method for task scheduling decision is: After each task execution, update the node queues and communication broadband delays and generate the next state s t+1 , simulating the actual task processing process:

[0098]

[0099] where: represents the node queue at time t; represents the channel queue at time t; Δt is the time slot experienced in a single iteration step.

[0100] The beneficial effects of the present invention are as follows:

[0101] The cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making of the present invention has the following technical effects:

[0102] (1) Compared with the traditional single cloud computing or edge computing paradigm, the present invention considers the heterogeneity of various computing devices in complex manufacturing systems, designs a hierarchical cloud-edge collaborative computing resource scheduling architecture, and fully adapts to the computing needs of large-scale parallel devices in modern complex manufacturing systems.

[0103] (2) Compared with the existing cloud-edge collaborative task decomposition methods that rely on predefined rules and static algorithms, the MSPA proposed in the present invention realizes the adaptive adjustment of task granularity by dynamically predicting the node resource status and combining the principle of hierarchical dynamic programming, solves the problem in the prior art that the task division granularity is fixed and cannot flexibly adapt to the dynamic resource environment, and significantly improves the utilization efficiency of computing resources and the task parallel processing ability under the multi-layer architecture.

[0104] (3) Compared with the obvious limitations of traditional scheduling methods in terms of computational complexity, data requirements, real-time performance, generalization ability, etc. in complex manufacturing systems, the present invention introduces the deep reinforcement learning method, trains the neural network by continuously interacting with the environment, while ensuring the quality of scheduling decisions, greatly reduces the computational complexity, effectively meets the stringent requirements of complex manufacturing scenarios for real-time performance, solves the problem of low efficiency of traditional algorithms in large-scale parallel task scheduling, and can quickly adapt to network fluctuations and dynamic changes of node resources without prior data support.

[0105] (4) Compared with the problem that ordinary deep reinforcement learning (DRL) methods are difficult to converge under the multi-layer architecture, the present invention introduces a memory competition mechanism and a target network update strategy, constructs a D3QN network structure, combines an adaptive exploration strategy and a multi-objective collaborative optimization mechanism, solves the problems of unstable training and low convergence efficiency of ordinary DRL in cloud-edge collaborative multi-node parallel scheduling, and significantly improves the robustness and decision-making accuracy of the algorithm in complex heterogeneous environments. BRIEF DESCRIPTION OF THE DRAWINGS

[0106] In order to make the objectives, technical solutions and beneficial effects of the present invention clearer, the following drawings are provided for description of the present invention:

[0107] Figure 1 It is a flowchart of the cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on adaptive task division and decision-making joint optimization of the present invention;

[0108] Figure 2 It is a schematic diagram of the cloud-edge collaborative architecture;

[0109] Figure 3 It is a schematic diagram of the LSTM network structure;

[0110] Figure 4 It is a schematic diagram of the D3QN neural network structure;

[0111] Figure 5 It is the interface of the computing resource scheduling management system;

[0112] Figure 6 It is the comparison of the average reward training curves of each algorithm. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0113] The present invention will be further described below in conjunction with the accompanying drawings and specific embodiments, so that those skilled in the art can better understand the present invention and be able to implement it. However, the illustrated embodiments are not intended to limit the present invention.

[0114] As Figure 1 shown, the cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on adaptive task partitioning and joint optimization of decision-making in this embodiment includes the following steps:

[0115] Step 1: Construct a hierarchical cloud-edge collaborative computing network model, which includes a three-layer architecture of intelligent production units, edge servers, and cloud industrial platforms; quantify task processing latency, energy consumption, and timeout penalties, construct a multi-objective optimization model, and define the objective function and constraints.

[0116] (1) Hierarchical cloud-edge collaborative computing network model

[0117] As Figure 2 shown, this embodiment designs a three-layer system model composed of intelligent production units, edge servers, and cloud industrial platforms. Each edge server manages nearby intelligent production units. At the bottom layer of the architecture, at the beginning of each time slot, each intelligent production unit will generate computing tasks with a certain probability. Through offloading strategy adjustment, each task can be offloaded to the affiliated server through a wireless link to meet the latency requirements. Each computing node will maintain a task queue. When the load of the edge server reaches a certain threshold, part of the tasks can be offloaded to edge servers and cloud industrial platforms with more idle computing resources through wired communication for execution.

[0118] The intelligent production unit communicates with the edge server through wireless transmission. This embodiment sets up a macro base station to support edge-end communication. During the wireless transmission process, the power of the transmission signal will attenuate as the transmission distance increases and is affected by noise. According to Shannon's theorem, the maximum transmission rate can be described as:

[0119]

[0120] Where: R n represents the maximum transmission rate of the wireless link between device n and the edge server, with the unit of bps; W n represents the industrial communication bandwidth, with the unit of Hz; g′ represents the gain of the link, which refers to the gain of the transmitted signal energy after passing through the link; λ represents the transmission distance (m); λ′ represents the reference distance used to calculate the link loss. In this embodiment, the reference distance is set to 1 meter; p nIt represents the transmission power, which is the output power (W) of the transmitting device; N0 represents the noise power spectral density (W / Hz); μ represents the path loss exponent, which is used to describe the attenuation degree of the signal during transmission. In this embodiment, the path loss exponent is set to 2, indicating that the signal attenuation increases with the square of the transmission distance.

[0121] Specifically, in this embodiment, the principle of the hierarchical cloud-edge collaborative computing network model is as follows: within the time interval t, there is a set of N intelligent production units A set of K industrial computing nodes (including the industrial cloud platform), and each edge computing node manages the nearby intelligent production units. The task generated by the i-th intelligent production unit is described as Ω i ={D i , C i , Δ max}}, where D i represents the data size of the task (unit: bit), C i represents the total number of cpu cycles required for the computing task (unit: Cycles), and Δ max represents the maximum tolerable delay (expiration time) of the task. Each task is divided into subtasks of different sizes and offloaded to different computing nodes for parallel execution. represents the computing time limit constraint of subtask k, which is related to the task's maximum tolerable delay and data transmission delay.

[0122] (2) Multi-objective optimization model

[0123] This embodiment aims to jointly optimize delay and energy consumption. Since the units of these two metrics are different, this embodiment represents the utility function as the weighted sum of the delay factor, energy consumption factor, and timeout penalty term. The delay factor is defined as the ratio of the local execution delay of the task to the task execution delay, and the energy consumption factor is defined as the ratio of the local execution energy consumption of the task to the task execution energy consumption. The weight w controls the utility function to adjust the optimization tendency, and then the two metrics are scaled to the same magnitude through the proportionality coefficient α.

[0124] The multi-objective optimization model is expressed as:

[0125]

[0126] where: u i is the utility function; w is the weight coefficient; α and β are proportionality coefficients; represents the computing delay required for local processing of task Ω i ; the total delay of task Ω i ; represents the energy consumption of task Ω i during local computing; Denote the total energy consumption of task Ω i ; Δ max Denote the maximum tolerable delay of the task.

[0127] Taking the minimum of the task execution cost and the task execution delay as the optimization objective, the objective function and the constraint conditions are obtained:

[0128] max u i (t)

[0129] s.t. w ∈ [0, 1]

[0130] i ∈ [1, N]

[0131] α, β > 0

[0132] where: N is the number of intelligent production units in the set of intelligent production units.

[0133] The constraint w ∈ [0, 1] states that the sum of the weights of the delay optimization and the energy optimization should be equal to 1. The constraint i ∈ [1, N] means that the task generation node should be included in the device set. The constraint α, β > 0 means that the proportionality coefficients α and β should be positive values, allowing reasonable scaling to avoid the influence of excessive weights on the delay. When the utility value u i (t) is maximized, it represents the minimum delay and the corresponding minimum energy consumption value that can be achieved given a set of weights w.

[0134] (3) Total delay

[0135] Specifically, if the task Ω i is not decomposed, the computational delay required for local processing of the task Ω i is equivalent to:

[0136]

[0137] where: C i is the number of computational cycles required for task Ω i , f0 is the computational power of the local production terminal, is the queue delay of the current intelligent production unit.

[0138] The delay calculation formula for the task Ω i after offloading is:

[0139]

[0140] where: f m is the computational power of the computing node m; is the queue delay of the computing node m.

[0141] If the task is decomposed and the decomposed subtasks are scheduled in parallel, the computing latency is equal to:

[0142]

[0143] where: f k is the computing power of computing node k; is the queue latency of computing node k.

[0144] The transmission latency required to directly offload task Ω i from the local production terminal to the affiliated edge computing node m is expressed as:

[0145]

[0146] In the formula, D i represents the data volume of task Ω i , and R n represents the maximum transmission rate of device u n to the wireless communication link.

[0147] If task Ω i is offloaded from the local production terminal to another edge computing node (or industrial cloud platform) n, it needs to be first offloaded to the affiliated edge computing node and then secondarily offloaded to the target computing node. The required transmission latency is expressed as:

[0148]

[0149] In the formula, R m2m(m2c) represents the maximum transmission rate between edge computing nodes (edge to cloud).

[0150] If the task is decomposed and offloaded in parallel, the transmission latency can be expressed as:

[0151]

[0152] In this embodiment, the total latency of task Ω i is expressed as: is expressed as:

[0153]

[0154] where: represents the computing latency required for local processing of task Ω i ; represents the latency required to directly offload task Ω i from the local production terminal to the affiliated edge computing node m; represents the latency required for execution after offloading of task Ω i ; o is the offloading decision vector.

[0155] (4) Total energy consumption

[0156] The energy consumption includes computing energy consumption and communication energy consumption. The formula for calculating the energy consumption of local computing is:

[0157]

[0158] Where: f n represents the computing resources allocated by computing node n to the task; η0 represents the chip energy consumption coefficient, which is related to the chip architecture of the computing device and the computer power management strategy.

[0159] The communication energy consumption refers to the energy consumed in transmitting data between intelligent production units, edge computing nodes, and industrial cloud platforms, and is generally composed of two parts: transmission energy consumption and reception energy consumption. The commonly used communication energy consumption model is based on transmission power and channel loss, and can be expressed as:

[0160]

[0161] In the formula, or respectively represent the power of the sender and the receiver, and t i is the transmission delay during the task offloading process.

[0162] The computing energy consumption after offloading the task to each computing node is:

[0163]

[0164] In this embodiment, for task Ω i the total energy consumption is expressed as:

[0165]

[0166] Where: represents the energy consumption of task Ω i in local computing; E t and E r are respectively the transmission energy consumption and reception energy consumption of communication between intelligent production units, edge computing nodes, and industrial cloud platforms; represents the computing energy consumption after task Ω i is offloaded to each computing node.

[0167] Step 2: Through the resource-aware module based on the LSTM neural network, dynamically predict the computing resource status of the edge server and the cloud industrial platform, and generate a node resource prediction matrix.

[0168] This step introduces a multi-granularity subtask partitioning algorithm for the real-time quality detection and optimization task Ω of the intelligent production line iFor example, it can be decomposed into a set of subtasks (i.e., data collection and preprocessing, defect detection, optimization decision-making, scheduling allocation, etc.) and represented as Ω i ={A i ,B i ,…}. Each subtask may contain multiple operations due to the task type. However, since multiple decompositions will result in additional overhead and an unnecessary increase in the complexity of the optimization problem, the present invention only decomposes the task once, and the latency generated by a single task decomposition is extremely small and can be ignored.

[0169] (1) Prediction of industrial computing power node resources based on LSTM

[0170] As Figure 3 shown, LSTM (Long Short-Term Memory network) is a special type of recurrent neural network (RNN). By introducing gating mechanisms such as input gates, forget gates, and output gates, it effectively solves the problems that traditional RNNs have difficulty capturing long-term dependencies and vanishing / exploding gradients, and can model complex patterns in time series data. Its core lies in dynamically controlling the storage and forgetting of information, enabling the network to selectively retain historical key information and update the current state, making it suitable for the dynamic prediction of large-scale node resources (computing load, queue latency, channel state, etc.) in the cloud-edge-end collaboration scenario, providing a forward-looking decision-making basis for task scheduling.

[0171] The gating mechanisms of the LSTM unit are defined as follows:

[0172] 1) Forget gate:

[0173] f t =σ(W f ·[h t―1 ,x t +b f )

[0174] 2) Input gate:

[0175] i t =σ(W i ·[h t―1 ,x t +b i )

[0176] 3) Candidate cell state:

[0177]

[0178] 4) Cell state update:

[0179]

[0180] 5) Output gate:

[0181] ot = σ(W o · [h t―1 , x t + b o )

[0182] 6) Hidden state output:

[0183] h t = o t ⊙ tanh(C t )

[0184] where σ is the sigmoid function, ⊙ is element-wise multiplication, W is the weight parameter, b is the bias vector, h t―1 is the hidden state at the previous time step, x t is the current input feature vector, and C t―1 is the cell state at the previous time step.

[0185] Specifically, in this embodiment, the method for predicting the node resource prediction matrix based on the LSTM neural network is as follows:

[0186] Construct a feature matrix with input features including the historical queue delay sequence, industrial computing power node load, task arrival rate, and channel state historical data T is the time window length, and d is the feature dimension.

[0187] Input the matrix X into the LSTM neural network, train the LSTM neural network, and predict the resource utilization rate of the industrial computing power node. The output of the LSTM neural network is expressed as:

[0188] h t = σ(x t , h t―1 , c t―1 )

[0189] where: h t and c t respectively represent the hidden state and state of the LSTM cell at time step t; h t―1 and c t―1 respectively represent the hidden state and state of the LSTM cell at time step t - 1; σ is the sigmoid function; x t represents the slice of the matrix X at the same time step, containing the resource usage of all nodes.

[0190] Define Y as the matrix representing the predicted remaining resources for each node. Predict Y through the LSTM network:

[0191] Y = σ(X)

[0192] To calculate the specific predicted value Y, the hidden state h of the last time step of the LSTM needs to be t input into the fully connected layer (FCL), and h t is converted to Y, where W fc is the weight matrix of the FCL, and b fc is the bias vector. That is, the hidden state h of the last time step of the LSTM neural network t is input into the fully connected layer to obtain:

[0193] Y = W fc × h t + b fc

[0194] where: Y is the node resource prediction matrix of the predicted industrial computing power nodes; W fc is the weight matrix of the fully connected layer; b fc is the bias vector of the fully connected layer.

[0195] Step 3: Based on the resource prediction matrix, use the multi-granularity sub-task partitioning algorithm (MSPA) to partition the computing tasks generated by the manufacturing system into sub-task sets of fine-grained, medium-grained, and coarse-grained, and map the sub-tasks to the corresponding computing nodes according to the node resource status.

[0196] In the manufacturing system, partitioning tasks into finer granularities for parallel execution can significantly optimize the execution latency, reduce the risk of task timeouts, and reduce the impact of task queuing on subsequent tasks at the computing nodes. However, if the computing tasks are decomposed unreasonably, for example, the high-sampling-rate vibration signal analysis task is directly deployed to a single edge node without parallelization splitting, it may lead to node overload and real-time detection latency, and then trigger the risk of production line downtime. Another example is that forcibly splitting the multi-layer inference of a deep learning model into multiple sub-tasks across the cloud may increase the communication overhead due to frequent data transmission, resulting in the failure of the coordination between quality prediction and process adjustment. A more appropriate way is to decompose the computing tasks into sub-tasks of appropriate granularity according to the processing stages (such as data preprocessing, feature extraction, model inference), and allocate them to the matching computing nodes through a dynamic resource-aware scheduler. Therefore, we propose the MSPA based on the node resource awareness of the LSTM network.

[0197] Specifically, based on the node dynamic resource status predicted by the LSTM, the computing tasks of the manufacturing system can achieve multi-granularity adaptation through three-level decomposition.

[0198] (1) Dependent task structure modeling

[0199] In this embodiment, real-time manufacturing computing tasks (such as process simulation and quality prediction) are abstracted into a directed acyclic graph (DAG), where nodes represent atomic computing operations (such as single-process energy consumption modeling), and edges represent data dependencies and timing constraints between operations. A modular hierarchical decoupling strategy is adopted: for lightweight computing units that can be executed independently, they are grouped alone or with other independent computing units into an independent subtask; for strongly coupled operations with strict causal relationships, they are grouped into a subtask to ensure the integrity of the computing logic. Through topological decoupling, each computing module can be distributedly deployed on edge nodes, and the edge network is used to realize intermediate data exchange, and finally the results of subtasks are fused. Although data copy synchronization incurs additional network overhead, the parallelization scheme based on task decomposition still has significant advantages in improving system throughput.

[0200] (2) Multi-granularity subtask partitioning

[0201] Based on the prediction results of the dynamic resource characteristics of edge nodes (including computing main frequency memory bandwidth B(i) and network latency ), a multi-granularity partitioning theoretical model for manufacturing tasks is established. For subtasks with

[0202] The process of partitioning computing tasks using the multi-granularity subtask partitioning algorithm in this embodiment follows the principle of hierarchical dynamic programming, including:

[0203] Fine-grained partitioning layer: The computing task is abstracted into a directed acyclic graph. For parallelizable computing units, a set of minimum computing units {s f} is constructed according to the data locality principle, satisfying the constraint:

[0204]

[0205] where: d f is the data transfer volume of the fine-grained computing unit; η is the network bandwidth utilization threshold to ensure that the data transfer time does not exceed the total delay budget; B (i) is the memory bandwidth; Δ max is the maximum tolerable delay of the task; is the network latency.

[0206] Medium-grained aggregation layer: Based on the node computing power dynamically aggregate fine-grained units into s m , satisfying the constraint:

[0207]

[0208] where: c fis the computational workload of the fine-grained computing unit; γ is the computational resource elasticity factor, which is used to balance the node load and the latency constraint.

[0209] Coarse-grained fusion layer: Construct s using the latency-sensitive critical path analysis method c , and fuse the coupled units {s s} with strong timing constraints as coarse-grained subtasks, satisfying the constraints:

[0210]

[0211] where: d s is the total data transmission volume of the subtask group; c s is the total computational workload of the subtask group; μ is the data-computation trade-off coefficient, which coordinates the communication and computational overheads through Pareto optimization.

[0212] In this embodiment, the computing tasks are partitioned by constructing a multi-granularity discrimination function. The multi-granularity discrimination function is:

[0213]

[0214] where: ω C , ω D and ω τ are the weighting coefficients of the computational density, data scale, and latency sensitivity respectively; and:

[0215] When , it is partitioned into fine-grained subtasks;

[0216] When , it is partitioned into medium-grained subtasks;

[0217] When , it is partitioned into coarse-grained subtasks;

[0218] θ f and θ c are the threshold parameters dynamically adjusted through online Bayesian optimization.

[0219] (3) Subtask mapping

[0220] For the large number of computing nodes in the manufacturing system, this embodiment proposes a multi-objective optimization heuristic mapping strategy. Specifically, the method of mapping subtasks to the corresponding computing nodes is as follows.

[0221] Adopt the multi-objective optimization heuristic mapping strategy, divide the nodes into three levels according to the resource situation, corresponding to the three granularities of tasks, and construct a two-dimensional optimization objective function:

[0222]

[0223] where: is the sub-task mapping decision matrix; α and β are dynamic weight coefficients; is the expected queue delay of node i at time slot t based on LSTM prediction; Q i (t) is the real-time task queue of node i at time slot t; N is the total number of available nodes; is for node i k the reciprocal of the main frequency computing efficiency; i k is the target node index assigned to sub-task k; K is the total number of sub-tasks.

[0224] This embodiment defines the mapping relationship between sub-tasks and computing nodes. Let characterize the mapping relationship of sub-task k to node i. For a task group with K sub-tasks, there are node allocation constraints:

[0225]

[0226] Among them: characterize the mapping relationship of sub-task k to node i.

[0227] The optimal mapping relationship between sub-tasks and computing nodes is obtained by using the Pareto front search strategy. On the premise of satisfying the node allocation constraints, through an iterative candidate node screening mechanism:

[0228] 1) Priority sorting stage: According to Construct a delay-sensitive sub-task queue.

[0229] 2) Resource matching stage: Implement weighted round-robin scheduling for high-main-frequency nodes.

[0230] 3) Dynamic compensation stage: Adjust the α / β weight ratio based on the sliding window mechanism to achieve joint optimization of computing-queue.

[0231] Step 4: Construct a task offloading decision model based on the competing double deep Q-network (D3QN), and combine with a multi-objective optimization reward function to dynamically select the offloading nodes and execution order of sub-tasks. The reward function includes the weighted sum of a task delay factor, an energy consumption factor, and a timeout penalty term.

[0232] (1) Task offloading decision model

[0233] Transform the computing task scheduling problem into a Markov decision model, and define the Markov decision as:

[0234] MDP=(S,A,P,R,γ)

[0235] Where: S is the current state space; A is the action space; P is the transition probability, that is, for each state s and action a, the probability of transferring to a new state s′ after executing this action, denoted as P(s′∣s,a); R is the reward function; γ is the discount factor, which is used to discount future rewards to reflect the uncertainty and time value of future rewards.

[0236] For the computing task Ω generated by the intelligent production unit i i , two main factors are considered: whether to perform one-time or two-time offloading and to which computing node to offload. Therefore, the action space A is defined as:

[0237]

[0238] o i =[o1(t),o2(t),…,o n (t)], o n (t)∈{0,1}

[0239] s i =[s1(t),s2(t),…,s n (t)], 0≤s n (t)≤Ω i

[0240] Where: o i is the offloading decision vector; s i is the task allocation vector for node i; N level is the set of nodes with different resource levels; Ω i is the main computing task.

[0241] Since the number of industrial computing nodes is too large under the cloud-edge-end collaborative framework and it is difficult to obtain real-time industrial computing node resource information, in this embodiment, the state space S is constructed using the resource information perceived by the multi-granularity sub-task partitioning algorithm, denoted as:

[0242]

[0243] Where: represents the computing resource information of node i at time t; represents the set of tasks waiting at time t; represents the task queue information of node i at time t; represents the occupancy information of the communication broadband at time t.

[0244] The reward function of the DRL agent is consistent with the utility function. In this embodiment, the reward function R is defined as:

[0245]

[0246] Where: Ri The reward function representing the agent; w is the weight parameter used to adjust the inclination ratio of latency and energy consumption; α and β are the scaling factors used to balance the ranges of rewards for each part and avoid the problem of a single dominant advantage being too large.

[0247] (2) D3QN Agent Workflow

[0248] Input the state vector and extract high-order features through a fully connected layer. As Figure 4 shown, the Dueling network divides the features into two branches: 1. State value branch (Value Stream): Outputs the state value estimate V(s). 2. Advantage function branch (Advantage Stream): Outputs the advantage values V(s,a) for each action.

[0249] In this implementation, the dueling double deep Q-network (D3QN) adopts the Dueling network structure, including a state value branch and an advantage function branch, and generates the Q value through an aggregation formula:

[0250]

[0251] Adopt the ε-greedy strategy to select actions, with a probability of ε for random exploration, otherwise select

[0252] The agent interacts with the environment, generates trajectory data and stores it in the memory bank. Each memory can be represented as memory=(s,a,r,done,s_); where: s is the state, representing the current environmental observation value; a is the action sampled according to the policy network; r is the reward feedback by the environment after executing the action; done is the termination state; s_ is the next environmental value.

[0253] Sample a small batch of experiences from the replay buffer, calculate the target Q value through the target network and the Double Q-Learning mechanism, and the Q value update function is:

[0254]

[0255] where: Q eval is the action estimate value selected by the evaluation network; Q target is the target network estimate value; γ is the discount factor.

[0256] Step Five: Through the target network update mechanism and the adaptive exploration strategy, iteratively optimize the parameters of the D3QN model to achieve real-time dynamic adjustment of the task scheduling decision.

[0257] (1) Target Network Update

[0258] The parameter update method of the D3QN model is as follows: The target network adopts a hard update mechanism based on the temporal difference loss function, that is, the parameters of the evaluation network are completely copied to the target network regularly. Specifically, the evaluation network is optimized by minimizing the temporal difference loss between the predicted Q value and the target Q value, and the loss function is defined in the form of mean square error:

[0259]

[0260] where: θ is the parameter of the evaluation network; θ ― is the parameter of the target network; is the experience replay buffer.

[0261] After every fixed number of training steps, the parameters of the evaluation network are completely synchronized to the target network, avoiding the lag that may be introduced by soft updates, ensuring the timeliness and stability of the target Q value, and maintaining the convergence of the training process at the same time.

[0262] (2) Environmental state iteration

[0263] The real-time dynamic adjustment method of task scheduling decision is as follows: After each task execution, update the queue of each node and the communication broadband delay and generate the next state s t+1 , simulating the actual task processing process:

[0264]

[0265] where: represents the node queue at time t; represents the channel queue at time t; Δt is the time slot experienced in a single iteration step.

[0266] The following combines specific examples to illustrate the specific implementation manner of the cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task division and decision-making of the present invention.

[0267] As Figure 5 shown, this embodiment designs a computing resource scheduling and management system based on the window operating system, and deploys the system in a manufacturing workshop with 1 cloud industrial platform (cloud side), 4 distributed computing servers (edge side) and 32 intelligent production units (device side) for application testing.

[0268] In the test, in this embodiment, the deep reinforcement learning (DRL) agent is first trained. During the training process, a large number of continuous task requests (varying in size, load, and tolerance delay requirements) enter the network. After the model converges, the DRL agent can quickly make corresponding adjustments to environmental changes. During the training process, we randomly add noise to some computing nodes to simulate the unreasonable fluctuations of resources accidentally generated in the actual production and manufacturing process, for testing the robustness of the method of the present invention.

[0269] Figure 6 For the comparison of the average task reward, delay, and energy consumption of the algorithm with 5000 rounds of iteration, since there is no task decomposition, the overall optimization performance and task completion rate of ordinary benchmark algorithms (local execution, edge offloading, etc.) in actual applications are relatively low and not comparable. Therefore, we only introduce the full offloading strategy (Full Offloading) based on MSPA and the deep Q-learning network algorithm (DQN) for comparison.

[0270] It can be seen from the comparison images that the method (D3QN) proposed by the present invention has significant advantages after the model converges. The D3QN algorithm optimizes the overall energy consumption while reducing the task execution delay by reasonably scheduling the decomposed tasks. In contrast, due to the limitations of ordinary DRL algorithms such as overestimation of Q values, the DQN algorithm causes the task group to be unreasonably scheduled, and the performance of the algorithm is poor in most rounds. At the same time, the overall optimization performance of the DQN algorithm shows a downward trend of fluctuations when the computing resources fluctuate.

[0271] Practical applications prove that the method proposed by the present invention has good robustness in dealing with a large number of nodes in the multi-layer architecture of complex manufacturing systems, can quickly adapt to environmental changes and maintain good scheduling effects, and optimize the overall production and manufacturing process.

[0272] The above-described embodiments are merely preferred embodiments given to fully illustrate the present invention, and the protection scope of the present invention is not limited thereto. Equivalent substitutions or transformations made by those skilled in the art on the basis of the present invention are all within the protection scope of the present invention. The protection scope of the present invention is subject to the claims.

Claims

1. A cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on joint optimization of adaptive task partitioning and decision-making, characterized in that: It includes the following steps: Step 1: Construct a hierarchical cloud-edge collaborative computing network model, which includes a three-layer architecture of intelligent production units, edge servers, and cloud industrial platforms; quantify task processing latency, energy consumption, and timeout penalties, construct a multi-objective optimization model, and define the objective function and constraints; Step 2: Through a resource awareness module based on the LSTM neural network, dynamically predict the computing resource status of edge servers and cloud industrial platforms, and generate a node resource prediction matrix; Step 3: Based on the resource prediction matrix, use a multi-granularity subtask partitioning algorithm to partition the computing tasks generated by the manufacturing system into fine-grained, medium-grained, and coarse-grained subtask sets, and map the subtasks to the corresponding computing nodes according to the node resource status; Step 4: Based on the competitive double deep Q network, construct a task offloading decision model, and combine it with a multi-objective optimization reward function to dynamically select the offloading nodes and execution order of subtasks. The reward function includes the weighted sum of task latency factors, energy consumption factors, and timeout penalty terms; Step 5: Through the target network update mechanism and adaptive exploration strategy, iteratively optimize the parameters of the competitive double deep Q network model to achieve real-time dynamic adjustment of task scheduling decisions.

2. The cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making according to claim 1, characterized in that: In the first step, the principle of the hierarchical cloud-edge collaborative computing network model is as follows: within the time interval t, there is a set of N intelligent production units a set of K industrial computing nodes Each edge computing node manages the nearby intelligent production units; the task generated by the i-th intelligent production unit is described as Ω i ={D i , C i , Δ max}, where D i represents the data size of the task, C i represents the total number of cpu cycles required for the computing task, and Δ max represents the maximum tolerable delay of the task; each task is divided into subtasks of different sizes and offloaded to different computing nodes for parallel execution, represents the computing time limit constraint of subtask k.

3. The cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making according to claim 1, wherein: In Step 1, the multi-objective optimization model is expressed as: Where: u i is the utility function; w is the weight coefficient; α and β are the proportionality coefficients; represents the task Ω i the computational latency required for local processing; the task Ω i total latency; represents the task Ω i energy consumption for local computing; represents the task Ω i total energy consumption; Δ max represents the maximum tolerable latency of the task; and: Task Ω i The total latency is expressed as: Wherein: represents task Ω i the computing latency required for local processing; represents the latency required to directly offload task Ω i from the local production terminal to the affiliated edge computing node m; represents the latency required for task Ω i to execute after offloading; o is the offloading decision vector; Task Ω i Total energy consumption Is expressed as: Wherein: represents task Ω i energy consumption calculated locally; E t and E r are respectively the transmission energy consumption and the reception energy consumption of communication between the intelligent production unit, the edge computing node and the industrial cloud platform; represents task Ω i energy consumption after being offloaded to each computing node; Taking the minimum of task execution cost and task execution latency as the optimization objectives, the objective function and constraints are obtained: max u i (t) s.t.e∈[0,1] i∈[1,N] α,β>0 Where: N is the set The number of intelligent production units in 4. The cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making according to claim 1, characterized in that: In Step 2, the method for predicting the node resource prediction matrix based on the LSTM neural network is: Construct a feature matrix with input features including historical queue delay sequences, industrial computing power node loads, task arrival rates, and historical channel state data T is the time window length, and d is the feature dimension; Input the matrix X into the LSTM neural network, and the output of the LSTM neural network is expressed as: h t = σ(x t , h t―1 , c t―1 ) Where: h t and c t represent the hidden state and cell state of the LSTM cell at time step t respectively; h t―1 and c t―1 represent the hidden state and cell state of the LSTM cell at time step t-1 respectively; σ is the sigmoid function; x t represents the slice of matrix X at the same time step, which contains the resource usage of all nodes; The hidden state h of the last time step of the LSTM neural network t is input into the fully connected layer to obtain: Y = W fc × h t + b fc Among them: Y is the node resource prediction matrix of the predicted industrial computing power nodes; W fc is the weight matrix of the fully connected layer; b fc is the bias vector of the fully connected layer.

5. The collaborative scheduling method of cloud-edge computing resources for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making according to claim 1, characterized in that: In Step 3, the process of using the multi-granularity subtask partitioning algorithm to partition computing tasks follows the principle of hierarchical dynamic programming, including: Fine-grained partitioning layer: Abstract the computing task as a directed acyclic graph, and construct a set of minimum computing units according to the data locality principle, satisfying the constraints: Where: d f is the data transfer volume of the fine-grained computing unit; η is the network bandwidth utilization threshold to ensure that the data transfer time does not exceed the total delay budget; B (i) is the memory bandwidth; Δ max is the maximum tolerable delay of the task; is the network delay; Medium-grained aggregation layer: Dynamically aggregate fine-grained units into medium-grained subtasks based on node computing capabilities, satisfying the constraints: Where: c f is the computational workload of the fine-grained computing unit; γ is the computational resource elasticity factor, which is used to balance the node load and latency constraints; is the node computing power; Coarse-grained fusion layer: Use the delay-sensitive critical path analysis method to fuse strongly time-constrained coupled units into coarse-grained subtasks, satisfying the constraints: where: d s is the total data transfer volume of the sub-task group; s c is constructed by using the latency-sensitive critical path analysis method; c s is the total computation volume of the sub-task group; μ is the data-computation trade-off coefficient.

6. The cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making according to claim 5, characterized in that: Construct a multi-granularity discrimination function to partition the computing tasks. The multi-granularity discrimination function is: Where: ω C , ω D and ω τ are the weighting coefficients for calculating density, data scale, and latency sensitivity respectively; and: When it is divided into fine-grained subtasks; When divide medium-granularity subtasks; When it is divided into coarse-grained subtasks; θ f and θ c are threshold parameters dynamically adjusted by online Bayesian optimization.

7. The collaborative scheduling method for cloud-edge computing resources of a complex manufacturing system based on the joint optimization of adaptive task partitioning and decision-making according to claim 5, wherein: In Step 3, the method for mapping subtasks to the corresponding computing nodes is: Adopt a multi-objective optimization heuristic mapping strategy, divide the nodes into three levels according to the resource situation, corresponding to the three granularities of tasks, and construct a two-dimensional optimization objective function: Wherein: is the sub-task mapping decision matrix; α and β are dynamic weight coefficients; is the expected queue delay of node i at time slot t based on LSTM prediction; Q i (t) is the real-time task queue of node i at time slot t; N is the total number of available nodes; is the reciprocal of the main frequency computing efficiency of node i k ; i k is the target node index assigned to sub-task k; K is the total number of sub-tasks; The node allocation constraint is: Wherein: Characterize the mapping relationship of subtask k to node i; Adopt the Pareto front search strategy to obtain the optimal mapping relationship between subtasks and computing nodes.

8. The cloud-edge computing resource collaborative scheduling method for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making according to claim 1, wherein: In Step 4, the task offloading decision model is: Convert the computing task scheduling problem into a Markov decision model, and define the Markov decision as: MDP=(S,A,P,R,γ) Where: S is the current state space; A is the action space; P is the transition probability, that is, for each state s and action a, the probability of transferring to a new state s′ after executing this action, expressed as P(s′∣s,a); R is the reward function; γ is the discount factor; The action space A is: o i = [o1(t), o2(t), …, o n (t)], o n (t) ∈ {0, 1} s i = [s1(t), s2(t), …, s n (t)], 0 ≤ s n (t) ≤ Ω i where: o i is the offloading decision vector; s i is the task assignment vector for node i; N level is the set of nodes with different resource levels; Ω i is the main computing task; Construct a state space S using the resource information perceived by the multi-granularity sub-task partitioning algorithm, which is expressed as: Wherein: represents the computing resource information of node i at time t; represents the task set waiting at time t; represents the task queue information of node i at time t; represents the occupancy information of the communication bandwidth at time t; The reward function R is: Where: R i represents the reward function of the agent; w is the weight parameter used to adjust the inclination ratio of latency and energy consumption; α and β are scaling factors.

9. The collaborative scheduling method for cloud-edge computing resources of a complex manufacturing system based on the joint optimization of adaptive task partitioning and decision-making according to claim 8, characterized in that: The competing double deep Q-network adopts a Dueling network structure, including a state value branch and an advantage function branch, and generates Q values through an aggregation formula: Use the ε-greedy strategy to select actions. With probability ε, perform random exploration; otherwise, select The Q-value update function is: Where: Q eval is the action estimated value selected for the evaluation network; Q target is the target network estimated value; γ is the discount factor.

10. The collaborative scheduling method of cloud-edge computing resources for complex manufacturing systems based on the joint optimization of adaptive task partitioning and decision-making according to claim 9, characterized in that: In step 5, the parameter update method of the competing double deep Q-network model is as follows: The target network adopts a hard update mechanism based on the time difference loss function, and the evaluation network is optimized by minimizing the time difference loss between the predicted Q value and the target Q value. The loss function is defined in the form of mean square error: Where: θ is the evaluation network parameter; θ ― is the target network parameter; is the experience replay buffer; The real-time dynamic adjustment method for task scheduling decisions is as follows: after each task is executed, update the node queues and communication broadband delays and generate the next state s t+1 , and simulate the actual task processing process: Wherein: represents the node queue at time t; represents the channel queue at time t; Δt is the time slot experienced in a single iteration step.

Images