Task scheduling method and device, equipment and storage medium

Abstract

The invention provides a task scheduling method and device, equipment and a storage medium. The method comprises the steps that task information of a to-be-allocated task is input into a task scheduling model to be processed; determining a target edge node based on the output of the task scheduling model and the node state of at least one edge node, wherein the at least one edge node comprises the target edge node; distributing the task to be distributed to the target edge node; according to the method, the task information is processed through the task scheduling model, and the target edge node is dynamically determined in combination with the real-time state of the edge node, so that the adaptability of a task scheduling strategy to diversified task requirements and a dynamic edge computing environment is improved.

Description

Technical Field

[0001] The present application relates to the fields of cloud computing and big data, and in particular to a task scheduling method, apparatus, device, and storage medium. Background Art

[0002] Edge computing provides computing, storage, and network services at the edge of the network near the data source to meet the needs for agile connectivity, real-time business processing, data optimization, and security and privacy protection. Existing scheduling methods usually rely on static rule sets or traditional optimization algorithms such as heuristic algorithms and genetic algorithms, and have poor real-time adaptability. Summary of the Invention

[0003] The embodiments of the present application provide a task scheduling method, apparatus, device, and storage medium to solve the problem of poor real-time adaptability in existing task scheduling methods.

[0004] In order to solve the above technical problems, this application is implemented as follows:

[0005] In a first aspect, an embodiment of the present application provides a task scheduling method, the method comprising:

[0006] Input the task information of the task to be assigned into the task scheduling model for processing;

[0007] determining a target edge node based on an output of the task scheduling model and a node state of at least one edge node, the at least one edge node including the target edge node;

[0008] Allocate the task to be assigned to the target edge node.

[0009] Optionally, before inputting the task information of the to-be-assigned task into the task scheduling model for processing, the method further includes:

[0010] Get task information of multiple tasks;

[0011] determining a priority of each task according to the task information of each task in the plurality of tasks;

[0012] The task to be assigned is determined, where the task to be assigned is the task with the highest priority among the multiple tasks.

[0013] Optionally, determining the target edge node based on the output of the task scheduling model and the node status of at least one edge node includes:

[0014] Collecting the node status of at least one edge node;

[0015] Calculating a comprehensive score for each of the at least one edge node based on the node state of the at least one edge node and a weighted scoring algorithm, wherein a weight parameter for each edge node used to calculate the comprehensive score is determined based on an output of the task scheduling model;

[0016] A node with the highest comprehensive score among the at least one edge node is determined as the target edge node.

[0017] Optionally, the task scheduling model includes a first sub-model constructed based on a deep dual-Q network algorithm of a competitive architecture and a second sub-model constructed based on a proximal policy optimization algorithm.

[0018] Optionally, the task scheduling model is obtained by constructing a reward function based on historical data of experience replay and Markov decision process training;

[0019] The historical data includes state parameters, action parameters, reward parameters and next state parameters; the reward function is constructed based on task completion time, resource utilization, load balancing and energy consumption.

[0020] Optionally, before allocating the to-be-allocated task to the target edge node, the method further includes:

[0021] Obtaining the load status and bandwidth status of the target edge node;

[0022] When the load state does not satisfy the first preset condition or the bandwidth state does not satisfy the second preset condition, updating the target edge node, where the updated target edge node is a node among the at least one edge node except the target edge node before the update;

[0023] The allocating the to-be-allocated task to the target edge node includes:

[0024] Allocate the to-be-allocated task to the updated target edge node.

[0025] In a second aspect, an embodiment of the present application further provides a task scheduling device. The task scheduling device includes:

[0026] Input module, which inputs the task information of the task to be assigned into the task scheduling model for processing;

[0027] a first determining module, configured to determine a target edge node based on an output of the task scheduling model and a node state of at least one edge node, wherein the at least one edge node includes the target edge node;

[0028] The allocation module is configured to allocate the task to be allocated to the target edge node.

[0029] Optionally, the device further comprises:

[0030] The acquisition module is used to obtain task information of multiple tasks;

[0031] a second determining module, configured to determine the priority of each task among the plurality of tasks according to the task information of each task;

[0032] The third determining module is configured to determine the task to be assigned, where the task to be assigned is the task with the highest priority among the multiple tasks.

[0033] Optionally, the first determining module may also be configured to:

[0034] Collecting the node status of at least one edge node;

[0035] Calculating a comprehensive score for each of the at least one edge node based on the node state of the at least one edge node and a weighted scoring algorithm, wherein a weight parameter for each edge node used to calculate the comprehensive score is determined based on an output of the task scheduling model;

[0036] A node with the highest comprehensive score among the at least one edge node is determined as the target edge node.

[0037] Optionally, the task scheduling model includes a first sub-model constructed based on a deep dual-Q network algorithm of a competitive architecture and a second sub-model constructed based on a proximal policy optimization algorithm.

[0038] Optionally, the task scheduling model is obtained by constructing a reward function based on historical data of experience replay and Markov decision process training;

[0039] The historical data includes state parameters, action parameters, reward parameters and next state parameters; the reward function is constructed based on task completion time, resource utilization, load balancing and energy consumption.

[0040] Optionally, the device further comprises:

[0041] Obtaining the load status and bandwidth status of the target edge node;

[0042] When the load state does not satisfy the first preset condition or the bandwidth state does not satisfy the second preset condition, updating the target edge node, where the updated target edge node is a node among the at least one edge node except the target edge node before the update;

[0043] The allocating the to-be-allocated task to the target edge node includes:

[0044] Allocate the to-be-allocated task to the updated target edge node.

[0045] In a third aspect, an embodiment of the present application provides an electronic device, including a transceiver and a processor, wherein the processor is configured to:

[0046] Input the task information of the task to be assigned into the task scheduling model for processing;

[0047] determining a target edge node based on an output of the task scheduling model and a node state of at least one edge node, the at least one edge node including the target edge node;

[0048] Allocate the task to be assigned to the target edge node.

[0049] Optionally, the processor is further configured to:

[0050] Get task information of multiple tasks;

[0051] determining a priority of each task according to the task information of each task in the plurality of tasks;

[0052] The task to be assigned is determined, where the task to be assigned is the task with the highest priority among the multiple tasks.

[0053] Optionally, the processor is further configured to:

[0054] Collecting the node status of at least one edge node;

[0055] Calculating a comprehensive score for each of the at least one edge node based on the node state of the at least one edge node and a weighted scoring algorithm, wherein a weight parameter for each edge node used to calculate the comprehensive score is determined based on an output of the task scheduling model;

