Multi-thread interleaved logistics conveying line scheduling method

Abstract

The application discloses a multi-line interweaving logistics conveying line scheduling algorithm and particularly relates to the technical field of logistics conveying line scheduling; through constructing a dynamic graph structure model, each node and path in the logistics system is dynamically mapped into a graph structure, embedding learning of the node state is carried out by using a graph neural network, an abnormal propagation area is identified in real time when a fault occurs, the scheduling graph is pruned, high-risk nodes and paths are eliminated, and a safe and feasible task path is reconstructed; meanwhile, the accuracy of scheduling execution is ensured through conflict detection and feasibility verification, online adaptive optimization of the graph model is realized in combination with data acquisition and a feedback mechanism in the running process, and therefore the prediction ability of the scheduling system for complex abnormalities, the disaster recovery scheduling ability and the overall running robustness are significantly improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of logistics conveying line scheduling, in particular to a multi-line interpenetration logistics conveying line scheduling method. BACKGROUND

[0002] Multi-line interpenetration logistics conveying line scheduling refers to, in a logistics system, for the complex scene of multiple conveying lines crossing and operating in parallel, coordinating and optimizing the time sequence, path and priority of material transportation through intelligent scheduling algorithm, so as to realize efficient and orderly operation of each conveying line, avoid congestion and conflict, and improve the conveying efficiency and response capability of the overall logistics system.

[0003] The prior art has the following shortcomings:

[0004] In a multi-line interpenetration logistics system, the scheduling system often regards device failures such as elevator jam as local abnormalities, only suspends directly related tasks, and ignores the possible chain reaction it may cause to the entire system. In actual operation, such local failures often transmit upwards through path dependence, causing upstream AGV task backlog, path conflict unable to be released in time, and finally causing scheduling logic to be stuck and even the entire system to be paralyzed. SUMMARY

[0005] The purpose of the present application is to provide a multi-line interpenetration logistics conveying line scheduling method to solve the problems in the background art.

[0006] In order to achieve the above purpose, the present application provides the following technical scheme: a multi-line interpenetration logistics conveying line scheduling method, comprising:

[0007] A dynamic graph structure model is constructed for the logistics conveying system, and each conveying unit node and task flow path is defined as a node and an edge in the graph structure;

[0008] Based on the constructed graph structure, a graph neural network model is used to learn the state feature embedding of each node;

[0009] When an abnormality is detected in a node, the current system state is input into the graph neural network model in real time, the affected path area and the propagation risk score are obtained, and the abnormality propagation area is automatically identified;

[0010] According to the predicted abnormality propagation area, the scheduling graph is pruned, the high-risk path nodes are excluded, and the logistics scheduling path is regenerated based on the pruned graph structure;

[0011] The generated new scheduling path is subjected to conflict detection and execution feasibility verification, and the feasible scheduling scheme is issued to the control system for execution;

[0012] During execution, running data is continuously collected, and the scheduling execution results are fed back for online update and training of the graph neural network model.

[0013] Preferably, in the dynamic graph structure model, the nodes include: conveyor segmentation units, junction points, buffer areas, vertical lifting equipment, sorting equipment, AGV parking points or transfer points;

[0014] The system maintains in real time the node type, current operating status, material load, congestion level, and historical fault labels of each node as input features for the graph neural network.

[0015] Preferably, the average waiting chain length of a node is generated after analyzing the node input feature vector. The generation method is as follows: a directed graph G=(V,E) is established for the task scheduling system, and the weight w(u,v) of each edge (u,v)∈E is initialized as follows: In the formula, This represents the cumulative processing time of the currently waiting tasks on node u. This represents the average time taken to transfer data from u to v;

[0016] Define the longest path length L(v) for each node v∈V, traverse all nodes in topological sorting, and update each edge (u,v)∈E(u, v): This indicates that the longest path length of node v is equal to the longest path length among all its predecessor nodes u plus the transmission weight w(u,v).

