Task scheduling method, device, system, electronic device and storage medium

Abstract

The application provides a task scheduling method, device, system, electronic equipment and storage medium, and relates to the technical field of scheduling optimization. The method comprises the following steps: a multi-scale graph network corresponding to a scheduling task is constructed, and the multi-scale graph network comprises task nodes; node features of the task nodes are extracted, and the task nodes are screened according to the node features to obtain key bottleneck nodes meeting the conditions; optional scheduling states corresponding to the key bottleneck nodes are mapped into qubits; a target energy function for quantum degeneration evolution is obtained, and a bottleneck system composed of the qubits is evolved according to the target energy function to obtain an optimized state of the key bottleneck nodes; scheduling is performed according to the optimized state to generate a scheduling scheme for the scheduling task, so that efficient collaborative optimization in a complex scheduling scenario is realized, the solving quality and the calculation efficiency are improved, and the generated scheduling scheme can take into account the global consistency and the global feasibility of different time scales.

Description

Technical Field

[0001] This invention relates to the field of scheduling optimization technology, and in particular to a task scheduling method, a task scheduling device, a task orchestration system, an electronic device, and a computer-readable storage medium. Background Technology

[0002] With the advancement of industry and intelligent manufacturing, the complexity of production and scheduling systems is increasing daily. In scenarios such as manufacturing workshops, logistics distribution, and project collaboration, scheduling problems typically manifest as combinatorial optimization problems involving multiple tasks, resources, and constraints. These problems often face the following challenges: The curse of dimensionality: The surge in the number of tasks, types of resources, and constraints leads to an exponential expansion of the solution space, making it difficult for traditional optimization methods to find feasible solutions within a reasonable time. Local Optimality Trap: Classical heuristic algorithms or mathematical programming methods are prone to getting trapped in local optima during the search process, especially when the problem has multiple peaks and the global search capability is insufficient; Bottleneck isolation optimization: Existing methods usually separate bottleneck identification from bottleneck scheduling. The identified bottleneck nodes are treated with fixed optimization strategies, lacking a coordinated consideration of the dynamic evolution of bottlenecks and their mutual influence. Time-scale fragmentation: Actual scheduling often involves multiple time granularities, and there is coupling between optimization objectives and constraints at different levels. Traditional methods often use fixed time windows or optimize each level independently, resulting in a disconnect between local scheduling and global strategy, making it difficult to guarantee overall consistency; Insufficient adaptability to uncertainty: Uncertain factors such as equipment failure, emergency order insertion, and resource fluctuations frequently occur in the production environment. Traditional optimization models are mostly static or open-loop, lacking the ability to respond quickly to real-time feedback, and have poor robustness and adaptability.

[0003] To address the aforementioned issues, existing technologies have developed various improved algorithms, such as the introduction of tabu search, particle swarm optimization, and multi-objective evolutionary algorithms. However, these still cannot fundamentally solve the comprehensive challenges of multi-scale coupling, dynamic bottleneck coordination, and uncertainty adaptation simultaneously. Summary of the Invention

[0004] The present invention provides a task scheduling method, apparatus, system, electronic device, and computer-readable storage medium to solve or partially solve the problems of difficulty in effectively coordinating multiple bottlenecks, local optimum traps, solution difficulties, and time scale fragmentation in multi-scale scheduling scenarios.

[0005] This invention discloses a task scheduling method, characterized by comprising: Construct a multi-scale graph network corresponding to the scheduling tasks, wherein the multi-scale graph network includes at least task nodes at the time scale level; Extract the node features of the task nodes, and filter the task nodes according to the node features to obtain the key bottleneck nodes that meet the conditions. Map the optional scheduling states corresponding to the key bottleneck nodes to qubits; Obtain the target energy function for quantum degeneracy evolution, and evolve the bottleneck system composed of the qubits according to the target energy function to obtain the optimized state of the key bottleneck node; Based on the optimized state, a scheduling plan is generated for the scheduled task.

[0006] In some feasible implementations, the step of filtering task nodes based on the node characteristics to obtain key bottleneck nodes that meet the conditions includes: The node features of the task node are aggregated to obtain the bottleneck impact score of the task node; Task nodes whose bottleneck impact score is greater than or equal to a preset dynamic threshold are designated as critical bottleneck nodes.

[0007] In some feasible implementations, the aggregation of node features of the task node to obtain the bottleneck impact score of the task node includes: Obtain a bottleneck identification model, which includes at least a graph attention layer and a fully connected layer; The attention weights between the task node and its neighboring nodes are calculated through the graph attention layer, and the node features of the neighboring nodes are weighted and aggregated using the attention weights to obtain the context-enhanced representation corresponding to the task node. The node features of the task node itself are fused with the context-enhanced representation and input into the fully connected layer to output the bottleneck impact score of the task node.

[0008] In some feasible implementations, the node characteristics include at least one or more of the following static or dynamic attributes: task duration, resource requirements, task priority, deadline, resource contention intensity, task delay risk, resource utilization, task complexity, historical bottleneck frequency, number of downstream tasks, resource conflict graph centrality, and current progress deviation.

[0009] In some feasible implementations, the critical bottleneck node includes a first bottleneck node with a binary selectable state and a second bottleneck node with a multi-value selectable state. Mapping the selectable scheduling state corresponding to the critical bottleneck node to a qubit includes: For the first bottleneck node, a direct mapping using a single qubit is employed, with the two ground states of the qubit corresponding to the binary selectable states. For the second bottleneck node, binary encoding or one-hot encoding is used, and a combination of multiple qubits is used to represent each possible state. When the one-hot encoding is used, a penalty term is introduced into the target energy function to constrain multiple qubits corresponding to the same critical bottleneck node to have only one active state at any given time.

[0010] In some feasible implementations, the step of evolving the bottleneck system composed of the qubits according to the target energy function to obtain the optimized state of the key bottleneck node includes: The bottleneck system composed of the qubits is initialized to a quantum superposition state; Obtain the classical term corresponding to the target energy function and the driving term used to guide the quantum tunneling effect, and use the classical term and the driving term as the quantum annealing Hamiltonian; The bottleneck system is driven to evolve by the quantum annealing Hamiltonian, and the bottleneck system is measured after the evolution is completed to obtain the target classical value of the qubit. The classic target value is decoded to obtain the optimization state of the key bottleneck node.

[0011] In some feasible implementations, the process of driving the bottleneck system's evolution through the quantum annealing Hamiltonian, and then measuring the bottleneck system after the evolution to obtain the target classical value of the qubit, includes: The bottleneck system is driven to undergo multiple independent quantum annealing evolutions by the quantum annealing Hamiltonian. Each evolution obtains a set of initial classical values ​​for the qubits and the target energy function value corresponding to the initial classical values. The initial classical values ​​that minimize the target energy function value are selected as the target classical values.

[0012] Among some feasible implementation methods are: During the evolution of the bottleneck system, local energy change information, historical optimization success rate, and conflict information with neighboring nodes of the key bottleneck nodes are obtained. The degree of optimization stagnation corresponding to the key bottleneck node is determined using the local energy change information. The degree of conflict corresponding to the critical bottleneck node is determined using the conflict information. The dynamic attention weight of the key bottleneck node is obtained by calculating the degree of optimization stagnation, the degree of conflict, and the historical optimization success rate.

[0013] In some feasible implementations, the method further includes: The annealing temperature is dynamically adjusted according to the dynamic attention weight and the degree of conflict, and the quantum noise intensity is dynamically adjusted according to the dynamic attention weight and the degree of optimization stagnation. The annealing temperature is used to control the probability of the bottleneck system receiving inferior solutions during its evolution, and the quantum noise intensity is used to control the strength of the quantum tunneling effect during the bottleneck system's evolution.

[0014] In some feasible implementations, the step of scheduling based on the optimization state to generate a scheduling scheme for the scheduled task includes: Based on the optimization status of the key bottleneck nodes, determine the start and end times, resource allocation, and dependencies between tasks for each task node at different time scale levels. Output the start and end times, resource allocation, and dependencies in the form of structured data and / or visual charts to generate a scheduling plan for the scheduled task.

[0015] In some feasible implementations, the time scale hierarchy includes at least a first time scale hierarchy and a second time scale hierarchy, wherein the first time scale hierarchy corresponds to a high-level optimization model, and the second time scale hierarchy corresponds to a low-level optimization model. The method further includes: Obtain the optimization results output by the high-level optimization model. The optimization results include at least the resource allocation scheme and the node completion time limit carrying the initial relaxation. When optimizing the low-level optimization model, the solution space of the low-level optimization model is constrained according to the available resource time period and available resource capacity corresponding to the resource configuration scheme. Within the constrained solution space, a penalty term related to the node completion time limit is added to the objective function of the low-level optimization model. The penalty term is used to increase the objective function value when the task delays the node completion time limit. The penalty strength of the penalty term is determined by the current relaxation degree corresponding to the node completion time limit. During the execution of the low-level optimization model, the actual execution parameters corresponding to the currently executed task are collected in real time, and the deviation between the actual execution parameters and the preset plan value is calculated. If the deviation causes the penalty term to be triggered, the trigger frequency and / or trigger amplitude corresponding to the penalty term are obtained, and the trigger frequency and / or trigger amplitude are used as feedback signals and uploaded to the high-level optimization model. The high-level optimization model responds to the feedback signal, adjusting the slack of the node completion time limit in subsequent optimization cycles, and / or adjusting the weight coefficient of the penalty term in the low-level optimization model.

[0016] Among some feasible implementation methods are: Collect the actual execution data corresponding to the scheduling scheme; Obtain the planned execution data corresponding to the scheduling scheme; The actual execution data is compared with the planned execution data to obtain the corresponding difference information. Perform at least one update operation corresponding to the difference information.

[0017] In some feasible implementations, performing at least one update operation corresponding to the difference information includes: Update the node features; Adjust the dynamic threshold for filtering the key bottleneck nodes; Adjust the target energy function; Update the parameters of the multi-scale graph network.

[0018] This invention also discloses a task scheduling device, comprising: The graph network construction module is used to construct a multi-scale graph network corresponding to the scheduling task. The multi-scale graph network includes at least task nodes at the time scale level. The node filtering module is used to extract the node features of the task nodes and filter the task nodes according to the node features to obtain key bottleneck nodes that meet the conditions. The state mapping module is used to map the optional scheduling states corresponding to the key bottleneck nodes to qubits; An evolution module is used to obtain a target energy function for quantum degeneracy evolution, and to evolve the bottleneck system composed of the qubits according to the target energy function to obtain the optimized state of the key bottleneck node. The scheme generation module is used to schedule according to the optimization status and generate a scheduling scheme for the scheduled task.

[0019] In some feasible implementations, the node filtering module is specifically used for: The node features of the task node are aggregated to obtain the bottleneck impact score of the task node; Task nodes whose bottleneck impact score is greater than or equal to a preset dynamic threshold are designated as critical bottleneck nodes.

[0020] In some feasible implementations, the node filtering module is specifically used for: Obtain a bottleneck identification model, which includes at least a graph attention layer and a fully connected layer; The attention weights between the task node and its neighboring nodes are calculated through the graph attention layer, and the node features of the neighboring nodes are weighted and aggregated using the attention weights to obtain the context-enhanced representation corresponding to the task node. The node features of the task node itself are fused with the context-enhanced representation and input into the fully connected layer to output the bottleneck impact score of the task node.

[0021] In some feasible implementations, the node characteristics include at least one or more of the following static or dynamic attributes: task duration, resource requirements, task priority, deadline, resource contention intensity, task delay risk, resource utilization, task complexity, historical bottleneck frequency, number of downstream tasks, resource conflict graph centrality, and current progress deviation.

[0022] In some feasible implementations, the critical bottleneck node includes a first bottleneck node with a binary selectable state and a second bottleneck node with a multi-value selectable state. The state mapping module is specifically used for: For the first bottleneck node, a direct mapping using a single qubit is employed, with the two ground states of the qubit corresponding to the binary selectable states. For the second bottleneck node, binary encoding or one-hot encoding is used, and a combination of multiple qubits is used to represent each possible state. When the one-hot encoding is used, a penalty term is introduced into the target energy function to constrain multiple qubits corresponding to the same critical bottleneck node to have only one active state at any given time.

[0023] In some feasible implementations, the evolution module is specifically used for: The bottleneck system composed of the qubits is initialized to a quantum superposition state; Obtain the classical term corresponding to the target energy function and the driving term used to guide the quantum tunneling effect, and use the classical term and the driving term as the quantum annealing Hamiltonian; The bottleneck system is driven to evolve by the quantum annealing Hamiltonian, and the bottleneck system is measured after the evolution is completed to obtain the target classical value of the qubit. The classic target value is decoded to obtain the optimization state of the key bottleneck node.