[0056] A node with the highest comprehensive score among the at least one edge node is determined as the target edge node.

[0057] Optionally, the task scheduling model includes a first sub-model constructed based on a deep dual-Q network algorithm of a competitive architecture and a second sub-model constructed based on a proximal policy optimization algorithm.

[0058] Optionally, the task scheduling model is obtained by constructing a reward function based on historical data of experience replay and Markov decision process training;

[0059] The historical data includes state parameters, action parameters, reward parameters and next state parameters; the reward function is constructed based on task completion time, resource utilization, load balancing and energy consumption.

[0060] Optionally, the processor is further configured to:

[0061] Obtaining the load status and bandwidth status of the target edge node;

[0062] When the load state does not satisfy the first preset condition or the bandwidth state does not satisfy the second preset condition, updating the target edge node, where the updated target edge node is a node among the at least one edge node except the target edge node before the update;

[0063] The allocating the to-be-allocated task to the target edge node includes:

[0064] Allocate the to-be-allocated task to the updated target edge node.

[0065] In a fourth aspect, an embodiment of the present application provides an electronic device comprising: a processor, a memory, and a program stored in the memory and executable on the processor, wherein when the program is executed by the processor, the steps of the task scheduling method described in the first aspect above are implemented.

[0066] In a fifth aspect, an embodiment of the present application provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, the steps of the task scheduling method described in the first aspect above are implemented.

[0067] In a sixth aspect, an embodiment of the present application provides a computer program product, comprising computer instructions, which, when executed by a processor, implement the steps of the task scheduling method described in the first aspect above.

[0068] The task scheduling method of the present application includes inputting the task information of the task to be assigned into the task scheduling model for processing; determining the target edge node based on the output of the task scheduling model and the node status of at least one edge node, the at least one edge node including the target edge node; and assigning the task to be assigned to the target edge node. This method processes the task information through the task scheduling model and dynamically determines the target edge node based on the real-time status of the edge node, thereby improving the adaptability of the task scheduling strategy to diverse task requirements and dynamic edge computing environments, achieving accurate matching of task characteristics with node resources, thereby improving the resource utilization efficiency and task execution efficiency of the edge computing system, and reducing the resource waste and task delay problems caused by static scheduling or single rules. BRIEF DESCRIPTION OF THE DRAWINGS

[0069] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the following briefly introduces the drawings required for use in the description of the embodiments of the present application. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0070] Figure 1 This is a flowchart of the task scheduling method provided by an embodiment of the present application;

[0071] Figure 2 This is a schematic diagram of a Markov decision process provided by an embodiment of the present application;

[0072] Figure 3 This is a schematic diagram of module division of labor provided by an embodiment of the present application;

[0073] Figure 4 is a structural diagram of a task scheduling device provided in one embodiment of the present application;

[0074] Figure 5 This is a structural diagram of an electronic device provided in one embodiment of the present application. DETAILED DESCRIPTION

[0075] The following will be combined with the drawings in the embodiments of this application to clearly and completely describe the technical solutions in the embodiments of this application. Obviously, the embodiments described are part of the embodiments of this application, not all of them. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0076] This embodiment of the application provides a task scheduling method. Figure 1 , Figure 1 is a flowchart of the task scheduling method provided by the embodiment of the present application, such as Figure 1 As shown, the following steps are included:

[0077] Step 101: Input the task information of the task to be assigned into the task scheduling model for processing;

[0078] In this step, the above-mentioned tasks to be assigned can be understood as computing tasks that have not yet been assigned to edge nodes for execution, and can come from IoT devices, mobile terminals, sensors, etc.; the above-mentioned task information can be understood as data that describes the attributes of the task, specifically, it can include the basic attributes of the task, such as the task identification number, data input and output scale, and can also include resource requirement data such as computing amount, memory usage data, etc., and can also include time constraints, functional requirements or customized priority data or other data, etc., and the embodiments of the present application do not make specific limitations on this.

[0079] The above-mentioned task scheduling model can be understood as a decision model that receives task information and outputs a scheduling strategy. This application does not specifically limit the specific form of the model. It can be an intelligent model such as a deep reinforcement learning model, a machine learning model, or a rule model of a decision engine based on preset rules. In some optional implementations, it can also be an optimization model such as linear programming, dynamic programming, etc.

[0080] Step 102: determining a target edge node based on an output of the task scheduling model and a node state of at least one edge node, wherein the at least one edge node includes the target edge node;

[0081] In this step, the above-mentioned edge nodes can be understood as computing devices deployed at the edge of the network with localized data processing capabilities, such as smart routers, industrial gateways, on-board computing units, fifth-generation mobile communication technology (5G) base station built-in servers and other hardware devices, or they can be heterogeneous resources such as some nodes focusing on central processing unit (CPU) computing power and some nodes integrating neural network processing unit (NPU) acceleration chips; the above-mentioned node status can be understood as real-time data reflecting the current available resources and operating status of the edge node, which can include hardware resource information such as CPU utilization, memory usage, remaining storage space and graphics processing unit (GPU) computing power occupancy, as well as network status such as uplink bandwidth, downlink bandwidth, network delay, and network stability; it can also include software status such as the number of running tasks, operating system load, and service process health status; it can also include environmental parameters such as device temperature and geographic location.

[0082] In some optional implementations, an environmental awareness module can be set up to collect status information of each edge node, such as CPU utilization, memory usage, bandwidth, network latency, etc. At the same time, multi-dimensional data of edge nodes can be obtained through data proxy systems, edge awareness technology, multi-protocol support, etc. In addition to traditional resource indicators such as CPU, memory, and bandwidth, multi-source data such as sensor data, network traffic monitoring information, and device logs can also be integrated. These data sources include but are not limited to:

[0083] Hardware resource monitoring data: CPU utilization, memory usage, bandwidth, disk read and write rates, etc.

[0084] Network status information: network delay, network jitter, bandwidth utilization, etc.;

[0085] Device operation logs: System logs and application logs from devices, providing detailed records of device status and operating behavior;

[0086] External sensor data: Sensor data of the environment around the edge node (such as temperature, humidity, vibration, etc.) provides environmental perception capabilities for system operation.

[0087] In some optional implementations, due to the multi-source and heterogeneous nature of data, these data may exist in different formats after collection (such as structured, semi-structured, and unstructured data). In order to enable the deep reinforcement learning model to efficiently process and understand this data, vectorization technology can be introduced to achieve a unified representation of heterogeneous data; the specific process is as follows:

[0088] Data cleaning and preprocessing: Clean, normalize, and standardize the collected multi-source data to eliminate noise and redundant information and ensure data quality;

[0089] Feature extraction. Perform feature extraction on different types of data (such as time series and log text). For example, use time series analysis techniques to extract the time characteristics of network delays, or use natural language processing (NLP) technology to extract key events from logs.

[0090] Vectorized representation. Using vectorized technology (such as Facebook AI Similarity Search (FAISS), word embedding, etc.), the extracted multi-dimensional data is converted into a high-dimensional vector representation of fixed length. For example, extracting the statistical feature vector v for time series data x t , further reduce the dimension through dimensionality reduction technology, and then construct these statistics into a high-dimensional vector of fixed length. Assuming that 10 features are extracted, the high-dimensional vector representation of the time series may be:

[0091] v time =[f1,f2,...,f 10 ]

[0092] Text logs can be represented as vectors using NLP technology. For example, log information l is used to generate vector v using embedding models. l , which can be expressed as:

[0093] v log =[e1,e2,...,e d ]

[0094] d is the dimension of the embedding vector. The vectorized representation of image or video data is:

[0095] v image =[g1,g2,...,g k ]

[0096] k is the dimension of the image features. In this way, the system can construct a unified global state vector that comprehensively and structuredly represents the state of the current edge node;

[0097] Unified data representation. The unified global state vector can be represented as the concatenation of these high-dimensional vectors:

[0098]

[0099] Here, S is a high-dimensional vector of fixed length, whose dimension is equal to the sum of the dimensions of its individual components. This comprehensive vector S represents the current global state of the system, encompassing information such as time series features, log information, and image features. After vectorization, all multi-source heterogeneous data forms a unified data representation that is input into the subsequent deep reinforcement learning model. This not only improves data processing efficiency but also lays a solid data foundation for subsequent policy generation.

[0100] In some optional implementations, the node status of at least one edge node is continuously updated and perceived in real time, enabling continuous monitoring of the status of each edge node to ensure the system has timely access to the latest status information. This real-time perception capability allows the system to dynamically adjust task scheduling strategies to respond to changes in the network environment or node status.

[0101] The output of the above-mentioned task scheduling model may include a node selection preference, for example, such as "giving priority to nodes with CPU cores ≥ 4 and memory ≥ 8GB", or a weight parameter, such as "the CPU weight of computationally intensive tasks is set to 0.6, and the network weight is set to 0.2", or it may be an output candidate node list, such as filtering out 3 available nodes based on task compatibility, etc. The above-mentioned determination of the target edge node based on the output of the task scheduling model and the node status of at least one edge node can be understood as combining the output of the task scheduling model, such as node selection preference, weight parameters, etc., with the node status data, and selecting the best node from the candidate nodes by screening, sorting, scoring, etc. The embodiment of the present application does not make any specific restrictions on the screening method. It is possible to filter nodes according to the hard conditions output by the model and select the first node that meets the conditions; it is also possible to calculate a comprehensive score for each node and select the node with the highest score; or to use a greedy algorithm, genetic algorithm, etc. to solve the optimal allocation plan. The embodiment of the present application does not make any specific restrictions on this.

[0102] Step 103: Allocate the task to be assigned to the target edge node.

[0103] In this step, the above allocation can be understood as sending the task and its related resources such as input data, dependent libraries, etc. to the target node and triggering the execution process. For example, the task data can be transmitted to the node through the network protocol to distribute the assigned tasks; further, CPU cores, memory space, network bandwidth and other resources are allocated on the node; further, the execution environment on the node is called to start the task and complete the execution of the task.

[0104] In some optional implementations, a node failure detection mechanism can be implemented to regularly monitor the status of edge nodes, enabling real-time detection of node disconnections, overloads, or performance degradation. Upon detecting a node failure, the task allocation module immediately transfers any unfinished tasks from that node to a backup node, ensuring smooth task execution.

[0105] In some optional implementations, if a task is assigned to a node and fails to complete it promptly due to resource exhaustion or network anomalies, the system can initiate a task retry mechanism, automatically selecting another available edge node to reassign the task. For critical tasks, the system can pre-allocate multiple backup nodes to ensure that tasks can be immediately switched to backup nodes if the primary node fails, thereby improving the system's disaster recovery capabilities and task reliability.

[0106] In some optional implementations, a feedback mechanism can be added to monitor task execution and collect data such as task completion time, resource consumption, and node performance changes in real time. Compared to static strategies, adding a feedback mechanism allows for dynamic feedback collection and real-time analysis of this feedback data during task execution, providing a basis for subsequent scheduling strategy optimization. Based on real-time feedback, the system can rapidly adjust existing scheduling strategies. Feedback information such as task delays, resource shortages, and node overloads is captured by the system and passed to the task scheduling model, enabling it to optimize its strategy based on the latest information. This mechanism enables the system to adapt to changing task requirements and network environments, ensuring that the scheduling strategy remains optimal. The feedback mechanism can be integrated with an online learning mechanism, which continuously absorbs the latest feedback data to gradually fine-tune the task scheduling model. This online learning mechanism ensures that the system can continuously update its strategy in complex edge computing environments, preventing scheduling strategy failure or lag. Furthermore, online learning can fine-tune the model based on actual task feedback, ensuring that the scheduling strategy dynamically adapts to real-time task characteristics and environmental changes.

[0107] In the task scheduling method of the embodiment of the present application, the task information is processed by the task scheduling model, and the target edge node is dynamically determined in combination with the real-time status of the edge node, thereby improving the adaptability of the task scheduling strategy to diversified task requirements and dynamic edge computing environment, and achieving accurate matching of task characteristics and node resources, thereby improving the resource utilization efficiency and task execution efficiency of the edge computing system, and reducing resource waste and task delay problems caused by static scheduling or single rules.

[0108] Optionally, before inputting the task information of the to-be-assigned task into the task scheduling model for processing, the method further includes:

[0109] Get task information of multiple tasks;

[0110] determining a priority of each task according to the task information of each task in the plurality of tasks;

[0111] The task to be assigned is determined, where the task to be assigned is the task with the highest priority among the multiple tasks.