[0017] For the target node vtarget, backtrack all its valid preceding paths and record the length of each path. ; Set a maximum backtracking depth limit or calculate the average of the first K paths as the average waiting chain length of the node, the expression is: In the formula, This represents the average waiting chain length for a node.

[0018] Preferably, the path task backflow probability is generated after analyzing the edge input feature vector. The generation method is as follows:

[0019] Select a fixed time window, and for the path u→v, record the task identifiers of all tasks sent from node u to v; accumulate these tasks to form... (u→v); For each task: determine if it has a backflow task, and accumulate to... (u→v); Calculate the path task reversal probability, the expression is: In the formula, This represents the probability of backflow for the path task.

[0020] Preferably, in each scheduling cycle, the system takes the current graph structure state, including the average waiting chain length of nodes or the path task backflow probability, as input and feeds it into the trained graph neural network model.

[0021] The model outputs are: y^impact(v), which represents the risk score of node v being affected by the anomaly; and y^spread(v), which represents the probability that node v will continue to propagate the anomaly.

[0022] Based on the set thresholds: if y^impact(v) > 0.6: mark as an affected node; if y^spread(v) > 0.5: mark as a node in an abnormal propagation path;

[0023] Extract all affected nodes and related edges from the original graph to construct an anomaly propagation subgraph.

[0024] Preferably, when pruning the scheduling graph, an anomaly propagation score threshold is set, and nodes whose anomaly impact score exceeds the preset value and their associated paths are deleted. After pruning, the reachability and task integrity of the scheduling graph are judged. If there are breakpoint tasks, a scheduling agent node or jump node is introduced to perform path reconstruction.

[0025] Preferably, during the path reconstruction process, a multi-objective path search algorithm is adopted, which combines path safety score, task timeliness requirements and resource occupation conflict situation to generate multiple candidate paths and filter them according to priority. At the same time, a resource occupation time slice map is established for each candidate path to determine whether there are resource conflicts, time conflicts or device mutual exclusion relationships.

[0026] The technical effects and advantages provided by the present invention in the above technical solution are as follows:

[0027] 1. The multi-line interleaved logistics conveyor scheduling method provided by this invention overcomes the limitation of traditional systems that treat anomalies as local events. By constructing a dynamic graph structure and introducing graph neural networks for anomaly propagation modeling, the system gains the ability to perceive and predict the global scheduling ripple effect caused by local faults. In the early stages of a fault, the scheduling system can identify potentially affected areas through real-time graph state reasoning, automatically remove high-risk paths, and reconstruct task scheduling schemes, significantly improving the robustness and disaster recovery capability of the scheduling strategy.

[0028] 2. This invention continuously collects system operation data and constructs a feedback learning mechanism to achieve online iterative optimization of the graph neural network model. This enables the scheduling system to have adaptive learning capabilities, continuously improving prediction accuracy and response efficiency as task load changes and equipment status evolves. The overall solution achieves a closed-loop fusion of scheduling graph modeling, risk perception, path reconstruction, conflict control, and model learning. It is suitable for intelligent logistics scheduling systems in multi-line intertwined, high-concurrency, and variable scenarios, effectively improving system stability, intelligence level, and globally optimal scheduling performance. Attached Figure Description

[0029] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this invention. For those skilled in the art, other drawings can be obtained based on these drawings.

[0030] Figure 1 This is a mind map of the method of the present invention. Detailed Implementation

[0031] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0032] For examples, please refer to Figure 1 As shown, the multi-line interleaved logistics conveyor scheduling method described in this embodiment includes:

[0033] A dynamic graph structure model is constructed for the logistics transportation system, and each transportation unit node and the task flow path are defined as nodes and edges in the graph structure.

[0034] Based on the constructed graph structure, a graph neural network model is used to learn the state feature embedding of each node;