[0024] In some feasible implementations, the evolution module is specifically used for: The bottleneck system is driven to undergo multiple independent quantum annealing evolutions by the quantum annealing Hamiltonian. Each evolution obtains a set of initial classical values ​​for the qubits and the target energy function value corresponding to the initial classical values. The initial classical values ​​that minimize the target energy function value are selected as the target classical values.

[0025] Among some feasible implementation methods are: The information acquisition module is used to acquire local energy change information, historical optimization success rate, and conflict information with neighboring nodes of the key bottleneck node during the evolution of the bottleneck system. A stagnation determination module is used to determine the degree of optimization stagnation corresponding to the key bottleneck node using the local energy change information. A conflict determination module is used to determine the degree of conflict corresponding to the critical bottleneck node using the conflict information. The dynamic weight calculation module is used to calculate the dynamic attention weight of the key bottleneck node by using the optimization stagnation degree, the conflict degree, and the historical optimization success rate.

[0026] Among some feasible implementation methods are: An adjustment module is configured to dynamically adjust the annealing temperature according to the dynamic attention weight and the degree of conflict, and to dynamically adjust the quantum noise intensity according to the dynamic attention weight and the degree of optimization stagnation. The annealing temperature is used to control the probability of the bottleneck system receiving inferior solutions during its evolution, and the quantum noise intensity is used to control the strength of the quantum tunneling effect during the bottleneck system's evolution.

[0027] In some feasible implementations, the solution generation module is specifically used for: Based on the optimization status of the key bottleneck nodes, determine the start and end times, resource allocation, and dependencies between tasks for each task node at different time scale levels. Output the start and end times, resource allocation, and dependencies in the form of structured data and / or visual charts to generate a scheduling plan for the scheduled task.

[0028] In some feasible implementations, the time scale hierarchy includes at least a first time scale hierarchy and a second time scale hierarchy, wherein the first time scale hierarchy corresponds to a high-level optimization model, and the second time scale hierarchy corresponds to a low-level optimization model. The apparatus further includes: The result output module is used to obtain the optimization results output by the high-level optimization model. The optimization results include at least the resource configuration scheme and the node completion time limit. The penalty term determination module is used to constrain the solution space of the low-level optimization model according to the available resource time period and available resource capacity corresponding to the resource configuration scheme when optimizing the low-level optimization model, and to add a penalty term related to the node completion time limit to the objective function of the low-level optimization model within the constrained solution space. The penalty term is used to increase the objective function value when the task delays the node completion time limit, and the penalty intensity of the penalty term is determined by the current relaxation degree corresponding to the node completion time limit. The deviation calculation module is used to collect the actual execution parameters corresponding to the currently executed task in real time during the execution of the low-level optimization model, and calculate the deviation between the actual execution parameters and the preset plan value. The feedback module is used to obtain the triggering frequency and / or triggering amplitude corresponding to the penalty item if the deviation causes the penalty item to be triggered, and upload the triggering frequency and / or the triggering amplitude as a feedback signal to the high-level optimization model. The optimization module is used to respond to the feedback signal through the high-level optimization model, adjust the slack of the node completion time limit in subsequent optimization cycles, and / or adjust the weight coefficient of the penalty term in the low-level optimization model.

[0029] Among some feasible implementation methods are: The data acquisition module is used to collect the actual execution data corresponding to the scheduling scheme; The data acquisition module is used to acquire the planned execution data corresponding to the scheduling scheme; The comparison module is used to compare the actual execution data with the planned execution data to obtain the corresponding difference information; An update module is used to perform at least one update operation corresponding to the difference information.

[0030] In some feasible implementations, the update module is specifically used to perform at least one of the following update operations: Update the node features; Adjust the dynamic threshold for filtering the key bottleneck nodes; Adjust the target energy function; Update the parameters of the multi-scale graph network.

[0031] This invention also discloses a task scheduling system for implementing the task scheduling method described in this invention.

[0032] In some feasible implementations, the task orchestration system is applied to at least one of manufacturing workshop production scheduling, logistics and distribution scheduling, project collaboration task scheduling, cloud computing resource task scheduling, software development task scheduling, data center operation scheduling, supply order scheduling, energy system load scheduling, and autonomous driving fleet task orchestration.

[0033] This invention also discloses an electronic device, including a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other through the communication bus; The memory is used to store computer programs; When the processor executes a program stored in the memory, it implements the method described in the embodiments of the present invention.

[0034] This invention also discloses a computer-readable storage medium storing instructions that, when executed by one or more processors, cause the processors to perform the methods described in this invention.

[0035] The embodiments of the present invention have the following advantages: In this embodiment of the invention, for a scheduling task, a multi-scale graph network corresponding to the scheduling task is constructed. This multi-scale graph network includes task nodes at different time scale levels and dependency edges between task nodes. Next, node features of the task nodes are extracted, and task nodes are filtered based on these features to obtain key bottleneck nodes that meet certain conditions. The optional scheduling states corresponding to the key bottleneck nodes are mapped to qubits. Then, a target energy function for quantum degeneracy evolution is obtained, and the bottleneck system composed of qubits is evolved according to the target energy function to obtain the optimized state of the key bottleneck nodes. Finally, scheduling is performed based on the optimized state to generate a scheduling scheme for the scheduling task. Thus, by constructing a multi-scale graph network corresponding to the scheduling task, a unified model of the scheduling problem at multiple time granularities is achieved. It can capture the coupling relationship between tasks at different levels from a global perspective, laying the foundation for subsequent collaborative optimization. Then, based on node characteristics, task nodes are screened, which can accurately locate the core links that restrict the overall efficiency from massive tasks, avoid ineffective optimization of non-bottleneck nodes, and reduce computational complexity. After screening out key bottleneck nodes, the quantum tunneling effect of quantum annealing is used to enable the optimization process to cross the classical energy barrier with a certain probability, effectively escape the local optimum trap, and obtain a global approximate optimal solution. Then, based on the optimized results, scheduling is performed to obtain the corresponding scheduling scheme. It realizes efficient collaborative optimization in complex scheduling scenarios with multiple scales, high dimensions, and multiple constraints, improves the solution quality and computational efficiency, and enables the generated scheduling scheme to take into account global consistency and global feasibility at different time scales. Attached Figure Description

[0036] Figure 1 This is a flowchart of the steps of a task scheduling method provided in an embodiment of the present invention; Figure 2 This is a schematic diagram of the quantum computing optimization engine provided in an embodiment of the present invention; Figure 3 This is a structural block diagram of a task scheduling device provided in an embodiment of the present invention. Detailed Implementation

[0037] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0038] Reference Figure 1 The diagram illustrates a flowchart of a task scheduling method provided in an embodiment of the present invention, which may specifically include the following steps: Step 101: Construct a multi-scale graph network corresponding to the scheduling tasks. The multi-scale graph network includes at least task nodes at the time scale level and dependency edges between the task nodes. In this embodiment of the invention, scheduling tasks (all tasks in the following embodiments are scheduling tasks) can be sets of tasks corresponding to different scenarios, such as production scheduling in manufacturing workshops, task scheduling in logistics and distribution, task orchestration in project collaboration, task scheduling in cloud computing resources, task orchestration in software development, job scheduling in data centers, scheduling of supply orders, scheduling of energy load, and task orchestration in autonomous driving fleets. Scheduling tasks have multi-timescale characteristics; for example, in a manufacturing scenario, there are hourly equipment operation tasks, daily work order scheduling, and weekly capacity planning. To solve the multi-scale scheduling problem, this embodiment of the invention can first construct a multi-scale graph network to uniformly model scheduling tasks at multiple time granularities.

[0039] Specifically, multi-scale graph networks can divide scheduling tasks into multiple levels according to time scales, such as hourly, daily, and weekly levels. At each time scale level, scheduling tasks are abstracted as task nodes in the graph network. Each task node represents a specific scheduling task, such as a production process, a logistics delivery, or a project subtask. Simultaneously, dependency edges are constructed between task nodes in the multi-scale graph network. These dependency edges can be used to represent various dependencies between tasks, including temporal dependencies (e.g., task A must be completed before task B), resource dependencies (e.g., task A and task B share the same critical equipment), and logical dependencies (e.g., the output of task A is the input of task B), etc. This invention does not limit these dependencies.

[0040] Through the above process, multi-scale graph networks can fully reflect the task structure and inherent coupling relationships of a scheduling system. For example, for the scheduling tasks of a manufacturing workshop, a graph network containing three levels—weekly, daily, and hourly—can be constructed. At the weekly level, task nodes correspond to key processes in the weekly production plan; at the daily level, task nodes correspond to daily work orders; and at the hourly level, task nodes correspond to specific equipment operation tasks. Task nodes at different levels are connected by dependency edges. For example, the target process in the weekly plan may be decomposed into multiple daily work orders, and daily work orders can be further decomposed into hourly operations. These decomposition relationships can be represented by dependency edges. Simultaneously, there are also dependencies between task nodes within the same level. For example, multiple hourly operation tasks may have sequential constraints, etc., which this invention does not limit.

[0041] In some feasible implementations, the construction of multi-scale graph networks can be automated based on historical scheduling data and task decomposition rules. For example, historical task records can be retrieved from the production execution system, and information such as task start and end times, resource requirements, and dependencies can be extracted. Then, according to preset time scales (such as hours, days, weeks, months, etc.), tasks are categorized into different levels, and corresponding task nodes and dependency edges are established. For newly added scheduled tasks, their time scale level can be automatically determined based on the task's attributes (such as expected execution duration, resource requirement type, etc.), and dependency edges can be constructed based on the logical relationships between tasks.

[0042] Furthermore, multi-scale graph networks can incorporate edge features to enrich the semantic information of dependencies. For example, for dependency edges, features such as dependency type identifiers (temporal dependency, resource dependency, logical dependency), dependency strength coefficients, and resource conflict coefficients can be added. These edge features will be utilized by the graph neural network in subsequent bottleneck identification and optimization processes, thereby more accurately capturing the mutual influence between tasks.

[0043] Step 102: Extract the node features of the task nodes, and filter the task nodes according to the node features to obtain the key bottleneck nodes that meet the conditions. After constructing a multi-scale graph network, it is necessary to identify the key bottleneck nodes that restrict the overall scheduling efficiency from the numerous task nodes. To this end, this embodiment of the invention first extracts the node features of each task node. Node features can be a set of quantitative indicators describing the inherent characteristics of the task node itself and its dynamic state in the scheduling system. These indicators can be used to quantify the attributes of the task node itself and its dynamic state in the scheduling system. Then, based on these node features, task nodes are screened to obtain key bottleneck nodes that meet the conditions, so as to further optimize the state of the key bottleneck nodes and thus improve scheduling efficiency.

[0044] Optionally, the node characteristics include at least one or more of the following static or dynamic attributes: task duration, resource requirements, task priority, deadline, resource contention intensity, task delay risk, resource utilization, task complexity, historical bottleneck frequency, number of downstream tasks, resource conflict graph centrality, current progress deviation, etc. These characteristics can be obtained from the definition data of the scheduled tasks, historical execution records, and real-time monitoring data, and this invention does not impose any limitations on them.

[0045] Among the node characteristics mentioned above, resource contention intensity and task delay risk are key features for measuring a node's bottleneck potential. Specifically, the resource contention intensity of a task node can be calculated, based on the task node's demand for various resources, the available capacity of resources, and the number of other task nodes competing for resources simultaneously. Furthermore, the task delay risk of a task node can be calculated, based on one or more of the task node's slack time, whether the task node is on the critical path, and the task node's historical delay frequency.

[0046] Resource competition intensity can be used to measure the degree of conflict that arises when a task competes with other tasks for limited resources during its execution. It reflects the task's dependence on scarce resources and the potential risk of resource bottlenecks. The calculation of resource competition intensity can be based on the task's demand for various types of resources, the available capacity of resources, and the number of other tasks competing for resources at the same time.

[0047] In some exemplary calculation processes, the intensity of resource competition can be calculated using the following formula:

[0048] in, This refers to the intensity of resource competition. The higher the value, the more intense the resource competition faced by the task, and the higher the possibility of it becoming a bottleneck. This can be the resource requirement r for task i; This can be the total capacity of resource r; This can be the number of other tasks that use resource r within the same time period as task i; This can be the total number of all tasks using resource r within the current time window being considered.

[0049] Optionally, the above formula can be adjusted according to different resource types. For example, different weighting coefficients can be assigned to preemptible resources (such as CPU time slices) and non-preemptible resources (such as dedicated equipment). At the same time, the selection of the time window can also be dynamically adjusted according to the time scale of the task. A shorter time window can be used for hourly tasks, while a longer time window can be used for weekly tasks. This invention does not impose any restrictions on this.