[0112] In the task scheduling method of the embodiment of the present application, the aforementioned multiple tasks can be understood as a group of tasks awaiting scheduling within the same time period. These tasks may originate from different devices or application scenarios. For example, in a smart city scenario, these tasks include traffic camera video analysis tasks, streetlight status monitoring tasks, and trash can overflow detection tasks that arrive simultaneously; and in an industrial internet scenario, these tasks include equipment failure warning tasks, production data statistics tasks, and robot control tasks. The aforementioned task information includes key features used for priority determination, such as attributes related to urgency, the time window within which completion must take place, the degree of impact of the task on system operation, or the degree of dependence of the task on scarce resources.

[0113] The above-mentioned priority can be understood as a quantitative indicator for measuring the order of task execution, which is calculated by comprehensively calculating the key features in the task information. The method for determining the priority is not specifically limited in the embodiment of this application. A rule engine method can be used to preset priority rules, for example:

[0114] You can set task priorities first, including:

[0115] Urgency: Based on the time limit, deadline and other information of the task, the task is divided into three priorities: high (2), medium (1), and low (0) (which can be preset before the task is assigned);

[0116] Computational complexity: Based on the computing resources required for the task, it is divided into low computing tasks (0), medium computing tasks (1) and high computing tasks (2) (the classification can be given in advance based on historical execution status or task size);

[0117] Critical task identification: It is used to manually mark tasks that have high real-time requirements and are crucial to business needs. 1 is a critical task and 0 is a non-critical task. Therefore, for any task j, its priority P j It can be represented by a three-dimensional vector:

[0118] P j =(critical task identifier ∈ {0, 1}, urgency ∈ {0, 1, 2}, complexity ∈ {0, 1, 2})

[0119] Here, P = (1, x, x) > P = (0, x, x), P = (a, 2, x) > P = (a, 1, x) > P = (a, 0, x), and P = (a, b, 2) > P = (a, b, 1) > P = (a, b, 0). x represents any value within the selectable range, and a and b represent fixed values ​​within the selectable range. Therefore, for a batch of tasks to be assigned, the priority of the tasks can be sorted according to the above method.

[0120] Furthermore, the allocation can be performed according to the ranking of the target edge nodes and task priorities P, the task with the highest priority is assigned to the target edge node, the ranking of the target edge node tasks is updated, and then the allocation process is continued until it ends.

[0121] This implementation effectively optimizes the order of task processing by obtaining information about multiple tasks and determining their priorities before scheduling, prioritizing high-priority tasks. This prevents excessive resource occupation by low-priority tasks, improves the system's responsiveness to critical tasks, and enhances its stability and reliability. Furthermore, this priority-based task screening mechanism improves the rationality of task scheduling and resource utilization efficiency, making the task scheduling model more targeted, reducing task waiting times, and improving overall task execution efficiency.

[0122] Optionally, determining the target edge node based on the output of the task scheduling model and the node status of at least one edge node includes:

[0123] Collecting the node status of at least one edge node;

[0124] Calculating a comprehensive score for each of the at least one edge node based on the node state of the at least one edge node and a weighted scoring algorithm, wherein a weight parameter for each edge node used to calculate the comprehensive score is determined based on an output of the task scheduling model;

[0125] A node with the highest comprehensive score among the at least one edge node is determined as the target edge node.

[0126] In the task scheduling method of the embodiment of the present application, the above-mentioned collecting the node status of at least one edge node can be understood as collecting real-time operating status data of the edge node, including:

[0127] Hardware resources: CPU utilization, memory usage, and disk read / write rates (e.g., Node A has a CPU utilization of 60% and 2GB of memory remaining).

[0128] Network status: network latency (e.g., round-trip latency from Node B to the terminal is 15ms), bandwidth utilization (current available bandwidth is 80Mbps);

[0129] It can also include device temperature (affecting stability), task processing history (such as the task completion rate of node C in the past hour is 95%), etc.

[0130] In some optional implementations, the real-time operating status data may be processed, for example, after collection, it may be cleaned and normalized (such as standardizing the CPU utilization from [0, 100%] to [0, 1]) to form structured data that can be processed by the model.

[0131] The above-mentioned calculation of the comprehensive score of each edge node in the at least one edge node based on the node status of the at least one edge node and the weighted scoring algorithm can be understood as that when a new task is received, the system first selects the edge node that is most suitable for the current task based on the output of the task scheduling model. This selection process can fully consider the current status of the node (such as CPU, memory, bandwidth, network delay, etc.), as well as the execution requirements of the task (such as computing power, data transmission requirements, time constraints, etc.), so as to ensure that the task can be assigned to the node with the most sufficient resources and the highest execution efficiency. For example, taking the CPU utilization c of node i as i , memory usage m i , network bandwidth size b i and network delay t i As the main evaluation index, the weighted scoring method can be used to calculate the comprehensive score S of the node i :

[0132]

[0133] Among them, w1, w2, w3 and w4 are indicator weight coefficients, the sum of their weights is 1, and they can be dynamically adjusted according to different task requirements to give priority to different goals such as real-time performance or resource utilization. and The values ​​of the corresponding indicators are normalized to ensure that all resource indicators fall in the interval [0,1]:

[0134]

[0135] First, through the environmental perception module, the resource status data of all nodes can be collected in real time. Secondly, the above scoring formula is used to calculate the adaptability score of each node under the current task. Then, for each newly received task, it can be sorted from high to low according to the score, and the node with the highest score can be selected as the task execution node.

[0136] The above determination of the node with the highest comprehensive score among the at least one edge node as the target edge node can be understood as calculating the comprehensive scores of all candidate nodes, sorting them in descending order of scores, and selecting the highest edge node to achieve the optimal matching of task characteristics and node status.

[0137] In this implementation, by collecting multi-source real-time status of edge nodes and using the dynamic weight parameters output by the task scheduling model to construct a weighted scoring algorithm, the node selection process can adapt to task requirements. This data-driven intelligent decision-making mechanism improves the accuracy of matching tasks with node resources, improves the resource utilization and task execution efficiency of the edge computing system, and at the same time enhances the robustness of the system in complex scenarios through multi-objective weight adjustment.

[0138] Optionally, the task scheduling model includes a first sub-model constructed based on a deep dual-Q network algorithm of a competitive architecture and a second sub-model constructed based on a proximal policy optimization algorithm.