[0035] When an anomaly is detected in a node, the current system status is input into the graph neural network model in real time to obtain the affected path area and the propagation risk score, and automatically identify the area affected by the anomaly.

[0036] Based on the predicted area of ​​abnormal impact propagation, the scheduling graph is pruned to exclude high-risk path nodes, and the logistics scheduling path is regenerated based on the pruned graph structure.

[0037] The newly generated scheduling path is subjected to conflict detection and execution feasibility verification. The feasible scheduling scheme is then sent to the control system for execution.

[0038] During execution, running data is continuously collected, and the scheduling execution results are fed back for online update and training of the graph neural network model.

[0039] Abstract all physical or logical units in a logistics system that have control logic, state changes, and resource competition into nodes of a graph. This includes, but is not limited to: conveyor belt segments (each segment can be independently controlled to start and stop), junction points (where multiple conveyor lines or AGV paths converge), buffer or cache shelves, vertical lifting equipment, sorting equipment or robotic arm interaction points, as well as AGV parking points, charging points, and transfer points, etc.

[0040] During graph initialization and operation, each node should dynamically maintain the following attributes for the input features of the graph neural network: node type code (e.g., "01" represents the intersection point, "02" represents the hoist), current operating status (normal, abnormal, maintenance, shutdown, etc.), real-time load (e.g., the current quantity of material on the conveyor section, unit load), congestion level (estimated by accumulation detection or queue length), and fault history label (whether there are fault records in the recent time windows).

[0041] If there is a logistics task transmission relationship between any two logistics nodes, a directed edge is created in the graph to represent the task flowing from one node to another. For example, the route A → junction B → elevator C will form directed edges A → B and B → C.

[0042] Each edge also has variable attributes that reflect the path's transmission capacity and operating status, including: average transmission time (dynamically updated based on historical or real-time data), throughput (i.e., the amount of material that can pass through per unit time), current occupancy status (whether it is occupied by a task), and edge weight (a cost function used for path search or scheduling optimization, such as time, distance, and priority).

[0043] If bidirectional flow is possible in the path, such as AGVs that can travel in both directions, a bidirectional edge should be established; if a segment is a shared segment (shared by multiple AGVs / tasks), a "mutual exclusion weight" attribute needs to be set for conflict detection.

[0044] The graph structure needs to be updated in real time as the logistics system status changes. Status synchronization is performed once every scheduling cycle (e.g., every 1 second): Node status update: Update node status according to PLC signals or scheduling feedback; Edge status update: Calculate task transmission delay and congestion level between nodes and dynamically update edge weights; Add / delete nodes or edges: Dynamically adjust the graph structure when the system adds new equipment, disables paths, or changes task structure.

[0045] By connecting to the underlying sensing system (such as AGV positioning, RFID, sensors, WMS / MES), the data is mapped into a graph structure input format: the state of each node / edge is collected by the state sensing component and converted into a standard vector representation; the vector can be used as the node input feature hv and edge feature euv of the graph neural network.

[0046] To improve storage efficiency and processing speed, sparse graph data structures can be used in the following ways: adjacency lists can be used to represent graph connections; feature matrices can be used to store the feature vectors of nodes / edges; and graph databases (such as Neo4j) or graph computing frameworks (such as DGL and PyTorch Geometric) can be used to manage the graph structure.

[0047] The attributes of nodes and edges are numerically normalized (e.g., Min-Max, Z-score); discrete types (e.g., fault states, type encoding) are processed using one-hot encoding or embedding. The above graph structure is converted into an input format acceptable to graph neural networks, such as a combination of (nodes, edges, features); dynamic graph time-series snapshot input is supported (for time-series GNN training).

[0048] Constructing a dynamic graph structure model is not only the core foundation for data modeling in scheduling systems, but also a bridge connecting intelligent prediction and optimal control. By deeply modeling the relationships between nodes and paths in the logistics system and integrating real-time sensing information, subsequent graph neural networks can possess the capabilities of "structure perception," "state reasoning," and "dynamic evolution," providing a reliable data structure foundation and learning interface for disaster recovery scheduling, anomaly prediction, and path reconstruction.