[0050] Task delay risk can be used to represent the probability or severity of a task failing to complete as planned, such as the probability of a task exceeding its deadline or causing subsequent tasks to be delayed. The calculation of task delay risk can be based on a comprehensive assessment of indicators such as the task's slack time, critical path location, and historical delay frequency. In some exemplary calculation processes, task delay risk can be calculated using the following formula:

[0051] in, The slack time is the difference between the latest start time and the earliest start time of a task. It refers to the maximum amount of time that a task can delay without affecting the timely completion of the entire project or subsequent tasks. It can be used to measure the time urgency of a task. The smaller the slack time, the greater the risk, and vice versa. It can be an indicator function. If the task is on the critical path, a coefficient greater than 1 is taken, such as 1.5; otherwise, 1 is taken directly. It can be the delay ratio of this task or similar tasks in the historical scheduling, and the value can be between 0 and 1. It can be a small positive number to avoid division by zero errors.

[0052] Alternatively, in addition to the above formula, the delay probability predicted by machine learning can be used directly as the task delay risk. For example, the delay probability of the current task can be predicted based on historical task execution data through time series models such as long short-term memory networks, and this delay probability can be used as a measure of delay risk. This invention does not limit this.

[0053] In addition to resource competition intensity and task delay risk, node characteristics may also include: Task priority: The importance of a task in the system. It can be specified by the user or business rules and can be represented by a numerical value, such as 1 to 10, with higher values ​​indicating greater importance.

[0054] Deadline urgency: The time difference between the current time and the task deadline, or normalized urgency, for example: urgency i =1 / (deadline-*) t now + δ ).

[0055] Resource utilization rate: The proportion of resources used during task execution, reflecting its contribution to resource load. For example: .

[0056] Task complexity: The number of subtasks within a task, the types of skills required, the technical difficulty, etc., can be quantified into a comprehensive index.

[0057] Historical bottleneck frequency: The proportion of times this task was identified as a bottleneck in the total number of scheduling operations in the historical scheduling process.

[0058] Number of downstream tasks: The number of tasks that depend on this task (out-degree), reflecting the extent of its latency propagation.

[0059] Resource conflict graph centrality: In a resource conflict graph, the degree to which a node serves as a resource contention center (e.g., degree centrality, betweenness centrality).

[0060] Current progress deviation: The deviation between the actual progress and the planned progress (such as the difference in the percentage of completion). If it is already behind schedule, the risk is higher.

[0061] The above features can be selected, combined, or normalized according to the actual scheduling scenario, ultimately forming the feature vector of each task node. x i ∈R d ,in, d It can be the corresponding feature dimension.

[0062] After extracting the node features of task nodes, these features can be used to further filter the task nodes to identify key bottleneck nodes that meet the criteria. Key bottleneck nodes are task nodes that significantly constrain the overall efficiency of the scheduling system and require priority optimization.

[0063] In some feasible implementations, bottleneck impact scores for task nodes are obtained by aggregating their node features. Then, task nodes with bottleneck impact scores greater than or equal to a preset dynamic threshold are identified as key bottleneck nodes. This aggregation of node features allows for a comprehensive and accurate assessment of each task node's bottleneck potential by utilizing its own attributes and its structural relationships with neighboring nodes. Furthermore, a dynamic threshold is used for filtering, enabling the identified key bottleneck nodes to adaptively adjust with system state changes, avoiding misjudgments or omissions caused by fixed thresholds. By focusing optimization resources on the core nodes that truly constrain overall efficiency, the computational burden of subsequent quantum annealing optimization is effectively reduced, improving the targeting and efficiency of the overall scheduling optimization.

[0064] The bottleneck impact score can be a comprehensive scalar indicator used to quantify the severity or likelihood of a task node becoming a bottleneck. To calculate the bottleneck impact score, it is necessary to perform an aggregation analysis of the task node's node characteristics and its relationships with neighboring nodes. This process can be implemented using a graph attention-based mechanism, optionally: In the process of determining the bottleneck impact score for each task node, a pre-trained bottleneck identification model can be used. This model includes at least a graph attention layer and a fully connected layer. The graph attention layer aggregates information from neighboring nodes, and the fully connected layer maps the aggregated features to the bottleneck impact score. Specifically, the graph attention layer first calculates the attention weights between the task node and its neighboring nodes, and then uses these attention weights to weighted aggregate the node features of the neighboring nodes to obtain a context-enhanced representation for the task node. The task node's own node features are then fused with this context-enhanced representation and input into the fully connected layer, outputting the bottleneck impact score for the task node. By calculating the attention weights through the graph attention layer, the influence of different neighboring nodes on the current task node can be dynamically learned, more accurately capturing the role of dependencies between tasks in bottleneck formation. Based on this, the attention weights are used to weighted aggregate the features of neighboring nodes to obtain a context-enhanced representation containing local topological structure, allowing the bottleneck identification process to fully integrate the task's own attributes and structural information. Finally, the fully connected layer maps the fused features to the bottleneck impact score, achieving end-to-end quantitative evaluation from multi-dimensional features to bottleneck potential, significantly improving the accuracy and robustness of bottleneck identification.

[0065] In some exemplary computational processes, attention weights can be calculated using the following formula:

[0066] in, and , i, j, are the feature vectors (i.e., node features) of task nodes i and j, respectively; W is a learnable weight matrix used to perform linear transformation on the node features; a is the weight vector of the attention mechanism; Represents vector concatenation operation; N i It is the set of neighboring nodes of task node i. This attention weight... This can reflect the extent of node j's influence on node i.

[0067] Next, the calculated attention weights can be used to weight and aggregate the node features of neighboring nodes to obtain the context-enhanced representation corresponding to the task node. The calculation formula for the context-enhanced representation is as follows:

[0068] The context enhancement means that the influence of neighboring nodes on the current node is incorporated, so that the identifier of the task node not only includes its own characteristics, but also its local topology and neighbor information.

[0069] Then, the node features of the task node itself can be fused with the context-enhanced representation. The fusion can be achieved through vector concatenation, i.e.:

[0070] Alternatively, other fusion methods such as addition or gating mechanisms can be used. The fused feature vector is input into a fully connected layer, and a nonlinear transformation is applied to output the bottleneck impact score of the task node.

[0071] in, v Here, b is the learnable weight vector, b is the bias, and σ is the activation function, such as the sigmoid function, which can map the bottleneck impact score to between 0 and 1. If unbounded real numbers are desired, a linear output can also be used directly.

[0072] Alternatively, the node representations of the last layer of the graph neural network can be directly used as input to the bottleneck impact score, i.e., the node embeddings are obtained after propagation through a multi-layer graph attention network (GAT). z i =GAT(X, G), then z i The bottleneck impact score is obtained by inputting the data into a multilayer perceptron (MLP). s i =MLP( z i ).

[0073] The bottleneck identification model involved in the above process can be a model trained based on historical scheduling data. The construction of the training data can include: extracting the task graph structure and its execution results from historical scheduling logs. For each task node, a corresponding node label is assigned based on whether it becomes an actual bottleneck (e.g., whether it causes delays in subsequent tasks, whether it causes resource blockage, etc.), with node label 1 indicating a bottleneck node and node label 0 indicating a non-bottleneck node. Since bottleneck nodes typically account for a small proportion and there is a class imbalance problem, a weighted cross-entropy loss function can be used.

[0074] in, This can be a weighting coefficient for bottleneck categories, which can be set based on the proportion of key bottleneck nodes, for example... ; It can be a real label. This represents the bottleneck probability predicted by the model.

[0075] During the training of the bottleneck identification model, the Adam optimizer can be used with an initial learning rate of 0.001, along with a learning rate decay strategy. After each training round, the accuracy, recall, and F1 score of bottleneck identification are evaluated using a validation set to prevent overfitting. Furthermore, an early stopping mechanism can be introduced, stopping training if the validation set performance does not improve for 10 consecutive rounds.

[0076] After obtaining the bottleneck impact score for each task node, a dynamic threshold is set to filter out key bottleneck nodes. This dynamic threshold can be set based on the distribution of bottleneck impact scores across all task nodes. For example, one of the following methods can be used: taking the top [number] nodes with the highest bottleneck impact scores. k % is used as a key bottleneck node, such as the top 10%; task nodes whose bottleneck impact score is higher than the mean plus standard deviation are selected. s i > μ s + σ s The present invention does not limit the setting of a fixed threshold based on the frequency of historical bottlenecks and the dynamic adjustment thereof.

[0077] Optionally, to adapt to the dynamic changes in the scheduling system, the dynamic threshold itself can also be updated. In some feasible implementations, the dynamic threshold can be dynamically updated based on the bottleneck occurrence frequency of task nodes in historical scheduling data. Specifically, when the bottleneck occurrence frequency is higher than the first threshold (e.g., the actual number of bottleneck nodes exceeds expectations), it indicates that the current threshold may be too low, causing too many nodes to be identified as bottlenecks. In this case, the dynamic threshold can be increased. When the bottleneck occurrence frequency is lower than the second threshold (e.g., the actual number of bottleneck nodes is far less than expected), it indicates that the current threshold may be too high, causing some real bottlenecks to be missed. In this case, the dynamic threshold can be decreased. Thus, by dynamically updating the dynamic threshold based on the bottleneck occurrence frequency in historical scheduling data, the threshold can be adaptively adjusted with the system's operating status, avoiding identification bias caused by fixed thresholds when the system changes. When the bottleneck occurrence frequency deviates from expectations, timely adjustment of the threshold can effectively balance the sensitivity and specificity of bottleneck identification, reduce misjudgments of non-bottleneck nodes and omissions of real bottleneck nodes, thereby ensuring the accurate allocation of subsequent optimization resources and improving the adaptability and optimization efficiency of the scheduling system in dynamic environments.

[0078] For example, a sliding window can be set up to count the most recent... M The number of task nodes that actually become bottlenecks in this scheduling process N bottleneck，actual And the number of key bottleneck nodes identified through bottleneck impact scores. N bottleneck，identified .like N bottleneck，actual > N bottleneck，identified If the threshold is ×1.2, it indicates that too few key bottleneck nodes have been identified, and the threshold needs to be lowered; if N bottleneck，actual < N bottleneck，identified If the value is ×0.8, it indicates that too many critical bottleneck nodes have been identified, and the threshold needs to be increased. Optionally, the adjustment step size can be a preset small value, such as 0.01, etc., and this invention does not limit this.

[0079] Step 103: Map the optional scheduling states corresponding to the key bottleneck nodes to qubits; After identifying the critical bottleneck nodes, the scheduling scheme for these nodes needs to be optimized. The scheduling problem for critical bottleneck nodes can be formalized as a combinatorial optimization problem, where each critical bottleneck node can have multiple optional scheduling states (e.g., different start times, resource allocation patterns, etc.). To leverage the global search capability of quantum annealing, these discrete optional states can be mapped to qubits. Qubits are the basic information units in quantum computing; unlike classical bits which are in a 0 or 1 state, qubits can be in a |0 state. and |1 The superposition state, i.e., |ψ =a∣0 +b∣1 Where a and b can be complex magnitudes, satisfying |a| 2 +∣b∣ 2 =1.

[0080] During quantum annealing, the state of each qubit is in a strong superposition state in the early stage of annealing (e.g., ...). |0 +∣1 Subsequently, driven by an external magnetic field and the interacting Hamiltonian, it gradually evolves into the classical ground state (i.e., |0). or |1 This corresponds to a specific binary value.

[0081] In some feasible implementations, the key bottleneck nodes include a first bottleneck node with a binary selectable state and a second bottleneck node with a multi-value selectable state. For the first bottleneck node, a direct mapping using a single qubit is employed, with the two ground states of the qubit corresponding to the binary selectable states. For the second bottleneck node, binary encoding or one-hot encoding is used, employing a combination of multiple qubits to represent each selectable state. When using one-hot encoding, a penalty term is introduced into the target energy function to constrain multiple qubits corresponding to the same key bottleneck node to have only one active state at any given time. By using different qubit mapping methods for bottleneck nodes with binary and multi-value selectable states, the quantized expression of the scheduling state can adapt to various decision-making scenarios, improving the flexibility of encoding and the utilization efficiency of qubits. For one-hot encoding, the introduction of a penalty term effectively constrains multiple qubits corresponding to the same node to have only one active state at any given time, ensuring that the solution generated during quantum annealing always satisfies the exclusivity constraint of the scheduling state, avoiding the occurrence of illegal solutions, and improving the feasibility and reliability of the optimization results.

[0082] For the first bottleneck node with two selectable states, such as two resource allocation modes (mode A or mode B), a direct mapping using a single qubit can be employed. Specifically, a single qubit can be used. q i This represents the possible states of the node. The two ground states of a qubit correspond to two possible states: q i =∣0 Corresponding to mode A, q i =∣1 Corresponding to mode B, etc.