[0139] In the task scheduling method of the embodiment of the present application, a hybrid reinforcement learning algorithm based on the competitive architecture of the Dueling Double Deep Q-Network (D3QN) and the Proximal Policy Optimization (PPO) algorithm is adopted, which has the advantages of high efficiency and intelligence. Through the fusion of real-time state feedback and historical experience, the model can quickly adapt to changing environments and task requirements. Combining the advantages of the two algorithms, the model performs well in tasks of different complexity and can learn the optimal scheduling strategy in a short time, thereby improving the efficiency and response speed of the overall system.

[0140] In some optional implementations, the algorithm used can be selected based on the complexity of the task and the characteristics of the environment. For simple tasks, D3QN can be used directly for policy learning, while for complex and dynamic environments, PPO is introduced to improve learning effects and policy stability:

[0141] In simple task environments (typically scenarios where system states and task requirements change slowly and with a certain regularity, where factors such as task arrival rates, edge node resource utilization, and network conditions vary little, and task scheduling is relatively easy to predict), the primary goal of task scheduling is to optimize resource allocation and improve scheduling efficiency, with relatively low requirements for policy robustness. D3QN can be used directly, as it efficiently learns optimal policies in relatively stable environments. It utilizes dual Q-learning to mitigate the bias of overestimating Q values, while separating the relative merits of each action through an advantage function. This makes it suitable for optimizing resource allocation and scheduling strategies in simple environments.

[0142] In complex and dynamic environments (typically scenarios where system states and task requirements change frequently and there is a degree of uncertainty, where edge node loads fluctuate significantly, task types and arrival rates are unpredictable, and resource bottlenecks may occur), task scheduling strategies must not only balance resource efficiency but also possess strong adaptability and decision-making stability to cope with rapid environmental changes and uncertainty. Compared to D3QN, PPO performs more robustly in continuous and complex action spaces, and its policy updates can adaptively adjust to the changing environment.

[0143] In some optional implementations, this can be achieved by adopting different optimization algorithms, such as genetic algorithms, particle swarm optimization algorithms, or scheduling strategies based on heuristic rules. Although these alternative algorithms essentially achieve the same goal, their implementation paths and technical principles are different. However, the D3QN and PPO adopted in the present invention combine the advantages of reinforcement learning, can optimize task scheduling through historical data and real-time feedback, and are highly adaptable and robust. Although genetic algorithms or particle swarm optimization can also be used to optimize scheduling, they usually rely on preset rules and lack self-learning capabilities. When faced with complex and dynamic edge computing environments, their scheduling efficiency is low and it is difficult to cope with rapid changes in node status or task requirements. In addition, heuristic rules are more suitable for small-scale or clear-rule scenarios. When faced with uncertainty and large-scale task scheduling, the scheduling performance is often not as good as reinforcement learning.

[0144] This implementation achieves adaptive policy learning for tasks of varying complexity by building an adaptive scheduling model based on deep reinforcement learning, incorporating a deep dual-Q network and proximal policy optimization. Leveraging the efficient decision-making capabilities of D3QN for simple tasks and the stable optimization advantages of PPO for complex dynamic tasks, it dynamically matches task requirements with algorithmic characteristics, to some extent avoiding the limitations of a single algorithm. This architecture improves the overall efficiency of task scheduling and its stability in complex scenarios, while also enabling refined resource allocation through differentiated algorithm selection.

[0145] Optionally, the task scheduling model is obtained by constructing a reward function based on historical data of experience replay and Markov decision process training;

[0146] The historical data includes state parameters, action parameters, reward parameters and next state parameters; the reward function is constructed based on task completion time, resource utilization, load balancing and energy consumption.

[0147] In the task scheduling method of the embodiment of the present application, reference is made to Figure 2 , the above-mentioned Markov decision process can be understood as a process in which an intelligent agent learns the optimal strategy through interaction with the environment. In some optional implementations, an adaptive scheduling model based on deep reinforcement learning can be adopted. The adaptability and dynamism of the adaptive scheduling model based on deep reinforcement learning stem from its powerful learning and decision-making capabilities. Through deep neural network modeling of complex environments, optimization of real-time perception and feedback mechanisms, processing of multi-objective balance, and coping with environmental uncertainties, deep reinforcement learning can achieve efficient and flexible task scheduling in a constantly changing edge computing environment. The adaptive scheduling model based on deep reinforcement learning mainly includes the settings of state input, action space, reward function, etc., as well as the specific implementation steps of the training process. In order to enhance the flexibility and adaptability of the model, it is possible to consider combining algorithms at the same time, for example, combining the D3QN algorithm with the new reinforcement learning algorithm PPO.

[0148] Specifically, the state s t It is the system environment information perceived by the adaptive scheduling model based on deep reinforcement learning at time step t. The rationality of the state definition directly affects the performance of the model. In distributed edge computing task scheduling, the state usually includes the following elements: task information, edge node information, network status and historical information. Therefore, the state s t It can be represented as a multidimensional vector containing the set of the above information.

[0149] Action a t is the scheduling strategy selected by the model at time step t. The definition of the action space determines the scheduling decisions that the model can take. In edge computing task scheduling, actions typically include the following options: task allocation, resource adjustment, and task migration. The action space can be discrete (such as selecting a specific node) or continuous (such as dynamically adjusting resource allocation), depending on the specific application scenario.

[0150] Reward function r t Used to evaluate the effectiveness of the model's scheduling decisions at time step t. The goal of the reward function is to guide the model toward learning the optimal scheduling strategy. Common reward items include: task completion time, resource utilization, load balancing, and energy consumption. The reward function can be designed as a weighted sum of these indicators, namely:

[0151] r t =w1×r 1 +w2×r 2 +w3×r 3 +w4×r 4

[0152] in, is a weight parameter used to adjust the priority of different objectives. They represent task completion time, resource utilization, load balancing and energy consumption respectively.

[0153] For example, the detailed steps for training an adaptive scheduling model based on deep reinforcement learning can be as follows:

[0154] Step 1: Model initialization. Initialize the weight parameters of the deep neural network, initialize the environment, including the initial task queue and edge node states, and set the initial strategy, usually a random strategy.

[0155] Step 2: Select an algorithm.

[0156] Step 3: Strengthen model sampling and strategy evaluation. First, at time step t, the model is based on the current state s t Select action a t , the strategy can be based on the soft maximum (Soft Maximum, softmax) strategy to balance exploration and utilization; secondly, when performing action a t After that, the environment will return to the new state s t+1 and instant rewards t ; Then, (s t ,a t ,r t ,s t+1 ) is stored in the model's experience replay buffer.