[0049] Based on the constructed graph structure, a graph neural network model is used to learn the state features of each node. The graph neural network aggregates the neighborhood states of nodes and outputs the predicted value of the abnormal impact and the probability of impact propagation for each node, specifically including:

[0050] For each node, construct a feature vector containing: node type (e.g., junction, elevator, buffer) → One-hot encoding or embedding encoding; current operating status (normal, abnormal, fault) → numerical mapping (e.g., 0, 1, 2); current load (material quantity or occupancy ratio) → numerical normalization; congestion level (stacking time, queue length) → real-valued feature; fault history identifier → binary variable (whether a fault has occurred recently).

[0051] Each directed edge is assigned the following feature vectors: transmission time (dynamically changing) → real value; throughput capacity → real number normalization; current path state (idle, congested) → discrete encoding; path directionality → used as a graph structure connection index (u→v).

[0052] Normalize continuous numerical features (e.g., min-max normalization) and perform one-hot encoding or embedding mapping on discrete variables.

[0053] Neural network models with graph aggregation capabilities are employed, such as GCN (Graph Convolutional Network), GraphSAGE (sampling neighbor aggregation, suitable for large graphs), and GAT (Graph Attention Network, with attention mechanism).

[0054] GNN updates the hidden state of each node using the following formula: In the formula, Let v be the hidden vector representation of the k-th node. AGGREGATE represents the set of neighboring nodes of node v. AGGREGATE can be used for operations such as summation, averaging, max pooling, and attention-weighted operations. σ represents the learnable weights of the k-th layer; σ represents the activation function, such as ReLU.

[0055] Typically, 2 to 3 graph convolutional layers are selected to capture the effects of multi-hop adjacency; each layer is followed by BatchNorm and Dropout layers to enhance generalization ability.

[0056] The graph neural network is trained to learn anomaly impact prediction models: historical scheduling data is collected, including: system operation state graph (node ​​state + edge weight), fault / anomaly occurrence nodes and their subsequent impact areas (which can be used as supervision signals), and two training objectives are constructed for each node: anomaly impact score: the probability that the node is affected by an anomaly in the current graph structure (between 0 and 1), and propagation probability: whether the node will spread the anomaly to other nodes (0 or 1 classification); if it is a regression output (impact score): MSE (mean squared error) loss is used; if it is a categorical output (whether it spreads): cross-entropy loss is used; dual-task training (multi-task loss) is supported.

[0057] When the system detects an abnormality in the status of any node (e.g., equipment failure, prolonged delay, data disconnection), the dispatch control center immediately triggers the "abnormality identification flag" and marks the faulty node as vfail, synchronizing the following information:

[0058] The event includes a fault occurrence timestamp, fault type (hardware jam, timeout failure, communication interruption, etc.), and a node status snapshot (including the status of surrounding nodes). This event serves as a trigger condition to initiate the real-time GNN inference process.

[0059] The scheduling system collects the states of all nodes and edges from the state-aware components within the current period and constructs the input graph structure, including:

[0060] Node input feature vectors (such as load, status code, fault marker);

[0061] Input feature vectors (such as current path transmission time and traffic status);

[0062] Graph topology (connection relationships between nodes);

[0063] This graph structure dynamically reflects a snapshot of the entire system's operating state and serves as input to the graph neural network model.

[0064] The average waiting chain length of a node is generated by analyzing the node's input feature vector. The generation method is as follows:

[0065] For the task scheduling system, construct a directed graph G=(V,E), and initialize the weight w(u,v) of each edge (u,v)∈E as follows: In the formula, This represents the cumulative processing time of the currently waiting tasks on node u. This represents the average time taken to transfer data from u to v;