[0083] For a second bottleneck node with multiple selectable states, such as a start time with mm selectable time intervals, two typical encoding methods can be used: binary encoding or one-hot encoding. Specifically, in the binary encoding method, the following can be used: log2m Each qubit is used for binary encoding, and each combination of qubits corresponds to a specific state. For example, when m=4, two qubits can be used ( q 1, q 2) indicates that the combination 00, 01, 10, and 11 correspond to four different start times. For binary encoding, the number of qubits required is relatively small.

[0084] Correspondingly, when the number of selectable states is small and clear distinction is required, one-hot encoding can be used. Each selectable state is assigned an independent qubit, and it is constrained that only one qubit is in the |1 state at any given time. State. For example, if a node has k resource allocation modes, then k qubits ( q 1, q 2,…, q k This indicates that a valid state is one bit that is 1 and the rest are 0. In one-hot encoding, the state can be clearly distinguished, easy to understand and constrain.

[0085] In some examples, it is assumed that the possible start times for the target critical bottleneck node i include three time periods: t1, t2, t3, etc., and that one-hot encoding is used with three qubits q. i,1 q i,2 q i,3 This indicates that if the final measurement result is |100 , indicating that t1 is selected; |010 Represents t2; |001 This represents t3.

[0086] To ensure that only one qubit is in an active state, a penalty term needs to be introduced into the subsequent target energy function. When using one-hot encoding, this can be achieved using the classical Hamiltonian. H C Add a penalty item, for example:

[0087] Here, P can be a large positive coefficient (i.e., a penalty coefficient) used to enable the system to choose a suitable combination. The penalty term can be zero if and only if only one qubit is 1; otherwise, the penalty term is positive, thereby increasing the energy of the system and eliminating illegal combinations during the optimization process.

[0088] After mapping all critical bottleneck nodes to their corresponding qubits, the superposition state of all qubits constitutes the state of the entire bottleneck system. For example, suppose there are a total of N Each of the key bottleneck nodes uses [a specific method / mechanism]. k i Encoding with qubits, the total number of energy bits is Accordingly, the system state of the bottleneck system can be represented as:

[0089] Among them, |x To represent a specific binary string (i.e., the computational ground state of all qubits), c x Let c be a complex number with magnitude ∑∣c x | 2 =1, this superposition state simultaneously contains all possible scheduling schemes, that is, the combination of all possible states of critical bottleneck nodes.

[0090] Step 104: Obtain the target energy function for quantum degeneracy evolution, and evolve the bottleneck system composed of the qubits according to the target energy function to obtain the optimized state of the key bottleneck node; After completing the qubit mapping, a target energy function can be constructed to quantify the merits of different scheduling schemes. This target energy function can encode the scheduling optimization objective (such as minimizing total completion time or maximizing resource utilization) and various constraints as a function of the qubit values.

[0091] In some feasible implementations, the objective energy function can be implemented using either a quadratic unconstrained binary optimization (QUBO) form or an Ising model form. The QUBO form can be:

[0092] Where, x i ∈{0,1} represents the classical values ​​of a quantum bit. a i The coefficients are linear. b ij It is a quadratic coefficient.

[0093] Accordingly, the Ising model can take the form of:

[0094] in, For Pauli Z operator, the corresponding value of the qubit (usually mapped to) =2 x i 1, i.e., |0 Corresponding +1, |1 correspond 1), For local magnetic fields, This represents the coupling strength.

[0095] The construction of the target energy function needs to be determined according to the specific scheduling optimization objective. For example, if the optimization objective is to minimize the total completion time, the completion time of each task can be expressed as a function of the qubit value, and the total completion time can be used as the energy term. If there is a resource capacity constraint, the excess resource usage can be added as a penalty term to the target energy function. This invention does not impose any restrictions on this.

[0096] After constructing the target energy function, the bottleneck system composed of qubits can be evolved to obtain the optimized state of the key bottleneck nodes. In some feasible implementations, the evolution process may include: initializing the bottleneck system composed of qubits into a quantum superposition state; obtaining the classical term corresponding to the target energy function and the driving term used to guide the quantum tunneling effect, and using the classical term and the driving term as the quantum annealing Hamiltonian; driving the evolution of the bottleneck system through the quantum annealing Hamiltonian, measuring the bottleneck system after the evolution to obtain the target classical value of the qubits; decoding the target classical value to obtain the optimized state of the key bottleneck node. Thus, by initializing the bottleneck system into a quantum superposition state, the system can include all possible scheduling schemes with equal probability weights in the early stage of evolution, laying the foundation for subsequent wide-area search. Then, the driving term in the quantum annealing Hamiltonian is used to introduce the quantum tunneling effect, enabling the system to cross the classical energy barrier with a certain probability, effectively escaping the local optimum trap, and thus exploring more fully in the solution space. Finally, by measuring and decoding the evolved system, the optimized state with the lowest corresponding energy is obtained, achieving efficient approximation of the global optimum in a complex solution space and improving the solution quality of the scheduling scheme.

[0097] In the evolution of the bottleneck system, it is first initialized as a quantum superposition state. In the early stages of annealing, the quantum fluctuation intensity is relatively large, and the system can usually be set as a uniform superposition state of all qubits. For example, each qubit is in a state of |+ state, that is At this point, the system includes all possible scheduling schemes with equal probability weights.

[0098] After initialization to a quantum superposition state, a corresponding quantum annealing Hamiltonian can be constructed to drive the quantum annealing process. This quantum annealing Hamiltonian can be: H(t) = H C + Γ(t)H Q in, H C It can be the classical term corresponding to the objective energy function, which encodes the optimization objective and constraints; H Q This can be used as the driving Hamiltonian to introduce the quantum tunneling effect, and it can be taken as:

[0099] in, For Pauli X operator; Γ (t) represents the quantum noise intensity (or tunneling intensity) as a function of time, in the early stages of annealing. Γ (0) is relatively large, and quantum effects dominate. It then gradually decays to zero, causing the system to eventually evolve into the classical ground state.

[0100] After constructing the quantum annealing Hamiltonian, the bottleneck system can be driven to evolve using this quantum annealing Hamiltonian. The evolution process follows the Schrödinger equation, i.e.:

[0101] In practical quantum annealing hardware (such as the D-wave system), the evolution process can be realized through physical adiabatic quantum computation, that is, the system starts from the initial Hamiltonian. H Q Starting from the ground state, the Hamiltonian is slowly transformed into the final Hamiltonian. H C In this process, according to the adiabatic theorem, if the change is slow enough, the system will always remain in the instantaneous ground state, eventually reaching... H C The ground state is the optimal solution to the corresponding optimization problem.

[0102] After the evolution is complete, the bottleneck system can be measured, and the measurement can cause the superposition state to collapse to a definite computational ground state |x. This yields the classical values ​​of all qubits (i.e., binary strings of 0s and 1s), which correspond to a specific scheduling scheme. Next, the measured classical values ​​can be decoded to reconstruct the optimized state of each critical bottleneck node. Optionally, the decoding process can be the inverse of the encoding process; for example, for nodes using one-hot encoding, the measurement result is |010. This indicates that the second optional time period has been selected; for nodes using binary encoding, the binary string needs to be converted to a decimal number and then mapped to the corresponding optional state.

[0103] Optionally, during quantum annealing, the solution obtained from a single annealing may not be the globally optimal solution. Therefore, in this embodiment of the invention, a strategy of multiple independent annealing processes can be implemented to obtain a better solution. Specifically, the bottleneck system is driven by the quantum annealing Hamiltonian to undergo multiple independent quantum annealing evolutions. Each evolution obtains a set of initial classical values ​​for a set of qubits and the target energy function value corresponding to the initial classical values. The set of initial classical values ​​with the smallest target energy function value is selected as the target classical value.

[0104] In the specific implementation, a parameter can be set. R (e.g., R=1000, etc.) indicates that R independent annealing runs are performed. Each run starts from the same initial state (uniform superposition state) and goes through the same annealing scheduling function. Γ (t), but due to quantum fluctuations and environmental noise, the final classical solution obtained from each run may differ. The solution obtained during the annealing process is collected. R Each solution, and the energy value corresponding to each solution. E (x)= x∣ H C |x Then, the solution with the lowest energy is selected as the optimal solution. By performing multiple independent annealing processes, the probability of finding the global optimal solution can be effectively increased.

[0105] In practical quantum annealing hardware, a single task can be set to anneal multiple times (called the "num_reads" parameter). The hardware will automatically return multiple samples and the energy of each sample at the same time, allowing the user to select the sample with the lowest energy as the final result.

[0106] Furthermore, to improve the convergence speed and solution quality of the quantum annealing process, annealing parameters can be dynamically adjusted based on the real-time state of the bottleneck system during evolution. Optionally, during the evolution of the bottleneck system, local energy change information, historical optimization success rate, and conflict information with neighboring nodes of key bottleneck nodes are acquired. Then, the optimization stagnation level corresponding to the key bottleneck node is determined using the local energy change information, and the conflict level is determined using the conflict information. Finally, the dynamic attention weight of the key bottleneck node is calculated using the optimization stagnation level, conflict level, and historical optimization success rate. The conflict level can characterize the resource contention and time constraint tightness between bottleneck nodes, while the dynamic attention weight can assess the difficulty and urgency of each bottleneck region. Based on these two factors, real-time quantitative perception of the bottleneck node's optimization state can be achieved, providing a fine-grained decision-making basis for subsequent differentiated adjustments to annealing parameters.

[0107] Furthermore, after obtaining the dynamic attention weights and conflict levels, the annealing temperature can be dynamically adjusted according to these weights and conflict levels, and the quantum noise intensity can be dynamically adjusted according to the dynamic attention weights and optimization stagnation levels. By acquiring the local energy changes, conflict information, and historical optimization success rates of key bottleneck nodes in real time during the evolution process, the system can dynamically perceive the optimization progress and mutual constraints of each node, providing multi-dimensional real-time basis for parameter adjustment. At the same time, calculating the dynamic attention weights based on this information can quantify the importance and urgency of each node in the current optimization stage, making subsequent parameter adjustments more targeted. Adjusting the annealing temperature according to the conflict level and the quantum noise intensity according to the optimization stagnation level respectively enables the system to strengthen local fine-grained search when node conflicts are severe and enhance the quantum tunneling effect to promote global exploration when optimization stagnates, thereby achieving adaptive dynamic balance of annealing parameters and effectively improving the convergence speed and solution quality of the quantum annealing process.

[0108] Among them, the annealing temperature is used to control the probability of accepting inferior solutions during the evolution of the bottleneck system, and the quantum noise intensity is used to control the strength of the quantum tunneling effect during the evolution of the bottleneck system.

[0109] For information on local energy changes, during the evolution process, intermediate measurements can be performed on the bottleneck system at fixed time intervals (or iteration steps, etc.) to record the local energy contribution of each key bottleneck node. For node i, its local energy Ei can be obtained from the global solution.

[0110] in, It can be an item that depends only on the state of node i itself. This can be the interaction term between node pairs. Furthermore, the local energy contribution of node i can be defined as:

[0111] This makes the sum of the local energies of all nodes equal to the total energy.

[0112] Furthermore, the degree of optimization stagnation can be used to measure whether a node has stalled during the optimization process. Criteria for determining optimization stagnation include, but are not limited to: the energy decrease rate approaching zero; and the node... i Local energy E i It remains essentially unchanged through multiple annealing iterations, i.e., Δ E i ≈0; Solution space exploration stalled: node iThe state repeatedly remains at the same local optimum during multiple annealing processes, failing to break out of the current region to explore other possible solutions; energy fluctuations are stable but show no downward trend: although there are slight fluctuations in energy, the long-term average does not decrease, indicating that the system is confined to the vicinity of a local optimum, etc.

[0113] In practical implementation, the degree of stagnation can be quantified by calculating the local energy decrease rate of node i in the most recent K measurements. The formula for calculating the energy decrease rate is as follows:

[0114] in, This can be the time step between adjacent records. Continuously below a preset threshold (e.g., 10) -3 When ), the node can be determined. i There is optimization stagnation, and the degree of stagnation can be set to the value 'stagnation'. i =1 norm ( ), where norm can be a normalization function.

[0115] Conflict information can be raw, multi-dimensional data collected from the current scheduling state of the bottleneck system to measure the incompatibility or competition intensity between key bottleneck nodes. This conflict information can include: resource competition indicators: describing the competition among nodes for scarce resources, such as the node's demand for various resources, the available capacity of resources, and the number of other nodes competing for the same resource simultaneously; temporal tightness indicators: describing the strength of time constraints between a node and its predecessor / successor tasks, such as the reciprocal of relaxation time and the tightness of dependencies; logical dependency indicators: describing the mandatory synchronization requirements between nodes due to input-output relationships, such as data timeliness requirements and the degree of coupling between tasks; and multi-resource composite indicators: describing the mutual constraints between resources when a node simultaneously requires multiple resources.