[0157] Step 4: Batch update. First, randomly sample a batch of experience samples from the experience replay buffer; second, predict the Q value of each sample through the deep neural network, and calculate the target Q value using the Bellman equation:

[0158]

[0159] Among them, Q target is the target value; γ is the discount factor, and θ is the parameter of the current neural network; then, the loss function (such as mean square error) is calculated:

[0160]

[0161] Where L(θ) represents the loss and N is the number of samples in the batch. Finally, the neural network parameters θ are updated using gradient descent or other optimization algorithms. If the PPO algorithm is used, the policy gradient method is used to update the policy.

[0162] Step 5: Strategy Optimization. The updated neural network parameters in the previous step are used to improve the scheduling strategy. Through continuous sampling and updating, the model gradually learns an optimal strategy that maximizes the cumulative reward.

[0163] Step 6: Strategy Evaluation and Improvement. During training, you can regularly evaluate the performance of your strategy, such as through cross-validation or by running the model in an independent test environment to evaluate its scheduling effect. Based on the evaluation results, you can adjust the model's hyperparameters (such as the learning rate and discount factor) or network structure (such as the number of layers and nodes) to further improve model performance.

[0164] Step 7: Model Convergence and Application. The reinforcement model training process will continue until the model's cumulative reward converges or reaches the set performance indicator. After the model converges, the trained model will be applied to the subsequent task allocation module to verify its performance in the real environment.

[0165] This implementation builds a multi-objective reward function encompassing metrics such as task completion time and resource utilization, combined with historical data from experience replay and a Markov decision process, enabling the task scheduling model to autonomously learn optimal strategies for dynamic environments. This data-driven training mechanism balances task efficiency, resource utilization, load balancing, and energy consumption, improving the model's adaptability to complex edge computing scenarios, avoiding the limitations of static rules, and enabling self-optimization of scheduling strategies, thereby improving overall system performance and reducing operating costs.

[0166] Optionally, before allocating the to-be-allocated task to the target edge node, the method further includes:

[0167] Obtaining the load status and bandwidth status of the target edge node;

[0168] When the load state does not satisfy the first preset condition or the bandwidth state does not satisfy the second preset condition, updating the target edge node, where the updated target edge node is a node among the at least one edge node except the target edge node before the update;

[0169] The allocating the to-be-allocated task to the target edge node includes:

[0170] Allocate the to-be-allocated task to the updated target edge node.

[0171] In the task scheduling method of the embodiment of the present application, due to the particularities of the edge computing environment, for example, edge node load and bandwidth vary dramatically over time, different nodes have widely varying hardware configurations, or edge devices generally have limited memory / CPU and cannot handle overloaded tasks, etc., ignoring the real-time status of the nodes can easily lead to some nodes being overloaded and some being idle.

[0172] The above-mentioned update can be understood as re-determining the target edge node based on the output of the task scheduling model and the node status of at least one edge node; the above-mentioned updating of the target edge node when the load status does not meet the first preset condition or the bandwidth status does not meet the second preset condition, the updated target edge node is the node of the at least one edge node other than the target edge node before the update. It can be understood that when allocating tasks to be allocated, the system can dynamically adjust the allocation strategy by perceiving and predicting the real-time status of each node; the above-mentioned first preset condition and the second preset condition can be set according to the specific environment or set by the user according to needs. In some optional implementations, if there are critical tasks, stricter preset conditions can be set, or non-critical tasks can relax the conditions, so as to achieve refined scheduling of resources. If the current target node does not meet any of the above conditions, it is reselected from the candidate node set, and the real-time status verification is performed to prevent the task from being allocated to the node that is about to be overloaded, thereby improving the stability of the system.

[0173] For example, the system prioritizes nodes with low current load and sufficient bandwidth for high-computation tasks, avoiding over-concentration of load and improving overall resource utilization. Furthermore, the system prioritizes assigning tasks to nodes with optimal execution times based on deadlines and latency requirements, maximizing task execution efficiency.

[0174] This implementation, by verifying the target node's load and bandwidth status twice before task assignment and dynamically updating the node if the conditions are not met, avoids, to some extent, the existing issues of "static scheduling leading to node overload" and "high task execution failure rate." This closed-loop mechanism of real-time state perception, condition verification, and dynamic adjustment improves the reliability and resource elasticity of edge computing systems. It is suitable for highly dynamic, resource-constrained edge scenarios, enhancing the stable execution of critical tasks and extending the lifespan of edge devices.

[0175] In some optional embodiments, such as Figure 3 As shown, the above steps can be implemented through the following four modules:

[0176] Environmental Perception Module: This module achieves panoramic awareness of the edge computing environment's status through comprehensive collection and processing of multi-source heterogeneous data. Advanced vectorization technology ensures efficient information representation, enabling the task scheduling model to obtain comprehensive status information, including key metrics such as CPU utilization, memory usage, and network latency. This comprehensive information provides a solid data foundation for subsequent policy learning and task allocation, enhancing the system's decision-making capabilities. This module not only collects status information from each edge node (such as CPU utilization, memory usage, bandwidth, and network latency), but also uses advanced technologies to comprehensively collect and preprocess multi-source heterogeneous data. Traditional edge computing systems often limit data collection to a single source or a limited number of metrics, failing to fully reflect the system's global status. This paper proposes an improved environmental perception method that integrates multi-source heterogeneous data from different data sources and formats, ensuring comprehensive and real-time awareness of the edge node's operating status. This module specifically includes three functions: multi-source heterogeneous data collection, unified preprocessing and vectorization of heterogeneous data, and continuous data updating and real-time perception. By applying these technologies, the environmental perception module provides a comprehensive and real-time description of the global status of distributed edge computing systems. This perception method based on multi-source heterogeneous data collection and vectorization technology greatly enriches the data input of the system and provides efficient and convenient data support for the subsequent learning and optimization of adaptive models based on deep reinforcement learning.

[0177] Policy Learning Module: This module utilizes a hybrid reinforcement learning algorithm based on D3QN and PPO, offering both efficiency and intelligence. By integrating real-time state feedback with historical experience, the model can rapidly adapt to changing environments and task requirements. Combining the strengths of both algorithms, the model excels in tasks of varying complexity, learning optimal scheduling policies in a short period of time, thereby improving overall system efficiency and responsiveness.