[0066] Since the scheduling graph is a DAG, a topological sort can be performed on the graph to generate a node sequence. ; Ensure that the direction of all edges is: if , then i <j。

[0067] Define the longest path length L(v) for each node v∈V. Initially: L(v)=0 if v is the source node (no incoming edges); L(v)=−∞ for other nodes.

[0068] Iterate through all nodes according to the topological sort, and update each edge (u,v)∈E(u, v): This indicates that the longest path length of node v is equal to the longest path length among all its predecessor nodes u plus the transmission weight w(u,v).

[0069] For the target node vtarget, backtrack all its valid preceding paths and record the length of each path. The maximum backtracking depth limit can be set, or only the average of the first k paths can be calculated as the average waiting chain length of the node. The expression is: In the formula, This represents the average waiting chain length for a node.

[0070] After analyzing the edge input feature vector, the path task backflow probability is generated. The generation method is as follows:

[0071] Select a fixed time window (e.g., the past hour, the past N scheduling cycles) to collect task behavior data, maintaining both short-term responsiveness and long-term trend considerations. For the path u→v: record the identifiers of all tasks sent from node u to v (task ID, AGV number, pallet number, etc. can be used); accumulate these tasks to form... (u→v); For each of the above tasks: determine whether any of the following behaviors occur during the process:

[0072] The system schedules the AGV to be turned back (e.g., when the AGV executes a withdrawal command);

[0073] The request was returned to u or its upstream node (caching failure, task failure).

[0074] A detour was taken, but the target node v was not reached;

[0075] If any of the above conditions are met, it is recorded as a backflow task and accumulated to [number]. (u→v); can be identified with the help of scheduling system logs, path reconstruction records, and exception tags.

[0076] The probability of backflow of a path task is calculated using the following expression: In the formula, This represents the probability of task backflow along the path. If the result is close to 0, it indicates that the path is stable. If it is close to or exceeds 0.2~0.3, it suggests that there may be a problem with the scheduling strategy or that the path logic is disordered.

[0077] In each scheduling cycle, the system takes the current graph structure state, including the average waiting chain length of nodes or the path task backflow probability, as input and feeds it into the trained graph neural network model.

[0078] The model outputs two results:

[0079] y^impact(v): Risk score (continuous value) of node v being affected by the anomaly.

[0080] y^spread(v): Whether node v is likely to continue propagating the anomaly (Boolean probability);

[0081] Based on the set thresholds: if y^impact(v) > 0.6: mark as an affected node; if y^spread(v) > 0.5: mark as a node in an abnormal propagation path;

[0082] Extract all affected nodes and related edges from the original graph to construct an anomaly propagation subgraph, which will be used for the next step of scheduling graph pruning and path reconstruction.

[0083] After completing the graph neural network inference, nodes with y^impact(v) > 0.6 are marked as high-risk;

[0084] Remove these nodes from the scheduling graph, including:

[0085] All incoming edges (paths from other nodes to this node);

[0086] All outgoing edges (paths connecting this node to other nodes);

[0087] Pause all currently scheduled tasks and new task accesses on this node.

[0088] Removal operations can be performed directly in the scheduling graph data structure, such as updating the adjacency list or node list.

[0089] Scan the propagation scores of all path edges;

[0090] If a path's score exceeds a set threshold (e.g., > 0.5), the path is considered unsafe.

[0091] Delete the path (directed edge) from the scheduling graph;

[0092] If an alternative path exists (such as a path that can be switched between multiple paths), then the primary path is marked as unavailable, and the alternative path is prioritized for use.

[0093] After pruning, it is necessary to check whether the graph structure still retains: connectivity between the start and end points; whether critical tasks are isolated; and whether there are any tasks that must pass through the pruned nodes / paths. If any of the above issues exist, a scheduling refactoring mechanism should be implemented or temporary scheduling proxy logic should be introduced (see subsequent path generation).