[0116] Accordingly, conflict information can be used to determine the degree of conflict corresponding to key bottleneck nodes. The degree of conflict can be used to measure the incompatibility or competition intensity between nodes and other nodes in the scheduling scheme.

[0117] In some feasible implementations, the conflict type between the critical bottleneck node and its neighboring nodes is determined. The conflict type includes one or more of the following: resource competition conflict, temporally tight coupling conflict, logical dependency conflict, or multi-resource composite conflict. The conflict degree is generated according to the conflict type. It is determined whether the rate of decrease of the local energy of the critical bottleneck node in multiple consecutive evolutions is lower than a preset threshold. If so, it is determined that the critical bottleneck node has optimization stagnation, and the corresponding optimization stagnation degree is generated.

[0118] In specific implementations, conflict types include, but are not limited to, the following: Resource contention conflict: Multiple tasks compete for the same scarce resource within the same time period, and the resource capacity is insufficient to meet all demands simultaneously. For example, three machines simultaneously require the same critical device, but the device can only serve one task, causing two tasks to wait.

[0119] Tightly coupled timing conflicts: There are strict sequential constraints between tasks, and the relaxation time is extremely small (or even zero), so that any delay in any task will immediately propagate to subsequent tasks. For example, task A must be completed before task B starts, but the available time window for A is only 1 minute earlier than the latest start time of B, leaving almost no buffer.

[0120] Logical dependency conflict: The output of one task is the input of another task, and the input task has extremely high requirements for the timeliness or completeness of the data, which means that the two must be strictly synchronized. For example, task A produces a semi-finished product, and task B immediately begins processing it. If A has even a slight deviation, task B cannot proceed.

[0121] Multi-resource complex conflict: A single task requires multiple resources simultaneously, and these resources are themselves in a state of high competition, forming a "resource chain" conflict. For example, a task needs to occupy CPU, memory, and network bandwidth at the same time, and all three are close to full load.

[0122] Optionally, the quantification of conflict intensity can be based on resource conflict intensity, temporal proximity, and overall conflict severity. Specifically: Resource conflict intensity: For each resource r, count the number of other nodes competing for the resource with node i at the same time, and consider resource demand and capacity. The calculation formula can be as follows:

[0123] in, R It can be a collection of all resources in the system, including various constrained resources such as equipment, manpower, and materials; demand i,r It can be a node i (i.e., task) i Corresponding resources r The required quantity, such as the required equipment hours, manpower hours, and material quantity; capacity r The total available capacity of resource r, such as the total available machine hours of equipment, the total available man-hours of personnel, the maximum inventory of materials, etc. Nr overlap can be a node i Use resources within the same time period r The number of other task nodes, and the number of nodes that can be retrieved during this time period. i The expected execution time window;Nr "total" can represent all resources that need to be used within the currently considered time window. r The total number of task nodes.

[0124] During the calculation process, for each resource r, the node is first calculated. i The proportion of this resource used Then multiply by the percentage of nodes competing for that resource during the same period. Finally, sum all the resources. The larger the value, the more intense the resource competition faced by the node, and the higher the possibility of it becoming a bottleneck.

[0125] Temporal density: This measures the degree of conflict between node i and its predecessor / successor tasks due to time constraints. The formula for its calculation is:

[0126] in, It can be a node i The set of all predecessor task nodes, that is, the set of nodes that must be on the node i Tasks to be completed before starting; The set of all successor task nodes of node i, that is, the tasks that can only begin after node i is completed; It can be used for the predecessor mission j To the current task i The relaxation time is defined as =LST i EFT j LST i For the task i Latest start time, EFT j For the task j The earliest completion time; the smaller this value, the better the task. j The more easily the delay propagates to the task. i ; It can be from the current task i to the successor task. j The relaxation time can be defined as... =LST j EFT i The smaller the value, the stronger the task. i The more easily the delay propagates to the task. j ; It can be a very small positive number (e.g., 10) 6) Used to avoid division by zero errors when the relaxation time is zero.

[0127] During the calculation, for each task that has a direct dependency on node i, the reciprocal of its relaxation time is taken, and the sum is used to obtain the temporal tightness. The smaller the relaxation time and the larger the reciprocal, the tighter the time constraints and the stronger the conflicts.

[0128] After obtaining the resource conflict intensity and time tightness, the resource conflict intensity and time tightness can be fused to obtain a scalar value in the interval [0,1].

[0129] in, This can be the value after normalizing the resource conflict intensity. Because the original... They may have different dimensions and ranges of values, and need to be mapped to the [0,1] interval through normalization (e.g., min-max normalization or mean-variance normalization); It can be the value after time series tightness normalization, which is also mapped to the [0,1] interval.

[0130] α can be a weighting coefficient, ranging from [0,1], used to balance the relative importance of resource conflicts and timing conflicts in the overall conflict level. The value of α can be adjusted according to the actual scheduling scenario. For example, a larger value (such as 0.7) can be used in scenarios with high resource pressure, while a smaller value (such as 0.3) can be used in scenarios with strict time constraints. If not specifically specified, the default value of 0.5 can be used.

[0131] Furthermore, to facilitate a more intuitive assessment of the severity of a conflict in practical applications, the overall conflict severity can be assessed. Divided into multiple levels, for example: General conflict: 0≤ <0.3 indicates that there is only a small amount of resource or timing overlap between nodes, which can be easily resolved through local adjustments and has little impact on optimization; Moderate conflict: 0.3≤ A value <0.7 indicates significant resource competition or tight timing constraints, requiring a certain degree of global coordination and potentially becoming an obstacle to local optimization. Severe conflict: 0.7≤ A value of ≤1 indicates high coupling between nodes, intense resource contention, or almost no time slack, which can easily lead to scheduling bottlenecks and requires key intervention.

[0132] Optionally, when the conflict level exceeds 0.7, it can be determined that key intervention is required.

[0133] Furthermore, the historical success rate of optimization can be the proportion of nodes that have been successfully optimized in multiple optimizations throughout the historical process. After obtaining the optimization stagnation and conflict levels based on the aforementioned process, dynamic attention weights for key bottleneck nodes can be calculated based on these factors, along with the historical success rate. The combined effect of these three factors allows the calculated weights to accurately quantify the optimization urgency of each node. Based on these weights, the annealing parameters are dynamically adjusted, enabling optimization resources to adaptively tilt towards nodes that are "difficult to optimize, have high conflict, and low success rates," thereby improving the global convergence efficiency and solution quality of the quantum annealing process. Specifically, dynamic attention weights can be used to assess the importance or urgency of each key bottleneck node in the current optimization process. In some exemplary calculation formulas, the formula can be:

[0134] in, To optimize the degree of stagnation, v i For the degree of conflict, c i To optimize the success rate for historical data, u σ and b are learnable parameters, and σ is an activation function (such as Sigmoid). Optionally, these dynamic attention weights can be used for subsequent parameter tuning.

[0135] Based on the dynamic attention weights calculated in the aforementioned process, key parameters in the annealing process can be adjusted, such as adjusting the annealing temperature and / or quantum noise intensity.

[0136] For annealing temperature T:

[0137] For quantum noise intensity Γ :

[0138] in, Based on the annealing temperature, Based on the quantum noise intensity, β and γ For adjustment coefficients, N The number of critical bottleneck nodes.