[0178] Task Allocation Module: This module is designed to prioritize reliability. Through a dynamic task allocation mechanism, it efficiently assigns tasks to appropriate edge nodes based on real-time status and optimal strategies. This task allocation process balances resource utilization and task execution efficiency, ensuring stable and efficient system performance even under high loads. Furthermore, the module's built-in disaster recovery mechanism can address node failures or model decision malfunctions, ensuring system reliability. The core of the task allocation module is to implement a scheduling policy derived from an adaptive scheduling model based on deep reinforcement learning, dynamically allocating tasks to the most suitable edge nodes to improve resource utilization and task execution efficiency. The design of this module focuses on improving the system's resource scheduling efficiency and overall task execution performance through a rational task allocation strategy. Specific implementation methods for task allocation include: policy-based task allocation, such as node selection and optimization of resource utilization and task execution efficiency; mechanisms for balancing resources and efficiency; and the design of disaster recovery mechanisms.

[0179] Feedback Optimization Module: This module emphasizes real-time, dynamic, and adaptable performance. By monitoring task execution in real time and rapidly transmitting feedback to the policy learning module, it enables dynamic policy optimization. This feedback mechanism enables timely model adjustments and updates to adapt to changing network environments and task characteristics, ensuring optimal performance in complex and dynamic edge computing environments. The core function of the feedback optimization module is to collect real-time feedback from task execution and transmit this data to the policy learning module for scheduling optimization, enabling the system to dynamically adapt to changing network environments and task requirements. This module focuses on continuously optimizing model decisions through feedback-driven mechanisms, enhancing the system's adaptability and real-time responsiveness. This is achieved through three key capabilities: real-time feedback collection and analysis, feedback-driven policy updates, and feedback-driven policy updates. The modular design provides clear division of labor and efficient collaboration, allowing each module to focus on specific functions, ensuring the system can efficiently and flexibly handle complex task scenarios. This improves the system's flexibility and adaptability compared to merging or simplifying modules.

[0180] It should be noted that the existing technology cannot achieve multi-source data perception, lacks adaptive scheduling capabilities, task allocation decisions are not accurate enough, and system performance is unstable. The embodiments of the present application have higher performance and adaptability in dynamic and complex edge computing environments.

[0181] In some optional implementations, in addition to using the environment perception module, it is also possible not to use multi-source data, but to rely only on a single data source (such as hardware status information of the edge node) for perception, or to use different feature extraction methods.

[0182] In addition, the interaction mode between system modules can be adjusted according to user needs or certain modules can be reduced to reduce the difficulty of implementation. This embodiment of the present application does not make any specific limitations on this.

[0183] See also Figure 4 , Figure 4 This is a structural diagram of a task scheduling device provided in another embodiment of the present application.

[0184] like Figure 4 As shown, the task scheduling device 400 includes:

[0185] Input module 401, inputs the task information of the task to be assigned into the task scheduling model for processing;

[0186] A first determining module 402 is configured to determine a target edge node based on an output of the task scheduling model and a node state of at least one edge node, wherein the at least one edge node includes the target edge node;

[0187] The allocation module 403 is configured to allocate the to-be-allocated task to the target edge node.

[0188] Optionally, the device further comprises:

[0189] The acquisition module is used to obtain task information of multiple tasks;

[0190] a second determining module, configured to determine the priority of each task among the plurality of tasks according to the task information of each task;

[0191] The third determining module is configured to determine the task to be assigned, where the task to be assigned is the task with the highest priority among the multiple tasks.

[0192] Optionally, the first determining module may also be configured to:

[0193] Collecting the node status of at least one edge node;

[0194] Calculating a comprehensive score for each of the at least one edge node based on the node state of the at least one edge node and a weighted scoring algorithm, wherein a weight parameter for each edge node used to calculate the comprehensive score is determined based on an output of the task scheduling model;

[0195] A node with the highest comprehensive score among the at least one edge node is determined as the target edge node.

[0196] Optionally, the task scheduling model includes a first sub-model constructed based on a deep dual-Q network algorithm of a competitive architecture and a second sub-model constructed based on a proximal policy optimization algorithm.

[0197] Optionally, the task scheduling model is obtained by constructing a reward function based on historical data of experience replay and Markov decision process training;

[0198] The historical data includes state parameters, action parameters, reward parameters and next state parameters; the reward function is constructed based on task completion time, resource utilization, load balancing and energy consumption.

[0199] Optionally, the device further comprises:

[0200] Obtaining the load status and bandwidth status of the target edge node;

[0201] When the load state does not satisfy the first preset condition or the bandwidth state does not satisfy the second preset condition, updating the target edge node, where the updated target edge node is a node among the at least one edge node except the target edge node before the update;

[0202] The allocating the to-be-allocated task to the target edge node includes:

[0203] Allocate the to-be-allocated task to the updated target edge node.

[0204] For details, see Figure 5 As shown, an embodiment of the present application further provides an electronic device, including a bus 501 , a transceiver 502 , an antenna 503 , a bus interface 504 , a processor 505 and a memory 506 .

[0205] Processor 505, configured to:

[0206] Input the task information of the task to be assigned into the task scheduling model for processing;

[0207] determining a target edge node based on an output of the task scheduling model and a node state of at least one edge node, the at least one edge node including the target edge node;

[0208] Allocate the task to be assigned to the target edge node.

[0209] exist Figure 5In the embodiment, the bus architecture (represented by bus 501) is shown. Bus 501 may include any number of interconnected buses and bridges. Bus 501 links together various circuits including one or more processors represented by processor 505 and memory represented by memory 506. Bus 501 may also link together various other circuits such as peripheral devices, voltage regulators, and power management circuits, which are all well known in the art and are therefore not described further herein. Bus interface 504 provides an interface between bus 501 and transceiver 502. Transceiver 502 may be a single element or multiple elements, such as multiple receivers and transmitters, providing a unit for communicating with various other devices over a transmission medium. Data processed by processor 505 is transmitted over a wireless medium via antenna 503. Furthermore, antenna 503 receives data and transmits the data to processor 505.

[0210] The processor 505 is responsible for managing the bus 501 and general processing, and may also provide various functions, including timing, peripheral interfaces, voltage regulation, power management, and other control functions. The memory 506 may be used to store data used by the processor 505 when performing operations.

[0211] Optionally, the processor 505 may be a central processing unit (CPU), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), or a complex programmable logic device (CPLD).

[0212] Optionally, the monitoring information includes distance information and speed information corresponding to the at least one target object, and the processor 505 is specifically configured to:

[0213] Get task information of multiple tasks;

[0214] determining a priority of each task according to the task information of each task in the plurality of tasks;