[0094] After completing the graph pruning, you get a "healthy path graph" or "disaster recovery scheduling graph", which is used for the next round of scheduling path generation.

[0095] Based on the current list of tasks to be scheduled, determine the following for each task: starting node; target node; time requirements (e.g., latest arrival time, priority level); and special path preferences (e.g., only high-speed sections are allowed, avoid elevators). Establish the mapping requirements between tasks and the remaining available graph.

[0096] The following path planning algorithms are used: A* algorithm (minimizing the cost function (time, risk)); Dijkstra's algorithm (for shortest path priority in graphs); K-shortest path algorithm (generating multiple candidate paths for comparison); and constrained graph traversal algorithm (handling conditions such as task window and node capacity). The algorithm inputs the current graph, start and end points, and feasible constraints, and outputs one or more feasible paths.

[0097] Since multiple tasks are scheduled simultaneously, the following must be performed: path overlap detection (whether there are shared nodes / paths); time window conflict judgment (whether there is a conflict in the same time period); and AGV or conveyor equipment resource occupancy check.

[0098] If a conflict is found, the following strategies can be used for optimization:

[0099] Adjust task start time; use alternative paths; reduce the scheduling priority of some low-priority tasks; introduce local caching or transit node buffering scheduling.

[0100] The final scheduling path structure includes: the sequence of path nodes for each task; the estimated time window for each node to be traversed by the task; and the usage arrangement of key equipment along the path. This structure will be distributed to the control system (such as WCS, AGV scheduling controller) and executed in conjunction with the real-time status system.

[0101] For all newly generated scheduling paths, check for the following conflict types:

[0102] Node conflict: Multiple task plans occupy the same conveyor section, junction, or lifting equipment at the same time;

[0103] Edge path conflict: Multiple tasks share the same path (i.e., the edge in the graph) during the same time period.

[0104] Equipment mutual exclusion conflicts: such as multiple AGVs requesting to enter a single AGV channel simultaneously, or a narrow channel. Implementation: Establish a "time slice resource occupancy table" for each task path; scan all path time slices to determine if there are any overlaps; use a conflict window detection algorithm on the scheduling graph (such as sliding time window intersection judgment) to perform fast filtering.

[0105] Conflicts may also occur if the following relationships exist between tasks:

[0106] A task must wait for another task to complete before it can start; a node needs to complete task A before it can process task B; multiple batches of merged tasks need to share a critical cache or load point.

[0107] Solution: parse the dependency graph between tasks; set "start-up wait conditions" for tasks with dependencies; strengthen the scheduling order constraint logic.

[0108] Load limits for elevators / sorting equipment; reverse traversal restrictions for AGV paths; uniqueness detection of path usage direction (e.g., only one-way passable paths); buffer capacity limits (whether there are available slots at the target point or transfer point).

[0109] After ensuring there are no logical conflicts, it is also necessary to verify the actual execution capability: determine whether the nodes in each path are in an "executable state" within the expected scheduling period; consider whether the nodes are scheduled for maintenance, power-on / off, or task mode switching; verify the device load capacity: whether the current task exceeds the processing limit.

[0110] Accumulate the latency of each node / edge in the path; ensure that the total duration of the entire path does not exceed the time constraint of the task; ensure that the difference in pace between task batches is controllable, and avoid system jitter or backlog.

[0111] Comprehensive reachability verification: Does the starting point meet the "starting conditions" (is the task ready and resources available)? Is the path completely connected? Does the target location have the capability to receive tasks (space / capability / priority)?

[0112] The validated scheduling path scheme is converted into a data format that the system can recognize, including: the node sequence of each task; the task start time and the estimated entry / exit time of each node; the mapping of equipment control commands on the path (such as start / stop commands and AGV action codes); and conflict avoidance parameters (such as avoidance time and detour commands).