[0139] When severe conflicts are detected among certain nodes (such as...) When the attention weight is high (large), Enlargement, leading to Compared to The annealing temperature decreases the probability of accepting inferior solutions, making the system more inclined to perform local fine-grained searches. When optimization stagnation is detected (e.g., When (large), Enlargement, leading to Compared to Increasing the intensity of quantum noise can enhance the quantum tunneling effect, helping the system escape local optima and improve global exploration capabilities. Through this dynamic adjustment mechanism, the adaptive allocation of annealing resources can be effectively achieved, enabling the algorithm to intelligently balance global exploration and local utilization, thereby improving optimization efficiency and solution quality.

[0140] Optionally, the above process primarily focuses on optimizing key bottleneck nodes. However, scheduling problems involve multiple time scales, and there is coupling between optimization objectives and constraints at different levels. To ensure the consistency of optimization results across different time scales, a multi-scale collaborative optimization mechanism is introduced in this embodiment. In some feasible implementations, the time scale levels include at least a first time scale level and a second time scale level. The first time scale level corresponds to a higher-level optimization model, and the second time scale level corresponds to a lower-level optimization model. For example, the first time scale level can be weekly, corresponding to a higher-level optimization model (such as a weekly scheduling model), while the second time scale level can be daily or hourly, corresponding to a lower-level optimization model (such as a daily scheduling model or an hourly scheduling model). The higher-level optimization model is responsible for formulating macro-level plans over longer periods, such as long-term allocation of key resources and setting major milestones. The lower-level optimization model is responsible for generating fine-grained scheduling schemes at shorter time scales, requiring consideration of both real-time performance and consistency with the higher-level strategy.

[0141] In practical implementation, the optimization results of the high-level optimization model need to be transmitted to the low-level optimization model to ensure that local scheduling is aligned with the global strategy. Specifically, the optimization results output by the high-level optimization model are first obtained. The optimization results include at least a resource allocation scheme and node completion deadlines. The resource allocation scheme can be a plan for allocating key resources in different time periods, such as a key piece of equipment being used for a maximum of 8 hours per day from Tuesday to Thursday. The node completion deadline can be the deadline for major milestones, which can carry a dynamically adjustable initial slack. The slack can be defined as the time difference between the node completion deadline and the expected completion time, used to characterize the degree of leniency of the deadline: the larger the slack, the more sufficient the time margin and the looser the constraint; the smaller the slack, the greater the risk of task delay. For example, if the project must be completed before Friday, and the expected completion time is Thursday, the slack could be 1 day, etc. This invention does not impose any limitations on this.

[0142] When optimizing a low-level optimization model, the solution space can be constrained based on resource availability periods and capacity in the resource allocation scheme. Within this constrained solution space, a penalty term related to node completion deadlines can be added to the objective function of the low-level optimization model. This penalty term increases the objective function value when a task delays a node's completion deadline, and its intensity is determined by the current relaxation level corresponding to the node's completion deadline. Optionally, the penalty level can also be determined by both the current relaxation level corresponding to the node's completion deadline and a learnable weight coefficient.

[0143] In this approach, the available resource time period and available resource capacity in the resource allocation scheme can be used as hard constraints. That is, the low-level optimization model must adhere to these resource limitations when generating the scheduling scheme. For example, a resource capacity upper limit can be set in the daily model. r,t This is equivalent to the high-level allocation value, and resource usage in any scheduling scheme cannot exceed this upper limit. Simultaneously, node completion deadlines can be treated as soft objectives, embedded as a penalty term in the objective function of the low-level optimization model. This means adding a penalty term related to node completion deadlines to the objective function of the low-level optimization model, thereby guiding the optimization scheme to proactively avoid delay risks. Specifically, when the slack is large, the penalty intensity increases slowly, allowing for a certain degree of flexibility; when the slack is small (i.e., the deadline is tight), the penalty intensity increases rapidly with delay, using strong constraints to guide the optimization scheme to proactively avoid delay risks. This penalty term works synergistically with learnable weight coefficients, enabling the low-level optimization model to flexibly accommodate high-level strategic objectives on the basis of hard constraints.

[0144] Alternatively, the objective function of the low-level optimization model can be written as:

[0145] in, This can be a penalty related to the node completion deadline; the value of this item increases when the task is close to or may be delayed from the deadline.

[0146] Accordingly, real-time deviations generated during low-level execution need to be fed back to higher levels to trigger adjustments in the high-level model. Specifically, during the execution of the low-level optimization model, the actual execution parameters corresponding to the currently executed task are collected in real time, and the deviation between the actual execution parameters and the preset planned values ​​is calculated. The actual execution parameters can be quantitative data reflecting the true progress of the task, collected in real time from the real physical system (such as manufacturing execution systems, equipment sensors, logistics tracking systems, etc.) during the scheduling process. These parameters may include the task's actual start time, actual end time, actual execution duration, actual waiting time, resource usage, resource usage period, actual resource consumption, and actual completion percentage. The planned values ​​can refer to the target data pre-defined for each task node in the scheduling scheme generated by the low-level optimization model, serving as the execution benchmark. These include the planned start time, planned end time, planned execution duration, planned slack time, computational resource allocation, planned resource usage period, and planned resource consumption. This invention does not limit these parameters.

[0147] If a deviation triggers a penalty term, the trigger frequency and / or magnitude of the penalty term are obtained and uploaded as feedback signals to the higher-level optimization model. During this process, if a penalty term is penalized, it indicates that the actual execution is approaching or has reached the node completion deadline, suggesting that the current high-level plan may be too restrictive or inaccurate. Therefore, upon receiving the feedback signal, the higher-level optimization model can respond by adjusting the slack of node completion deadlines in subsequent optimization cycles, and / or adjusting the weight coefficients of penalty terms in the lower-level optimization model.

[0148] In the specific implementation, when a penalty item is detected to be triggered, the trigger frequency f and trigger magnitude a corresponding to that penalty item can be obtained. Here, the trigger frequency refers to the number of times the penalty item is triggered within a unit of time (or within a statistical period), reflecting the frequency of delays in node completion deadlines; the trigger magnitude refers to the average or cumulative value of the penalty item at each trigger, reflecting the severity of the delay.

[0149] Specifically, the trigger frequency and trigger amplitude are compared with preset frequency and amplitude thresholds, respectively. Based on the comparison results, adjustments can be made in the following manner: High frequency and high amplitude (i.e., f≥F) high And a≥A high The error message indicates that the current plan is too tight, resulting in frequent and severe delays. In this case, a significant increase in buffer time is needed. Specific measures include: increasing the slack in node completion deadlines to allow more time; and simultaneously increasing the weight coefficient of the penalty term to strengthen the punishment for delays and guide lower-level optimization models to pay more attention to these deadlines.

[0150] High frequency, low amplitude (i.e., f≥F) high But a low This indicates that although penalties are frequently triggered, the delays caused by each trigger are not severe. The main problem here is an overly tight schedule, leading to frequent minor delays. The slack in the node completion deadlines can be appropriately increased to absorb these minor fluctuations; while the weighting coefficients of the penalty items can remain unchanged or be slightly adjusted.

[0151] Low frequency, high amplitude (i.e., f) <F low But a≥A high） This indicates that the trigger frequency is low, but each trigger causes significant delays. The overall plan may be lenient, but there are individual high-risk points. The weighting coefficient of the penalty items should be increased to strengthen the constraint on this timeframe; the slackness can remain unchanged.

[0152] Low frequency, low amplitude (i.e., f) <F low And a low This indicates that the plan is executing well, with penalties being triggered very rarely and having a minor impact. In this case, the plan can be tightened appropriately, i.e., reducing the slack of node completion deadlines or reducing the weight coefficient of penalty items, to improve scheduling efficiency.

[0153] Among them, F high and F low These are the high and low thresholds for the frequency, A. high and A low These are the high and low thresholds for the amplitude, respectively. Optionally, the threshold values ​​can be preset based on historical statistical data and business needs, and can be dynamically adjusted; this invention does not impose any limitations on this.

[0154] By implementing the aforementioned adjustment rules and analyzing both frequency and amplitude dimensions, a refined response to feedback signals is achieved. This allows the high-level optimization model to adaptively adjust planning parameters based on actual execution. By dividing the time scale into high-level and low-level layers and constructing corresponding optimization models for each, the scheduling system can achieve hierarchical decision-making and collaborative optimization at different time granularities. The high-level optimization model focuses on macro-level long-term planning, providing strategic guidance for global resource allocation and key node objectives. The low-level optimization model, based on this, generates fine-grained scheduling schemes, balancing real-time response with high-level constraints. Furthermore, this hierarchical modeling and collaborative mechanism effectively solves the problem of fragmented optimization objectives across different time scales in traditional methods, ensuring consistency between local scheduling and global strategy, and improving the overall coordination capability of the scheduling system in multi-scale coupled scenarios.

[0155] ​​Furthermore, the high-level optimization model can perform periodic re-optimization according to a preset time period (such as every 24 hours), or trigger re-optimization when the deviation between the actual execution parameters and the planned values ​​exceeds a preset re-optimization threshold. During re-optimization, the optimization algorithm is rerun with the current actual state of the system as the initial state, generating new high-level optimization results.

[0156] Optionally, to further improve the system's adaptability, this embodiment of the invention also introduces an uncertainty prediction mechanism based on a time series model. Specifically, the uncertainty of the system can be predicted using a time series model to obtain dynamic weight factors. Then, the weight ratios of different objective items in the objective function of the low-level optimization model are adjusted using the dynamic weight factors. The time series model is a Long Short-Term Memory (LSTM) network, whose input features include one or more of resource utilization, number of tasks, abnormal event encoding, task queue length, or time encoding. By predicting system uncertainty through the LSM network, it can anticipate potential resource fluctuations, task delays, or abnormal events based on historical execution data and current state characteristics, providing a forward-looking decision-making basis for the low-level optimization model. The predicted dynamic weight factors are used to adjust the weight ratios of different objective items (such as efficiency, robustness, and urgency) in the objective function in real time, allowing the optimization focus to adaptively shift with changes in the system environment. When an increase in uncertainty is predicted, the weight of the robustness objective is automatically increased, making the generated scheduling scheme more conservative in order to absorb fluctuations; conversely, it focuses more on efficiency, thus achieving a dynamic balance between the flexibility and robustness of the scheduling scheme in a dynamic environment.

[0157] For Long Short-Term Memory (LSTM) networks, the core update mechanism can be described by the following formula:

[0158]

[0159]

[0160]

[0161]

[0162]

[0163] in, x t For the input feature vector, h t It is in a hidden state (short-term memory). C t For cellular state (long-term memory). ft , i t , o t The outputs of the forget gate, input gate, and output gate are respectively... W and b These are learnable parameters.

[0164] The output of a Long Short-Term Memory (LSTM) network (which can be the hidden state) ht After passing through a fully connected layer, corresponding predicted values ​​can be generated, such as the probability of future task delays and resource conflict indices. These predicted results, after normalization or transformation using a specific function, can yield a dynamic weighting factor λ(t). λ(t) can be a scalar used for overall adjustment, or a vector used to adjust the weights of multiple target items separately.

[0165] For example, if the long short-term memory network predicts high uncertainty in the future (such as a high probability of equipment failure), then λ(t) will increase the weight of the robustness objective, making the scheduling more conservative; if the system is predicted to be stable, then λ(t) will increase the weight of the efficiency objective, pursuing a more compact schedule.

[0166] Through the above process, the corresponding dynamic weighting factor is obtained through uncertainty prediction. It can be used to adjust the weight ratio of different objective terms in the objective function of the low-level optimization model, thereby realizing the adaptive adjustment of the optimization center.

[0167] Step 105: Schedule according to the optimized state and generate a scheduling plan for the scheduled task.

[0168] After obtaining the optimized state of key bottleneck nodes, a final scheduling scheme can be generated based on these optimized states. This generated scheduling scheme can cover the detailed arrangements of all task nodes at different time scales, thus enabling scheduling based on the optimized results. This achieves efficient collaborative optimization in complex scheduling scenarios with multiple scales, high dimensions, and multiple constraints, improving solution quality and computational efficiency, and ensuring that the generated scheduling scheme can balance global consistency and global feasibility across different time scales.

[0169] In some feasible implementations, based on the optimization status of key bottleneck nodes, the start and end times, resource allocation, and dependencies between tasks at different time scales can be determined for each task node according to its optimization status. Then, the start and end times, resource allocation, and dependencies are output in the form of structured data and / or visual charts to generate a scheduling plan for the scheduled tasks. By transforming the optimization status of key bottleneck nodes into specific start and end times, resource allocation, and dependencies for each task node at different time scales, a complete and executable multi-scale scheduling plan is generated. Outputting the plan in the form of structured data and visual charts facilitates data exchange and integration with other systems, and also allows managers to intuitively understand and monitor the scheduling plan, thereby improving the practicality and operability of the scheduling plan.

[0170] The start and end times can be the start and end times of each task node at different time scales. For example, at the weekly level, the start and end times of the weekly plan can be output; at the hourly level, the operation time down to the minute can be output. Resource allocation can be the resources allocated to each task node during execution, including resource type, resource quantity, and time period occupied. Task dependencies can be the sequence and logical relationships between tasks, ensuring the executability of the scheduling plan.

[0171] Furthermore, the output format can be structured data, such as JSON or XML format, to facilitate data exchange with other systems; or it can be visual charts, such as multi-level Gantt charts, to facilitate managers to intuitively view and adjust scheduling plans, etc. This invention does not limit this.

[0172] Furthermore, since the optimization status of critical bottleneck nodes directly determines the scheduling of these nodes, the original scheduling plan can be used for non-critical bottleneck nodes, or adjustments can be made according to the optimization results of critical bottleneck nodes. In this way, the entire scheduling scheme is optimized at critical nodes while maintaining consistency with the original plan.

[0173] After generating the scheduling scheme, cross-level consistency checks can be performed to ensure that there are no conflicts in the scheduling arrangements between different time scales. Optionally, by performing cross-level consistency checks on the scheduling scheme, conflicts in resource allocation or task dependencies between different time scales can be identified; if a conflict is identified, conflict resolution steps are executed to adjust the start and end times or resource allocation of relevant task nodes to obtain an executable scheduling scheme. Specifically, the content of cross-level consistency checks includes, but is not limited to: Resource consistency: Check whether the resources allocated in the higher-level plan are consistent with the resource usage in the lower-level plan. For example, in the weekly plan, the maximum usage time of a certain device on Tuesday is 8 hours, while in the daily plan, the total usage time of the same device on Tuesday exceeds 8 hours.

[0174] Time Consistency: Check whether the milestone deadlines in the high-level plan are consistent with the task completion times in the low-level plan. For example, in the weekly plan, the project must be completed by Friday, while in the daily plan, all tasks must be completed by Friday.

[0175] Dependency consistency: Check whether cross-level task dependencies are satisfied. For example, if a weekly task is broken down into multiple daily subtasks, check whether the dependencies between these subtasks are consistent with the logic of the weekly task.

[0176] Through the above consistency checks and conflict resolution, an executable and conflict-free scheduling scheme can be obtained to ensure the stability of the scheduling scheme's execution.

[0177] Furthermore, in this embodiment of the invention, a closed-loop learning mechanism can be introduced to continuously optimize the models and parameters of each stage through feedback from actual execution data. Optionally, by collecting actual execution data corresponding to the scheduling scheme and obtaining planned execution data corresponding to the scheduling scheme, the actual execution data and planned execution data are compared to obtain corresponding difference information. Then, the difference information is used as feedback information, and at least one of the following update operations is performed based on the feedback information: updating node features, adjusting the dynamic threshold for screening key bottleneck nodes, adjusting the target energy function, and updating the parameters of the multi-scale graph network.

[0178] Actual execution data can be collected from data sources such as production execution systems and equipment monitoring systems, including the actual start time, actual end time, actual resource usage, and any abnormal events that occurred. Planned execution data can be the data from the generated scheduling scheme. By comparing the differences between actual and planned execution data, at least the following feedback information can be obtained: Bottleneck identification accuracy feedback: If a task is identified as a non-bottleneck node, but becomes a bottleneck in actual execution (causing delays in subsequent tasks), it indicates that the bottleneck identification model may have missed the target and the node features need to be updated or the dynamic threshold adjusted.

[0179] Optimization effect feedback: If the optimization of the key bottleneck node does not bring the expected efficiency improvement in actual execution, it may indicate that the target energy function is not set accurately enough, and the energy term coefficient needs to be adjusted or new constraints need to be introduced.

[0180] Uncertainty feedback: If unplanned anomalies occur frequently during actual execution, it indicates that the uncertainty prediction model needs to be updated, and the LSTM model can be retrained with new data.

[0181] Based on the feedback information mentioned above, node features can be updated, dynamic thresholds adjusted, target energy functions adjusted, and multi-scale graph network parameters updated. For example, node features can be added or adjusted based on new bottleneck influencing factors discovered during actual execution; the threshold for selecting key bottleneck nodes can be dynamically adjusted based on the actual frequency of bottleneck occurrence; coefficients in the target energy function can be adjusted or new penalty terms can be introduced based on optimization effect feedback; and the structure or edge features of the graph network can be updated based on new dependency relationships or resource conflict patterns discovered during actual execution. Thus, through a closed-loop learning mechanism, it can evolve from a static optimization tool into an intelligent system that can grow and adapt dynamically with the scheduling environment, continuously improving the quality and adaptability of scheduling solutions.

[0182] It should be noted that the embodiments of the present invention include, but are not limited to, the examples described above. It is understood that those skilled in the art can make further settings according to actual needs under the guidance of the ideas in the embodiments of the present invention, and the present invention does not limit such settings.

[0183] In this embodiment of the invention, for a scheduling task, a multi-scale graph network corresponding to the scheduling task is constructed. This multi-scale graph network includes task nodes at different time scale levels and dependency edges between task nodes. Next, node features of the task nodes are extracted, and task nodes are filtered based on these features to obtain key bottleneck nodes that meet certain conditions. The optional scheduling states corresponding to the key bottleneck nodes are mapped to qubits. Then, a target energy function for quantum degeneracy evolution is obtained, and the bottleneck system composed of qubits is evolved according to the target energy function to obtain the optimized state of the key bottleneck nodes. Finally, scheduling is performed based on the optimized state to generate a scheduling scheme for the scheduling task. Thus, by constructing a multi-scale graph network corresponding to the scheduling task, a unified model of the scheduling problem at multiple time granularities is achieved. It can capture the coupling relationship between tasks at different levels from a global perspective, laying the foundation for subsequent collaborative optimization. Then, based on node characteristics, task nodes are screened, which can accurately locate the core links that restrict the overall efficiency from massive tasks, avoid ineffective optimization of non-bottleneck nodes, and reduce computational complexity. After screening out key bottleneck nodes, the quantum tunneling effect of quantum annealing is used to enable the optimization process to cross the classical energy barrier with a certain probability, effectively escape the local optimum trap, and obtain a global approximate optimal solution. Then, based on the optimized results, scheduling is performed to obtain the corresponding scheduling scheme. It realizes efficient collaborative optimization in complex scheduling scenarios with multiple scales, high dimensions, and multiple constraints, improves the solution quality and computational efficiency, and enables the generated scheduling scheme to take into account global consistency and global feasibility at different time scales.

[0184] To enable those skilled in the art to better understand the technical solutions in the embodiments of the present invention, the following examples are provided for illustrative purposes: As an example, refer to Figure 2 The diagram illustrates a quantum computing optimization engine provided in an embodiment of the present invention. The quantum computing optimization engine can be used to achieve collaborative optimization of bottleneck nodes in multi-scale scheduling scenarios. The optimization engine takes qubit encoding as its core and achieves global optimization and adaptive adjustment of scheduling problems through mechanisms such as multi-scale task graph modeling, dynamic resource Hamiltonian construction, attention-guided parameter adjustment, multi-scale collaborative feedback, and reinforcement learning.

[0185] I. Multi-scale task graph modeling The optimization engine first performs multi-scale modeling of the scheduling tasks, constructing weekly and daily task graphs. The weekly task graph describes macroscopic task nodes and their dependencies over long periods, such as key resource allocation plans and major milestone nodes; the daily task graph focuses on fine-grained tasks over short periods, such as daily work orders and hourly operations. Through multi-scale task graph modeling, the complex scheduling problem is transformed into graph-structured data that can be processed within a quantum computing framework, providing a foundation for subsequent qubit encoding.

[0186] II. Quantum Bit Encoding Based on a multi-scale task graph, the optimization engine maps the optional scheduling states of task nodes (especially critical bottleneck nodes) to qubits. Qubit encoding is a core step in achieving problem quantization, and its specific mapping methods include: For nodes with binary selectable states, a single qubit is directly mapped, and the two ground states of the qubit correspond to two scheduling options respectively; For nodes with multiple possible states, binary encoding or one-hot encoding is used, and a combination of multiple qubits is used to represent each possible state. When using one-hot encoding, a penalty term needs to be introduced into the target energy function constructed subsequently to constrain multiple qubits corresponding to the same node to have only one active state at any given time.

[0187] By encoding with qubits, all possible scheduling schemes are represented as a superposition of multiple qubits, laying the foundation for the evolution of quantum annealing.

[0188] III. Constructing Dynamic Resource Hamiltonians The optimization engine constructs a dynamic resource Hamiltonian (i.e., the target energy function) based on the encoded qubit system. This Hamiltonian consists of two parts: Classic terms: These correspond to specific objectives of scheduling optimization, such as minimizing total completion time, maximizing resource utilization, and various constraints (such as resource capacity constraints and timing constraints). Driving term: Used to introduce the quantum tunneling effect, enabling the system to cross the classical energy barrier with a certain probability and avoid getting trapped in local optima.

[0189] The dynamic resource Hamiltonian not only includes a static optimization objective, but can also dynamically adjust the energy term coefficient based on real-time feedback information, thereby achieving adaptive optimization guidance.

[0190] IV. Adjustment of Attention Guidance Parameters During the quantum annealing evolution process, the optimization engine introduces an attention mechanism to dynamically adjust the annealing parameters. Specifically, it acquires real-time information on local energy changes of key bottleneck nodes, conflict information with neighboring nodes, and historical optimization success rates; based on this information, it calculates the dynamic attention weight for each node to quantify the importance and urgency of the node in the current optimization stage; it dynamically adjusts the annealing temperature according to the attention weight and the degree of conflict, and dynamically adjusts the quantum noise intensity according to the attention weight and the degree of optimization stagnation.

[0191] By adjusting parameters guided by attention, optimization resources can be adaptively tilted towards nodes that are "difficult to optimize and have high conflict", thereby improving the convergence speed and solution quality of the quantum annealing process.

[0192] V. Multi-scale Cooperative Feedback and Adaptive Optimization The optimization engine establishes a multi-scale collaborative feedback mechanism to achieve bidirectional interaction between high-level and low-level optimization models: Top-down transmission: High-level optimization results (such as weekly resource allocation schemes and milestone deadlines) are input into the low-level optimization model as hard constraints or soft objectives to ensure that local scheduling is aligned with the global strategy; Bottom-up feedback: Real-time deviations generated during low-level execution (such as task delays and resource conflicts) are uploaded to the high-level optimization model as feedback signals to trigger periodic re-optimization or parameter adjustments.

[0193] Through multi-scale collaborative feedback, the optimization engine can maintain global and local consistency in dynamic environments, achieving adaptive optimization adjustments.

[0194] VI. Strengthen Learning-Driven Learning To further enhance the adaptive capabilities of the optimization engine, a reinforcement learning mechanism is introduced to learn parameter adjustment rules online. The reinforcement learning model takes the current system state (e.g., task graph structure, node characteristics, real-time deviations) as input and optimization results (e.g., total completion time, resource utilization) as reward signals, learning the optimal annealing parameter adjustment strategy, threshold update rules, and collaborative feedback triggering conditions. Driven by reinforcement learning, the optimization engine can continuously improve its decision-making strategies from historical experience, adapting to the ever-changing scheduling environment.

[0195] VII. Real-time Response Optimization Based on the aforementioned mechanism, the optimization engine can perform real-time optimization responses to scheduled tasks. When a new scheduling request is received or a change in system state is detected, the optimization engine quickly initiates the quantum annealing evolution process, generating an optimized scheduling scheme within milliseconds. This real-time optimization response capability enables the system to cope with unexpected events such as emergency order insertions and equipment failures, improving the robustness and agility of the scheduling system.

[0196] 8. Output Layer of Multi-Scale Optimization Model The optimization engine ultimately generates an executable scheduling plan through the output layer of the multi-scale optimization model. The output includes: the start and end times of each task node at different time scales; the resource allocation plan (resource type, quantity, and time period); and the dependencies between tasks.

[0197] Output formats include structured data (such as JSON / XML format) and visual charts (such as multi-level Gantt charts), facilitating integration with other systems and manual monitoring.

[0198] IX. Feedback and Updates The optimization engine establishes a complete closed-loop learning mechanism. After the scheduling plan is executed, actual execution data (such as actual task start and end times, actual resource usage, and abnormal events) is collected and compared with the planned data to obtain discrepancy information. This discrepancy information serves as feedback signals to update the following: The structural or edge features of multi-scale task graphs; qubit encoding rules (such as the mapping method for adjusting optional states); coefficients or penalty terms of dynamic resource Hamiltonians; weight calculation rules for attention-guided parameter adjustment; policy networks of reinforcement learning models; trigger thresholds for collaborative feedback mechanisms.

[0199] Through feedback updates, the optimization engine can continuously learn from actual execution, constantly improve its performance, and evolve from a static optimization tool to a dynamic intelligent system.

[0200] Through the above technical solutions, the quantum computing optimization engine, with qubit encoding at its core, transforms the multi-scale scheduling problem into a combinatorial optimization problem solvable within the quantum annealing framework. Multi-scale task graph modeling ensures the completeness of the problem description; dynamic resource Hamiltonians construct a quantitative expression of the optimization objective and constraints; attention-guided parameter adjustment improves the convergence efficiency of quantum annealing; a multi-scale collaborative feedback mechanism guarantees global and local consistency; reinforcement learning-driven optimization enhances the system's adaptability; real-time optimization response meets the agility requirements of dynamic environments; and feedback updates enable continuous system evolution. Ultimately, this optimization engine can efficiently generate scheduling schemes that balance global optimum and local feasibility in complex scheduling scenarios, significantly improving the solution quality, computational efficiency, and robustness of the scheduling system.

[0201] It should be noted that, for the sake of simplicity, the method embodiments are all described as a series of actions. However, those skilled in the art should understand that the embodiments of the present invention are not limited to the described order of actions, because according to the embodiments of the present invention, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions involved are not necessarily essential to the embodiments of the present invention.

[0202] Reference Figure 3 The diagram illustrates a structural block diagram of a task scheduling device provided in an embodiment of the present invention, which may specifically include the following modules: Graph network construction module 301 is used to construct a multi-scale graph network corresponding to the scheduling task. The multi-scale graph network includes at least task nodes at the time scale level and dependency edges between the task nodes. The node filtering module 302 is used to extract the node features of the task nodes and filter the task nodes according to the node features to obtain key bottleneck nodes that meet the conditions. The state mapping module 303 is used to map the optional scheduling state corresponding to the key bottleneck node to a quantum bit; Evolution module 304 is used to obtain the target energy function for quantum degeneracy evolution, and to evolve the bottleneck system composed of the qubits according to the target energy function to obtain the optimized state of the key bottleneck node; The scheme generation module 305 is used to schedule according to the optimization status and generate a scheduling scheme for the scheduling task.

[0203] In some feasible implementations, the node filtering module 302 is specifically used for: The node features of the task node are aggregated to obtain the bottleneck impact score of the task node; Task nodes whose bottleneck impact score is greater than or equal to a preset dynamic threshold are designated as critical bottleneck nodes.

[0204] In some feasible implementations, the node filtering module 302 is specifically used for: Obtain a bottleneck identification model, which includes at least a graph attention layer and a fully connected layer; The attention weights between the task node and its neighboring nodes are calculated through the graph attention layer, and the node features of the neighboring nodes are weighted and aggregated using the attention weights to obtain the context-enhanced representation corresponding to the task node. The node features of the task node itself are fused with the context-enhanced representation and input into the fully connected layer to output the bottleneck impact score of the task node.

[0205] In some feasible implementations, the node characteristics include at least one or more of the following static or dynamic attributes: task duration, resource requirements, task priority, deadline, resource contention intensity, task delay risk, resource utilization, task complexity, historical bottleneck frequency, number of downstream tasks, resource conflict graph centrality, and current progress deviation.

[0206] In some feasible implementations, the critical bottleneck node includes a first bottleneck node with a binary selectable state and a second bottleneck node with a multi-value selectable state, and the state mapping module 303 is specifically used for: For the first bottleneck node, a direct mapping using a single qubit is employed, with the two ground states of the qubit corresponding to the binary selectable states. For the second bottleneck node, binary encoding or one-hot encoding is used, and a combination of multiple qubits is used to represent each possible state. When the one-hot encoding is used, a penalty term is introduced into the target energy function to constrain multiple qubits corresponding to the same critical bottleneck node to have only one active state at any given time.

[0207] In some feasible implementations, the evolution module 304 is specifically used for: The bottleneck system composed of the qubits is initialized to a quantum superposition state; Obtain the classical term corresponding to the target energy function and the driving term used to guide the quantum tunneling effect, and use the classical term and the driving term as the quantum annealing Hamiltonian; The bottleneck system is driven to evolve by the quantum annealing Hamiltonian, and the bottleneck system is measured after the evolution is completed to obtain the target classical value of the qubit. The classic target value is decoded to obtain the optimization state of the key bottleneck node.

[0208] In some feasible implementations, the evolution module 304 is specifically used for: The bottleneck system is driven to undergo multiple independent quantum annealing evolutions by the quantum annealing Hamiltonian. Each evolution obtains a set of initial classical values ​​for the qubits and the target energy function value corresponding to the initial classical values. The initial classical values ​​that minimize the target energy function value are selected as the target classical values.

[0209] Among some feasible implementation methods are: The information acquisition module is used to acquire local energy change information, historical optimization success rate, and conflict information with neighboring nodes of the key bottleneck node during the evolution of the bottleneck system. A stagnation determination module is used to determine the degree of optimization stagnation corresponding to the key bottleneck node using the local energy change information. A conflict determination module is used to determine the degree of conflict corresponding to the critical bottleneck node using the conflict information. The dynamic weight calculation module is used to calculate the dynamic attention weight of the key bottleneck node by using the optimization stagnation degree, the conflict degree, and the historical optimization success rate.

[0210] Among some feasible implementation methods are: An adjustment module is configured to dynamically adjust the annealing temperature according to the dynamic attention weight and the degree of conflict, and to dynamically adjust the quantum noise intensity according to the dynamic attention weight and the degree of optimization stagnation. The annealing temperature is used to control the probability of the bottleneck system receiving inferior solutions during its evolution, and the quantum noise intensity is used to control the strength of the quantum tunneling effect during the bottleneck system's evolution.

[0211] In some feasible implementations, the scheme generation module 305 is specifically used for: Based on the optimization status of the key bottleneck nodes, determine the start and end times, resource allocation, and dependencies between tasks for each task node at different time scale levels. Output the start and end times, resource allocation, and dependencies in the form of structured data and / or visual charts to generate a scheduling plan for the scheduled task.

[0212] In some feasible implementations, the time scale hierarchy includes at least a first time scale hierarchy and a second time scale hierarchy, wherein the first time scale hierarchy corresponds to a high-level optimization model, and the second time scale hierarchy corresponds to a low-level optimization model. The apparatus further includes: The result output module is used to obtain the optimization results output by the high-level optimization model. The optimization results include at least the resource configuration scheme and the node completion time limit. The penalty term determination module is used to constrain the solution space of the low-level optimization model according to the available resource time period and available resource capacity corresponding to the resource configuration scheme when optimizing the low-level optimization model, and to add a penalty term related to the node completion time limit to the objective function of the low-level optimization model within the constrained solution space. The penalty term is used to increase the objective function value when the task delays the node completion time limit, and the penalty intensity of the penalty term is determined by the current relaxation degree corresponding to the node completion time limit. The deviation calculation module is used to collect the actual execution parameters corresponding to the currently executed task in real time during the execution of the low-level optimization model, and calculate the deviation between the actual execution parameters and the preset plan value. The feedback module is used to obtain the triggering frequency and / or triggering amplitude corresponding to the penalty item if the deviation causes the penalty item to be triggered, and upload the triggering frequency and / or the triggering amplitude as a feedback signal to the high-level optimization model. The optimization module is used to respond to the feedback signal through the high-level optimization model, adjust the slack of the node completion time limit in subsequent optimization cycles, and / or adjust the weight coefficient of the penalty term in the low-level optimization model.

[0213] Among some feasible implementation methods are: The data acquisition module is used to collect the actual execution data corresponding to the scheduling scheme; The data acquisition module is used to acquire the planned execution data corresponding to the scheduling scheme; The comparison module is used to compare the actual execution data with the planned execution data to obtain the corresponding difference information; An update module is used to perform at least one update operation corresponding to the difference information.

[0214] In some feasible implementations, the update module is specifically used to perform at least one of the following update operations: Update the node features; Adjust the dynamic threshold for filtering the key bottleneck nodes; Adjust the target energy function; Update the parameters of the multi-scale graph network.

[0215] As the device embodiment is basically similar to the method embodiment, the description is relatively simple, and relevant parts can be found in the description of the method embodiment.

[0216] In addition, this invention also provides an electronic device, including: a processor, a memory, and a computer program stored in the memory and executable on the processor. When the computer program is executed by the processor, it implements the various processes of the scheduling method embodiment of the above-mentioned tasks and can achieve the same technical effect. To avoid repetition, it will not be described again here.

[0217] This invention also provides a computer-readable storage medium storing a computer program. When the computer program is executed by a processor, it implements the various processes of the scheduling method embodiment described above, achieving the same technical effect. To avoid repetition, it will not be described again here. The computer-readable storage medium may be a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, etc.

[0218] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. The same or similar parts between the various embodiments can be referred to each other.

[0219] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, apparatus, or computer program products. Therefore, embodiments of the present invention can take the form of entirely hardware embodiments, entirely software embodiments, or embodiments combining software and hardware aspects. Furthermore, embodiments of the present invention can take the form of computer program products implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, EEPROM, Flash, and eMMC, etc.) containing computer-usable program code.