[0215] The task to be assigned is determined, where the task to be assigned is the task with the highest priority among the multiple tasks.

[0216] Optionally, the processor 505 is specifically configured to:

[0217] Collecting the node status of at least one edge node;

[0218] Calculating a comprehensive score for each of the at least one edge node based on the node state of the at least one edge node and a weighted scoring algorithm, wherein a weight parameter for each edge node used to calculate the comprehensive score is determined based on an output of the task scheduling model;

[0219] A node with the highest comprehensive score among the at least one edge node is determined as the target edge node.

[0220] Optionally, the task scheduling model includes a first sub-model constructed based on a deep dual-Q network algorithm of a competitive architecture and a second sub-model constructed based on a proximal policy optimization algorithm.

[0221] Optionally, the task scheduling model is obtained by constructing a reward function based on historical data of experience replay and Markov decision process training;

[0222] The historical data includes state parameters, action parameters, reward parameters and next state parameters; the reward function is constructed based on task completion time, resource utilization, load balancing and energy consumption.

[0223] Optionally, the processor 505 is further configured to:

[0224] Obtaining the load status and bandwidth status of the target edge node;

[0225] When the load state does not satisfy the first preset condition or the bandwidth state does not satisfy the second preset condition, updating the target edge node, where the updated target edge node is a node among the at least one edge node except the target edge node before the update;

[0226] The allocating the to-be-allocated task to the target edge node includes:

[0227] Allocate the to-be-allocated task to the updated target edge node.

[0228] It should be noted that the electronic device provided in the embodiment of the present application is a device capable of executing the above-mentioned task scheduling method. Therefore, all implementation methods in the above-mentioned task scheduling method embodiment are applicable to the electronic device and can achieve the same or similar beneficial effects. To avoid repetition, this embodiment will not be described in detail.

[0229] An embodiment of the present invention also provides an electronic device, comprising: a processor, a memory, and a program stored in the memory and runnable on the processor. When the program is executed by the processor, the various processes of the above-mentioned task scheduling method embodiment are implemented, and the same technical effect can be achieved. To avoid repetition, it will not be repeated here.

[0230] The present application also provides a computer-readable storage medium having a computer program stored thereon. When the computer program is executed by a processor, the computer program implements the various processes of the above-mentioned task scheduling method embodiment and can achieve the same technical effect. To avoid repetition, the details are not described here. The computer-readable storage medium is, for example, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk.

[0231] An embodiment of the present application also provides a computer program product, including computer instructions. When the computer instructions are executed by a processor, the various processes of the above-mentioned task scheduling method embodiment are implemented and can achieve the same technical effect. To avoid repetition, they will not be repeated here.

[0232] It should be noted that, in this document, the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, article, or apparatus comprising a series of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or apparatus. In the absence of further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of other identical elements in the process, method, article, or apparatus comprising the element.

[0233] Through the description of the above implementation methods, those skilled in the art can clearly understand that the above-mentioned embodiment methods can be implemented by means of software plus the necessary general hardware platform, and of course can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art, can be embodied in the form of a software product, which is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk), and includes a number of instructions for enabling a terminal (which can be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in each embodiment of the present application.

[0234] The embodiments of the present application are described above in conjunction with the accompanying drawings, but the present application is not limited to the above-mentioned specific implementation methods. The above-mentioned specific implementation methods are merely illustrative and not restrictive. Under the guidance of this application, ordinary technicians in this field can also make many forms without departing from the purpose of this application and the scope of protection of the claims, all of which are within the protection of this application.

Claims

1. A task scheduling method, characterized in that: The method comprises: Input the task information of the task to be assigned into the task scheduling model for processing; determining a target edge node based on an output of the task scheduling model and a node state of at least one edge node, the at least one edge node including the target edge node; Allocate the task to be assigned to the target edge node.

2. The method according to claim 1, characterized in that Before inputting the task information of the to-be-assigned task into the task scheduling model for processing, the method further includes: Get task information of multiple tasks; determining a priority of each task according to task information of each task among the plurality of tasks; The task to be assigned is determined, where the task to be assigned is the task with the highest priority among the multiple tasks.

3. The method according to claim 2, characterized in that The determining of the target edge node based on the output of the task scheduling model and the node status of at least one edge node includes: Collecting the node status of at least one edge node; Calculating a comprehensive score for each of the at least one edge node based on the node state of the at least one edge node and a weighted scoring algorithm, wherein a weight parameter for each edge node used to calculate the comprehensive score is determined based on an output of the task scheduling model; A node with the highest comprehensive score among the at least one edge node is determined as the target edge node.

4. The method according to any one of claims 1 to 3, characterized in that The task scheduling model includes a first sub-model constructed based on a deep dual-Q network algorithm of a competitive architecture and a second sub-model constructed based on a proximal strategy optimization algorithm.

5. The method according to any one of claims 1 to 3, characterized in that The task scheduling model is obtained by constructing a reward function based on historical data of experience replay and Markov decision process training; The historical data includes state parameters, action parameters, reward parameters and next state parameters; the reward function is constructed based on task completion time, resource utilization, load balancing and energy consumption.

6. The method according to any one of claims 1 to 3, characterized in that Before allocating the to-be-allocated task to the target edge node, the method further includes: Obtaining the load status and bandwidth status of the target edge node; When the load state does not satisfy the first preset condition or the bandwidth state does not satisfy the second preset condition, updating the target edge node, where the updated target edge node is a node among the at least one edge node except the target edge node before the update; The allocating the to-be-allocated task to the target edge node includes: Allocate the to-be-allocated task to the updated target edge node.

7. A task scheduling device, characterized in that: The device comprises: Input module, which inputs the task information of the task to be assigned into the task scheduling model for processing; a first determining module, configured to determine a target edge node based on an output of the task scheduling model and a node state of at least one edge node, wherein the at least one edge node includes the target edge node; The allocation module is configured to allocate the task to be allocated to the target edge node.

8. An electronic device, characterized in that: The method comprises a processor, a memory, and a computer program stored in the memory and executable on the processor, wherein the computer program implements the steps of the task scheduling method according to any one of claims 1 to 6 when executed by the processor.

9. A computer-readable storage medium, characterized in that The computer-readable storage medium stores a computer program, which, when executed by a processor, implements the steps of the task scheduling method according to any one of claims 1 to 6.

10. A computer program product, characterized in that The method comprises computer instructions, which, when executed by a processor, implement the steps of the task scheduling method according to any one of claims 1 to 6.

Images