[0113] The scheduling plan is sent to: WCS system via API, message queue or industrial communication protocol (such as OPC-UA, Modbus, MQTT): control conveyor belts, sorting, lifting and other equipment; AGV scheduler: assign specific travel paths and task nodes to AGVs; MES or WMS system: update task status and inventory flow.

[0114] The control system sends back a "successful reception" signal; if a path scheduling fails or the task is suspended, a "rollback mechanism" is triggered: the alternative path is switched first; or the scheduling path generation module is re-entered to execute the next plan.

[0115] The control system periodically reports the task execution status (such as node arrival, equipment execution success, abnormal interruption, etc.); the scheduling system updates the system diagram status based on the feedback and makes the next round of scheduling decisions.

[0116] The exception interruption handling mechanism is triggered again if a new exception (carding, timeout, task conflict) is encountered during execution: graph structure state update; exception prediction module activation; graph pruning → path reconstruction → scheduling recalculation.

[0117] During the execution of scheduling tasks, the system needs to continuously collect the following types of data from devices, control systems, and sensor networks:

[0118] Node-level operational data: actual task entry and exit times; node status change logs (normal / abnormal / blocked); device fault flags and maintenance cycle records; buffer capacity changes and queue lengths.

[0119] Path-level operational data: actual path travel time; whether backtracking (path reversal) occurred; execution records of path interruption, switching, or jumping; AGV travel trajectory or conveyor line blockage status.

[0120] Task-level execution results: scheduling success and failure flags; success rate statistics (whether it was completed on time); number of scheduling conflicts and number of reschedulings.

[0121] The raw data collected is typically heterogeneous and time-inconsistent log data. To facilitate model use, the following processing is required:

[0122] Time alignment processing: Align the data of each node / edge with the task timestamp as the center;

[0123] Feature extraction: Transforming the raw signal into a structured feature vector, such as "waiting time fluctuation" and "reverse flow count";

[0124] Anomaly labeling: Labeling abnormal paths or nodes using preset rules or manual review (for supervised learning);

[0125] Sample sliding window generation: Construct a training sample set in units of graph structure + state snapshot + execution label.

[0126] The system executes the following procedure at regular intervals or when update conditions are triggered:

[0127] The scheduling execution results of the most recent period are merged with the graph structure state to generate new training samples; the sample content includes: node / edge feature vectors, graph structure topology, and target labels (anomaly score, propagation score).

[0128] Based on the existing graph neural network model architecture, adopt any of the following strategies:

[0129] Add new samples to the existing training set; continue training the original model for several rounds (usually fine-tuning with a small learning rate); use early stopping to control and avoid overfitting.

[0130] The underlying GNN structure is fixed, and only the output layer weights are updated; the original model structure is retained, and the model can quickly adapt to the latest state distribution.

[0131] Samples with large prediction errors in the recent period are weighted more; a sample importance factor is introduced to improve the system's ability to learn from rare anomalies.

[0132] After online training, prediction tests are first run on a simulation environment or a backup graph structure to verify whether the improvement in accuracy for identifying abnormal regions is significant. Only if the accuracy and robustness threshold tests are passed can the main model be replaced.

[0133] It supports switching between graph neural network models without interrupting system operation; the current model continues to process tasks until the end of the scheduling cycle; and a new model is activated at the start of the next cycle.

[0134] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters in the formulas are set by those skilled in the art according to the actual situation.

[0135] The above embodiments can be implemented, in whole or in part, by software, hardware, firmware, or any other combination thereof. When implemented using software, the above embodiments can be implemented, in whole or in part, as a computer program product. The computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer programs are loaded or executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more sets of available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium. A semiconductor medium can be a solid-state drive.

[0136] It should be understood that the term "and / or" in this document is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A alone, A and B simultaneously, and B alone, where A and B can be singular or plural. Additionally, the character " / " in this document generally indicates an "or" relationship between the preceding and following related objects, but it may also indicate an "and / or" relationship; please refer to the context for specific understanding. Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0137] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application.