[0220] Embodiments of the present invention are described with reference to flowchart illustrations and / or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing terminal device to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal device, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0221] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing terminal device to operate in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0222] These computer program instructions can also be loaded onto a computer or other programmable data processing terminal equipment, causing a series of operational steps to be performed on the computer or other programmable terminal equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable terminal equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0223] Although preferred embodiments of the present invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments as well as all changes and modifications falling within the scope of the embodiments of the present invention.

[0224] Finally, it should be noted that in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or terminal device that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or terminal device. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or terminal device that includes said element.

[0225] The above provides a detailed description of a task scheduling method and a task scheduling device provided by the present invention. Specific examples have been used to illustrate the principles and implementation methods of the present invention. The description of the above embodiments is only for the purpose of helping to understand the method and core ideas of the present invention. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of the present invention. Therefore, the content of this specification should not be construed as a limitation of the present invention.

Claims

1. A task scheduling method, characterized in that, include: Construct a multi-scale graph network corresponding to the scheduling tasks, wherein the multi-scale graph network includes at least task nodes at the time scale level; Extract the node features of the task nodes, and filter the task nodes according to the node features to obtain the key bottleneck nodes that meet the conditions. Map the optional scheduling states corresponding to the key bottleneck nodes to qubits; Obtain the target energy function for quantum degeneracy evolution, and evolve the bottleneck system composed of the qubits according to the target energy function to obtain the optimized state of the key bottleneck node; Based on the optimized state, a scheduling plan is generated for the scheduled task.

2. The method according to claim 1, characterized in that, The step of filtering task nodes based on the node characteristics to obtain key bottleneck nodes that meet the conditions includes: The node features of the task node are aggregated to obtain the bottleneck impact score of the task node; Task nodes whose bottleneck impact score is greater than or equal to a preset dynamic threshold are designated as critical bottleneck nodes.

3. The method according to claim 2, characterized in that, The aggregation of node features of the task node to obtain the bottleneck impact score of the task node includes: Obtain a bottleneck identification model, which includes at least a graph attention layer and a fully connected layer; The attention weights between the task node and its neighboring nodes are calculated through the graph attention layer, and the node features of the neighboring nodes are weighted and aggregated using the attention weights to obtain the context-enhanced representation corresponding to the task node. The node features of the task node itself are fused with the context-enhanced representation and input into the fully connected layer to output the bottleneck impact score of the task node.

4. The method according to claim 2 or 3, characterized in that, The node characteristics include at least one or more of the following static or dynamic attributes: task duration, resource requirements, task priority, deadline, resource contention intensity, task delay risk, resource utilization, task complexity, historical bottleneck frequency, number of downstream tasks, resource conflict graph centrality, and current progress deviation.

5. The method according to claim 1, characterized in that, The critical bottleneck nodes include a first bottleneck node with a binary selectable state and a second bottleneck node with a multi-value selectable state. Mapping the selectable scheduling states corresponding to the critical bottleneck nodes to qubits includes: For the first bottleneck node, a direct mapping using a single qubit is employed, with the two ground states of the qubit corresponding to the binary selectable states. For the second bottleneck node, binary encoding or one-hot encoding is used, and a combination of multiple qubits is used to represent each possible state. When the one-hot encoding is used, a penalty term is introduced into the target energy function to constrain multiple qubits corresponding to the same critical bottleneck node to have only one active state at any given time.

6. The method according to claim 1, characterized in that, The process of evolving the bottleneck system composed of the qubits according to the target energy function to obtain the optimized state of the key bottleneck node includes: The bottleneck system composed of the qubits is initialized to a quantum superposition state; Obtain the classical term corresponding to the target energy function and the driving term used to guide the quantum tunneling effect, and use the classical term and the driving term as the quantum annealing Hamiltonian; The bottleneck system is driven to evolve by the quantum annealing Hamiltonian, and the bottleneck system is measured after the evolution is completed to obtain the target classical value of the qubit. The classic target value is decoded to obtain the optimization state of the key bottleneck node.

7. The method according to claim 6, characterized in that, The process of driving the bottleneck system's evolution through the quantum annealing Hamiltonian, and then measuring the bottleneck system after the evolution to obtain the target classical value of the qubit, includes: The bottleneck system is driven to undergo multiple independent quantum annealing evolutions by the quantum annealing Hamiltonian. Each evolution obtains a set of initial classical values ​​for the qubits and the target energy function value corresponding to the initial classical values. The initial classical values ​​that minimize the target energy function value are selected as the target classical values.

8. The method according to claim 6 or 7, characterized in that, Also includes: During the evolution of the bottleneck system, local energy change information, historical optimization success rate, and conflict information with neighboring nodes of the key bottleneck nodes are obtained. The degree of optimization stagnation corresponding to the key bottleneck node is determined using the local energy change information. The degree of conflict corresponding to the critical bottleneck node is determined using the conflict information. The dynamic attention weight of the key bottleneck node is obtained by calculating the degree of optimization stagnation, the degree of conflict, and the historical optimization success rate.

9. The method according to claim 8, characterized in that, Also includes: The annealing temperature is dynamically adjusted according to the dynamic attention weight and the degree of conflict, and the quantum noise intensity is dynamically adjusted according to the dynamic attention weight and the degree of optimization stagnation. The annealing temperature is used to control the probability of the bottleneck system receiving inferior solutions during its evolution, and the quantum noise intensity is used to control the strength of the quantum tunneling effect during the bottleneck system's evolution.

10. The method according to claim 1, characterized in that, The step of scheduling based on the optimized state to generate a scheduling plan for the scheduled task includes: Based on the optimization status of the key bottleneck nodes, determine the start and end times, resource allocation, and dependencies between tasks for each task node at different time scale levels. Output the start and end times, resource allocation, and dependencies in the form of structured data and / or visual charts to generate a scheduling plan for the scheduled task.

11. The method according to claim 1, characterized in that, The time scale hierarchy includes at least a first time scale hierarchy and a second time scale hierarchy, wherein the first time scale hierarchy corresponds to a high-level optimization model, and the second time scale hierarchy corresponds to a low-level optimization model, and the method further includes: Obtain the optimization results output by the high-level optimization model. The optimization results include at least the resource allocation scheme and the node completion time limit carrying the initial relaxation. When optimizing the low-level optimization model, the solution space of the low-level optimization model is constrained according to the available resource time period and available resource capacity corresponding to the resource configuration scheme. Within the constrained solution space, a penalty term related to the node completion time limit is added to the objective function of the low-level optimization model. The penalty term is used to increase the objective function value when the task delays the node completion time limit. The penalty strength of the penalty term is determined by the current relaxation degree corresponding to the node completion time limit. During the execution of the low-level optimization model, the actual execution parameters corresponding to the currently executed task are collected, and the deviation between the actual execution parameters and the preset plan value is calculated. If the deviation causes the penalty term to be triggered, the trigger frequency and / or trigger amplitude corresponding to the penalty term are obtained, and the trigger frequency and / or trigger amplitude are used as feedback signals and uploaded to the high-level optimization model. The high-level optimization model responds to the feedback signal, adjusting the slack of the node completion time limit in subsequent optimization cycles, and / or adjusting the weight coefficient of the penalty term in the low-level optimization model.

12. The method according to claim 1, characterized in that, Also includes: Collect the actual execution data corresponding to the scheduling scheme; Obtain the planned execution data corresponding to the scheduling scheme; The actual execution data is compared with the planned execution data to obtain the corresponding difference information; Perform at least one update operation corresponding to the difference information.

13. The method according to claim 12, characterized in that, The execution of at least one update operation corresponding to the difference information includes: Update the node features; Adjust the dynamic threshold for filtering the key bottleneck nodes; Adjust the target energy function; Update the parameters of the multi-scale graph network.

14. A task orchestration system, characterized in that, A scheduling method for implementing the task as described in any one of claims 1-13.

15. The task orchestration system according to claim 14, characterized in that, The task orchestration system is applied to at least one of the following: manufacturing workshop production scheduling, logistics and distribution scheduling, project collaboration task scheduling, cloud computing resource task scheduling, software development task scheduling, data center operation scheduling, supply order scheduling, energy system load scheduling, and autonomous driving fleet task orchestration.

16. A task scheduling device, characterized in that, include: The graph network construction module is used to construct a multi-scale graph network corresponding to the scheduling task. The multi-scale graph network includes at least task nodes at the time scale level. The node filtering module is used to extract the node features of the task nodes and filter the task nodes according to the node features to obtain key bottleneck nodes that meet the conditions. The state mapping module is used to map the optional scheduling states corresponding to the key bottleneck nodes to qubits; An evolution module is used to obtain a target energy function for quantum degeneracy evolution, and to evolve the bottleneck system composed of the qubits according to the target energy function to obtain the optimized state of the key bottleneck node. The scheme generation module is used to schedule according to the optimization status and generate a scheduling scheme for the scheduled task.

17. An electronic device, characterized in that, It includes a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other through the communication bus; The memory is used to store computer programs; When the processor executes a program stored in the memory, it implements the method as described in any one of claims 1-13.

18. A computer-readable storage medium having instructions stored thereon that, when executed by one or more processors, cause the processors to perform the method as claimed in any one of claims 1-13.

Images