Claims

1. A scheduling method for multi-line interleaved logistics conveyor lines, characterized in that: include: A dynamic graph structure model is constructed for the logistics transportation system, and each transportation unit node and the task flow path are defined as nodes and edges in the graph structure. The average waiting chain length of nodes is generated after analyzing the node input feature vectors. The generation method is as follows: a directed graph G=(V,E) is established for the task scheduling system, and the weight w(u,v) of each edge (u,v)∈E is initialized as follows: In the formula, This represents the cumulative processing time of the currently waiting tasks on node u. This represents the average time taken to transfer data from u to v; Define the longest path length L(v) for each node v∈V, traverse all nodes in topological sorting, and update each edge (u,v)∈E(u, v): This indicates that the longest path length of node v is equal to the longest path length among all its predecessor nodes u plus the transmission weight w(u,v). For the target node vtarget, backtrack all its valid preceding paths and record the length of each path. ; Set a maximum backtracking depth limit or calculate the average of the first k paths as the average waiting chain length of the node, the expression is: In the formula, This represents the average waiting chain length for each node. After analyzing the edge input feature vector, the path task backflow probability is generated. The generation method is as follows: select a fixed time window, for the path u→v, record the task identifiers sent from node u to v; accumulate these tasks to form... (u→v); For each task: determine if it has a backflow task, and accumulate to... (u→v); Calculate the path task reversal probability, the expression is: In the formula, For path task backflow probability; In each scheduling cycle, the current graph structure state, including the average waiting chain length of nodes or the path task backflow probability, is used as input to the trained graph neural network model. The model outputs are: y^impact(v), which represents the risk score of node v being affected by the anomaly; and y^spread(v), which represents the probability that node v will continue to propagate the anomaly. Based on the set thresholds: if y^impact(v) > 0.6: mark as an affected node; if y^spread(v) > 0.5: mark as a node in an abnormal propagation path; Extract all affected nodes and related edges from the original graph to construct an anomaly propagation subgraph; Based on the constructed graph structure, a graph neural network model is used to learn the state feature embedding of each node; When an anomaly is detected in a node, the current system status is input into the graph neural network model in real time to obtain the affected path area and the propagation risk score, and automatically identify the area affected by the anomaly. Based on the predicted area of ​​abnormal impact propagation, the scheduling graph is pruned to exclude high-risk path nodes, and the logistics scheduling path is regenerated based on the pruned graph structure. The newly generated scheduling path is subjected to conflict detection and execution feasibility verification. The feasible scheduling scheme is then sent to the control system for execution. During execution, running data is continuously collected, and the scheduling execution results are fed back for online update and training of the graph neural network model.

2. The scheduling method for multi-line interleaved logistics conveyor lines according to claim 1, characterized in that: In the dynamic graph structure model, the nodes include: conveyor segmentation units, junction points, buffer areas, vertical lifting equipment, sorting equipment, AGV parking points or transfer points; The system maintains in real time the node type, current operating status, material load, congestion level, and historical fault labels of each node as input features for the graph neural network.

3. The scheduling method for multi-line interleaved logistics conveyor lines according to claim 1, characterized in that: When pruning the scheduling graph, an anomaly propagation score threshold is set. Nodes whose anomaly impact score exceeds the preset value and their associated paths are deleted. After pruning, the reachability and task integrity of the scheduling graph are judged. If there are breakpoint tasks, a scheduling agent node or jump node is introduced to perform path reconstruction.

4. The multi-line interleaved logistics conveyor scheduling method according to claim 3, characterized in that: During the path reconstruction process, a multi-objective path search algorithm is adopted, which combines path safety score, task timeliness requirements and resource occupation conflict to generate multiple candidate paths and filter them according to priority. At the same time, a resource occupation time slice map is built for each candidate path to determine whether there are resource conflicts, time conflicts or device mutual exclusion relationships.

Images