Flexible production line scheduling method and system based on multi-AGV cooperation

Abstract

The invention discloses a flexible production line scheduling method and system based on multi-AGV cooperation, particularly relates to the technical field of flexible manufacturing system resource scheduling, and is used for solving the defect that an existing dynamic priority mechanism causes AGV resource locking during high-priority task concurrence. The method comprises the steps of obtaining production line task priority data; the coupling association strength of the high-priority tasks is evaluated; identifying a group of risk tasks based on an intensity threshold; extracting intra-group task resource competition degree and path conduction efficiency, and generating a task chain conduction impedance factor through a graph convolutional neural network; processing an impedance factor through a gating circulation unit model, and outputting a cooperative distribution weight; aGV resources are distributed according to weight reforming and digitalization, and a scheduling instruction is generated; task conflict conduction modeling and resource collaborative allocation are achieved, and the production line resource utilization rate and the high-urgency task response efficiency are remarkably improved.

Description

Technical Field

[0001] The present invention relates to the technical field of flexible manufacturing system resource scheduling, and more specifically, to a flexible production line scheduling method and system based on multi-AGV collaboration. Background Art

[0002] In modern flexible manufacturing systems, multi-AGV collaborative scheduling technology has become a key means to improve production line efficiency. Existing technologies generally adopt a dynamic priority scheduling mechanism, that is, AGV resources are allocated in real time according to the urgency of the task (such as equipment failure repair, insert production instructions). This mechanism responds to sudden tasks through a central control system and optimizes local tasks according to preset rules (such as the shortest path and time window constraints).

[0003] However, the existing technology has the following defects: when multiple high-priority tasks are triggered concurrently in the time and space dimensions, the dynamic priority mechanism will trigger a resource locking effect - the AGV cluster occupied by local high-priority tasks cannot be released due to path blockage or task delay, causing tasks in other areas to stagnate due to resource depletion, seriously restricting the overall response efficiency and robustness of the flexible production line. Summary of the Invention

[0004] In order to overcome the above-mentioned defects of the prior art, an embodiment of the present invention provides a flexible production line scheduling method and system based on multi-AGV collaboration to solve the problems raised in the above-mentioned background technology.

[0005] To achieve the above object, the present invention provides the following technical solutions: A flexible production line scheduling method based on multi-AGV collaboration includes the following steps: S1. Obtain the task priorities of all tasks to be executed in the flexible production line; S2. Evaluate the task coupling strength between any two high-priority tasks and output the task coupling evaluation result; S3. Identify risky task groups based on the task coupling assessment results. The risky task groups consist of tasks whose task coupling strength exceeds a preset coupling threshold. S4. Extract the resource competition and path transmission efficiency of each task in the risk task group, and generate the task chain transmission impedance factor through the graph convolutional neural network; S5. Input the task chain conduction impedance factor into the gated recurrent unit model and output the AGV collaborative allocation weight of the risk task group; S6. Redistribute the execution order of all tasks in the risk task group based on the AGV collaborative allocation weight and generate AGV scheduling instructions.

[0006] In a preferred embodiment, obtaining the task priorities of all tasks to be executed in the flexible production line includes: Collect task priority data of each task to be executed from the flexible production line control system in real time; The task priority data is dynamically generated by the flexible production line control system according to the urgency of the task triggering event; Task triggering events include equipment failure repair instructions and insert order production instructions.

[0007] In a preferred embodiment, evaluating the task coupling strength between any two high-priority tasks and outputting the task coupling evaluation result includes: Obtain the execution path coordinate set of each high-priority task in the current layout diagram of the flexible production line; Calculate the path overlap ratio between the execution path coordinate sets of two high-priority tasks; Get the task execution time overlap ratio of two high-priority tasks within the scheduling time window; The product of the output path overlap rate and the task execution time overlap rate is used as the task coupling association strength value of the two high-priority tasks and output as the task coupling evaluation result.

[0008] In a preferred embodiment, the path overlap rate is equal to the ratio of the sum of the Euclidean distances of the overlapping path segments to the total length of the two task paths; the task execution time overlap rate is equal to the ratio of the overlapping duration of the two task execution periods to the total duration of the two tasks.

[0009] In a preferred embodiment, a risky task group is identified based on the task coupling assessment result. The risky task group is composed of tasks whose task coupling strength exceeds a preset coupling threshold, including: Get the task coupling strength values ​​of all high-priority task pairs; comparing the task coupling association strength value with a preset coupling threshold; Screening high-priority task pairs whose task coupling strength exceeds a preset coupling threshold; Construct risk task groups based on the topological connectivity of the selected high-priority task pairs; Output the set of all high-priority tasks contained in the risk task group as the identification result.

[0010] In a preferred embodiment, the resource competition and path transmission efficiency of each task in the risk task group are extracted, and a task chain transmission impedance factor is generated through a graph convolutional neural network, including: For each task in the risk task group, obtain the real-time AGV demand value and available value in the task area, and calculate the resource contention as the ratio of the real-time AGV demand value to the available value; For the same task, obtain the historical path operation log data of the task and calculate the path conduction efficiency as the inverse of the percentage of the path unobstructed period; The resource competition value and the path transmission efficiency value are combined into a binary feature vector, which is associated with the task node corresponding to the risk task group; Based on the resource dependency data between tasks in the risk task group, a task resource dependency topology graph is constructed, where nodes represent tasks and edges represent dependencies. The task resource dependency topology graph is input into the graph convolutional neural network to perform neighborhood feature aggregation operations and output the task chain conduction impedance factor value of each task node.

[0011] In a preferred embodiment, the task chain conduction impedance factor is input into the gated recurrent unit model, and the AGV collaborative allocation weight of the risk task group is output, including: Obtain the task chain conduction impedance factor value sequence of all tasks in the risk task group; Arrange the task chain conduction impedance factor numerical sequence according to the task dependency time sequence to form an impedance factor time sequence input vector; Input the impedance factor timing input vector into the pre-trained gated recurrent unit model to perform timing association fusion operation; The task weight parameters of the tasks in the risk task group are generated through the output layer of the gated recurrent unit model; Normalize the task weight parameters of all tasks in the risk task group to obtain the AGV collaborative allocation weight value of the risk task group.

[0012] In a preferred embodiment, the execution order of all tasks in the risk task group is redistributed according to the AGV collaborative allocation weight and an AGV scheduling instruction is generated, including: Obtain the AGV collaborative allocation weight values ​​corresponding to all tasks in the risk task group; Arrange the execution priority of all tasks in the risk task group in descending order according to the AGV collaborative allocation weight value; Allocate the number of AGV cluster resources to each task according to the execution priority order; Generate task scheduling time sequence queue based on execution priority order and the number of allocated AGV cluster resources; The task scheduling timing queue is converted into an executable scheduling instruction set for the AGV control system.

[0013] In a preferred embodiment, the number of AGV cluster resources allocated to a task is equal to the number of basic resource requirements of the task multiplied by an integer coefficient of the AGV collaborative allocation weight value.

[0014] On the other hand, the present invention provides a flexible production line scheduling system based on multi-AGV collaboration, including the following modules: Data acquisition module, used to obtain the task priorities of all tasks to be executed in the flexible production line; Conflict detection module, used to evaluate the task coupling strength between any two high-priority tasks and output the task coupling evaluation results; A risk identification module is used to identify risky task groups based on task coupling assessment results. The risky task groups are composed of tasks whose task coupling correlation strength exceeds a preset coupling threshold. The resource modeling module is used to extract the resource competition and path transmission efficiency of each task in the risk task group, and generate the task chain transmission impedance factor through the graph convolutional neural network; The collaborative decision-making module is used to input the task chain conduction impedance factor into the gated recurrent unit model and output the AGV collaborative allocation weight of the risk task group; The instruction generation module is used to redistribute the execution order of all tasks in the risk task group according to the AGV collaborative allocation weight and generate AGV scheduling instructions.

[0015] Compared with the prior art, the present invention has the following beneficial effects: Through a task coupling strength assessment mechanism, the system accurately identifies spatiotemporal conflict chains between high-priority tasks, breaking through the limitations of traditional dynamic priority scheduling, which focuses solely on single-task optimization. A risky task group is constructed based on topological connectivity, effectively capturing the implicit resource competition effects caused by indirect dependencies and mitigating the risk of AGV resource lockup caused by multi-task concurrency. A dual-factor graph convolution fusion of resource contention and path transmission efficiency quantifies the resource congestion and diffusion characteristics of task chains, enabling a resource allocation model that incorporates both spatial competition and temporal transmission characteristics. The task chain transmission impedance factor is modeled through a gated recurrent unit, dynamically analyzing the evolution of inter-task resource conflicts and ensuring that weight allocation decisions meet the causal requirements of dynamic production line scheduling. Finally, through an integerized coefficient resource allocation mechanism, the coordination weights are converted into discrete AGV cluster scheduling instructions, achieving resource coordination optimization for high-priority task groups. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 This is a flow chart of a flexible production line scheduling method based on multi-AGV collaboration of the present invention; Figure 2 This is a structural diagram of a flexible production line scheduling system based on multi-AGV collaboration in the present invention. DETAILED DESCRIPTION

[0017] The following will provide a clear and complete description of the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. All other embodiments obtained by ordinary technicians in this field based on the embodiments of the present invention without making any creative efforts shall fall within the scope of protection of the present invention.

[0018] Example 1: Figure 1 The present invention provides a flexible production line scheduling method based on multi-AGV collaboration, which includes the following steps: S1. Obtain the task priorities of all tasks to be executed in the flexible production line; S2. Evaluate the task coupling strength between any two high-priority tasks and output the task coupling evaluation result; S3. Identify risky task groups based on the task coupling assessment results. The risky task groups consist of tasks whose task coupling strength exceeds a preset coupling threshold. S4. Extract the resource competition and path transmission efficiency of each task in the risk task group, and generate the task chain transmission impedance factor through the graph convolutional neural network; S5. Input the task chain conduction impedance factor into the gated recurrent unit model and output the AGV collaborative allocation weight of the risk task group; S6. Redistribute the execution order of all tasks in the risk task group based on the AGV collaborative allocation weight and generate AGV scheduling instructions.

[0019] S1. Obtain the task priorities of all tasks to be executed in the flexible production line. The specific implementation includes the following steps: The flexible production line control system's central processing unit monitors trigger events associated with production tasks in real time. When it detects an equipment failure repair signal or an interruption production order, the unit invokes built-in event type priority mapping rules: Equipment failure repair events are assigned the highest priority level (e.g., a value of 9), interruption production events are assigned the second-highest priority level (e.g., a value of 7), and routine production tasks are dynamically assigned a priority level based on the remaining delivery time of the order. The specific rules are as follows: The delivery deadline corresponding to the task is obtained from the order database, and the difference between the current time and the deadline is calculated (defined as the remaining time). When the remaining time falls within a preset time interval, it is assigned a specific priority level. Shorter remaining time intervals are assigned higher priority levels (e.g., a remaining time of less than or equal to 2 hours is assigned level 6, less than or equal to 4 hours is assigned level 5, and greater than 4 hours is assigned level 4). The priority calculation unit encapsulates the generated priority data into data units containing an event type code, a priority level value, and a precise timestamp.

[0020] The control system transmits data units to the AGV dispatch server via an industrial real-time Ethernet protocol (such as PROFINET). The dispatch server performs data integrity checks: first, it verifies the integrity of the data unit using a cyclic redundancy check algorithm, which uses an internationally standardized generator polynomial. Second, it checks timestamp continuity. If the interval between the timestamp of the current data unit and the timestamp of the previous unit exceeds the system's maximum allowable latency threshold (e.g., 500 milliseconds), the data is considered abnormal. A retransmission mechanism is initiated for data units that fail verification: the first retransmission wait time is an integer multiple of the system's baseline period (e.g., if the baseline period is 50 milliseconds, the retransmission wait time is 100 milliseconds). If the retransmission fails again, the wait time increases exponentially (e.g., the second wait time is 200 milliseconds, the third wait time is 400 milliseconds). When the number of retransmissions reaches the upper limit (e.g., 3), a historical data recovery strategy is used: the priority levels of similar tasks within the most recent valid period (e.g., the previous minute) are retrieved from the historical database, the arithmetic mean is calculated, and the value of the priority level in the abnormal data unit is replaced with the arithmetic mean.

[0021] In multi-task conflict scenarios, the system performs priority arbitration. When multiple equipment failure repair events occur simultaneously, they are prioritized based on the physical location of the equipment relative to key workstations (those with distances less than a threshold, such as 5 meters, are prioritized). When multiple production orders are inserted simultaneously, they are prioritized based on the unit-time output value metric in the order management system (those with the highest output value per hour, such as the highest output value per hour, are prioritized). The arbitration result is generated by a dedicated hardware comparator using a two-level comparison architecture: the first-level comparator processes the event type code, and the second-level comparator processes the distance or output value metric. The arbitration result is written to a special flag field in the data unit.

[0022] S2. Evaluate the task coupling strength between any two high-priority tasks and output the task coupling evaluation results. The specific implementation includes the following steps: The path analysis of the flexible production line control system is performed by reading the equipment position coordinate model in the layout database. For each high-priority task, the coordinate point sequence of its preset moving path is extracted from the process database (for example, the path of task number P001 contains 3 positioning points: the starting point position coordinates, the intermediate point position coordinates, and the target point position coordinates). The path coincidence calculation engine performs: continuously comparing the coordinate point sequences of the two tasks, and identifying more than 3 consecutive reference points with completely matched positions (for example, the second and third reference points of task P001 coincide with the first and second reference points of task P002, respectively). For each pair of overlapping reference points, the physical spacing value is calculated: this value is the arithmetic square root of the sum of the square of the horizontal position difference and the square of the vertical position difference of the two reference points (for example, a pair of overlapping points has a horizontal difference of 3 units and a vertical difference of 2 units, and the spacing is approximately 3.61 units). The path overlap ratio is calculated by summing the distances between all pairs of overlapping points and dividing it by the total length of the two task paths (the total length is the sum of the distances between adjacent points in each task). For example, if the total distance is 3.6 units and the total length of the two tasks is 14.4 units, the overlap ratio is 25%. If no consecutive three overlapping points are found, the path overlap ratio is set to 0.

[0023] The scheduling system's time series analysis retrieves the execution time intervals of the two tasks in the job schedule (for example, Task P001 is scheduled for 09:00-09:30, and Task P002 is scheduled for 09:15-09:45). The time overlap calculator performs the following operations: It determines the overlapping subinterval of the two time intervals (in this example, the overlapping period 09:15-09:30), measures the duration of this subinterval (15 minutes), and divides this duration by the total execution time of the two tasks (30 minutes for Task P001 plus 30 minutes for Task P002 = 60 minutes) to calculate the task execution time overlap ratio (15 / 60 = 0.25). The calculated result is stored in the data buffer.

[0024] The CPU's numerical arithmetic unit accesses the buffer data, extracts the path overlap ratio value and the task execution time overlap ratio value, and performs a floating-point multiplication operation (e.g., 0.25 × 0.25 = 0.0625). This product is defined as the task coupling strength value. A structured data object is constructed: the paired task number is written into the task pair identifier field, the product value is stored in the association strength value field, and the timestamp field records the current system time. The status flag is set to 0 by default. If the path overlap ratio is 0 or the time overlap ratio is 0, resulting in a zero product, the status flag is set to 1, indicating an abnormal association.

[0025] Hardware requirements: The geometry coprocessor must support vector modulus calculation instructions, and the system timing unit must have 1 millisecond accuracy. Abnormal data handling: If path coordinates are missing, the average coordinate sequence of the task's three most recent historical paths will be used. If the planned time is not set, the planned interval will be deduced based on the work order's standard process time parameters.

[0026] S3. Identify risky task groups based on the task coupling assessment results. The risky task groups consist of tasks whose task coupling strength exceeds a preset coupling threshold. The specific implementation includes the following steps: The task coupling strength value data columns of all high-priority task pairs are read from the task coupling evaluation result database in pages (for example, the first record: the strength value of task pair P001-P002 is 0.0625). The system accesses the parameter configuration library to retrieve the preset coupling threshold (this threshold is dynamically set based on the historical operation data of the production line: the frequency of high-priority task conflicts in the past 90 days is counted. When the average number of conflicts per day exceeds 5, the threshold is set to 0.05, otherwise it is set to 0.1; the current example threshold is 0.05). The numerical comparison unit scans the task coupling strength value line by line: if the task coupling strength value is greater than the preset coupling threshold (for example, 0.0625>0.05), the valid flag bit (binary value 1) is set in the task pair status register; if it is less than or equal to, the invalid flag bit (0) is set. After completing the full table scan, a valid task pair index table is generated (for example, recording the valid task pair numbers P001-P002, P002-P003, etc.).

[0027] The topology construction engine loads the valid task pair index table and initializes the task node relationship graph: a separate node is generated for each unique task number, and undirected edges are created between the two nodes in a valid task pair (for example, an edge is established between nodes P001 and P002, and an edge is established between nodes P002 and P003). The connected domain identification process uses a depth-first traversal rule: a randomly selected unvisited node is used as the starting point, and its adjacent nodes are recursively visited and marked as visited until all nodes in the connected domain are traversed (for example, P001 visits adjacent node P002, and P002 visits P003, forming the node set {P001, P002, P003}). Upon completion of the traversal, an independent risk task group number (Group ID: G001) is generated. For isolated node handling, nodes without adjacent edges form their own risk task group (for example, a single node P004 generates Group ID: G002). When a ring topology is detected (e.g., a closed loop of P001-P002-P003-P001), it is automatically merged into the same risk task group (group ID: G003).

[0028] The risk task group data structure construction unit executes: assigning a hexadecimal identifier to each group (e.g., G001) and sorting the task numbers within the group in ascending lexicographical order (e.g., P001, P002, P003). The output thread writes the risk task group data set to a shared memory buffer. The data packet structure consists of three fields: a group identifier (fixed-length 4 bytes), a task quantity value (integer), and an array of task numbers (variable-length string). When the system detects a preset coupling threshold adjustment event (e.g., a temporary adjustment of the maintenance period threshold to 0.1), it automatically creates a data snapshot to prevent overwriting.

[0029] Hardware requirements: 64GB of memory is required for a 500-node scale, and the stack depth is capped at 10,000 layers. Abnormal data handling: If the task coupling strength value is missing, the average of the three most recent values ​​(e.g., the average of the values ​​at 08:00, 08:10, and 08:20) is used. If the threshold configuration table is corrupted, the default value of 0.05 is restored. Ring structure processing optimization: When the number of nodes in a ring exceeds 50, a hierarchical traversal strategy is enabled.

[0030] S4. Extract the resource competition and path transmission efficiency of each task in the risk task group, and generate the task chain transmission impedance factor through the graph convolutional neural network. The specific implementation includes the following steps: For each task record within a risk task group (for example, risk task group G001 includes tasks P001, P002, and P003), the system calls the real-time resource monitoring interface of the AGV scheduling system to obtain the current AGV demand value for the task's allocation area (specifically, the total number of AGVs assigned to tasks in that area, for example, area Z001 requires 3 AGVs) and the real-time number of available AGVs in the area (specifically, the number of idle AGVs detected by the area's sensors in real time, for example, 2 AGVs). The resource contention calculation unit calculates the resource contention value by dividing the AGV demand value by the AGV availability value (3 ÷ 2 = 1.5). This quotient is used as the resource contention value (task P001 has a resource contention value of 1.5). Each task within the same risk task group completes this calculation process independently (tasks P002 and P003 follow the same process).

[0031] For the same task record mentioned above (using Task P001 as an example), the system queries the path operation history database to retrieve all path status records for that task within the past 24 hours. Path status records contain a timestamp field and a status flag field (unblocked / blocked). To calculate the percentage of unblocked time periods, the system calculates the total time spent in all records marked as unblocked (for example, 540 minutes of unblocked time periods total) and divides it by the total monitoring period duration of 1440 minutes (24 hours x 60 minutes). This yields the percentage of unblocked time periods (540 ÷ 1440 = 0.375). The path efficiency calculation unit calculates the reciprocal of this percentage: 1 divided by the percentage of unblocked time periods (1 ÷ 0.375 ≈ 2.667). The result is used as the path efficiency value (Task P001's path efficiency is 2.667). This path efficiency calculation process is performed independently for each task within the risk task group.

[0032] The feature vector integration engine operates by extracting the calculated resource contention and path efficiency values ​​for each task record that has completed the two calculations above (e.g., task P001 has a resource contention of 1.5 and a path efficiency of 2.667). This constructs a binary feature vector consisting of these two values ​​([1.5, 2.667]). The system allocates data storage space in memory for each task node in the risk task group and associates the binary feature vector data with the corresponding task node (task node P001 stores the vector [1.5, 2.667]).

[0033] The system accesses the task resource dependency database to obtain dependency records for all tasks within the risk task group. Each dependency record contains fields for the dependent task number and the dependent task number (for example, a record indicates that the execution of task P001 requires the AGV resources released by task P002). The task resource dependency topology graph is constructed by performing the following operations: creating a graph structure with each task as an independent node (nodes P001, P002, and P003). Directed edges are created between nodes based on the dependency records (for example, an edge from node P002 to node P001). Each node carries the previously stored binary feature vector data. The graph structure data is converted into an adjacency matrix for storage.

[0034] The topology processing unit loads the complete task resource dependency topology data into the graph convolutional neural network computing environment. The graph convolutional neural network is configured as a two-layer structure. The first layer performs neighborhood feature aggregation: for each task node, it collects the binary feature vector data of its first-order neighboring nodes and performs a weighted summation operation (the weighting coefficient is determined by the dependency strength coefficient of the connecting edge, with a default value of 1.0). The result is used to generate an intermediate feature vector through an activation function. The second layer repeats this feature aggregation and transformation process. Finally, the output layer performs a linear regression operation to generate the task chain conduction impedance factor value for each node (for example, the impedance factor for task P001 is 0.82). The system combines each task's task number and the corresponding task chain conduction impedance factor value into an output data record, which is written to the shared memory output queue.

[0035] Implementation requirements: The path status database must support a throughput of 1,000 write operations per second; the graph neural network computing environment must be configured with a graphics processor accelerator card with a minimum of 16GB of video memory; and the memory system must support 64GB of physical memory allocation. Abnormal data handling mechanism: When the AGV availability value is 0, the resource contention value is calculated as the square of the (AGV demand value); when the path status record is less than 12 hours old, the proportion of unobstructed time is calculated based on the corresponding data of the most recent full working day; when a circular dependency conflict is detected (for example, A depends on B, and B depends on A), the newly established dependency is automatically released. The resource contention value is a dimensionless ratio; the path transmission efficiency value is a dimensionless inverse; and the task chain transmission impedance factor value is a dimensionless regression value.

[0036] S5. Input the task chain conduction impedance factor into the gated recurrent unit model and output the AGV collaborative allocation weight of the risk task group. The specific implementation includes the following steps: The system reads the task chain conduction impedance factor numerical sequence for all tasks in the risk task group from the shared data cache (for example, risk task group G001 contains three tasks: task number P001 has a task chain conduction impedance factor value of 0.82, task number P002 has a task chain conduction impedance factor value of 1.15, and task number P003 has a task chain conduction impedance factor value of 0.73). The system accesses the task resource dependency database to query the inter-task dependency timing information for the risk task group (for example, records indicate that task P003 must be executed before task P002, and task P002 must be executed before task P001). The timing reconstruction engine reorders the task chain conduction impedance factor value sequence in the order of dependency: the task chain conduction impedance factor value of the task without preceding dependency is placed first (such as the task chain conduction impedance factor value of P003 is 0.73), and then the task chain conduction impedance factor value of the task that directly depends on the former is arranged (such as the task chain conduction impedance factor value of P002 is 1.15), and finally the task chain conduction impedance factor value of the final dependent task is arranged (such as the task chain conduction impedance factor value of P001 is 0.82), forming the impedance factor timing input vector [0.73, 1.15, 0.82].

[0037] The sorted impedance factor time series input vector is fed into the pre-trained gated recurrent unit model inference engine. Model initialization: The hidden state vector is set to a 128-dimensional array of all zeros, and the model time step count is set equal to the input vector length (3 time steps in this example). The gated recurrent unit model performs temporal correlation fusion calculations: The first step processes the input vector's first element, 0.73. A reset gate calculation determines the proportion of historical information to be retained (the reset gate weight parameters are loaded from the model file), and an update gate calculation determines the proportion of the newly added current input (the update gate weight parameters are loaded). The second step processes the second element, 1.15. Using the hidden state vector output from the previous step as the basis, the reset gate and update gate calculations are repeated. The third step processes the last element, 0.82, to complete the temporal fusion operation. The hidden state vector at the final time step is fed into the fully connected output layer and processed using a sigmoid activation function to generate the task weight parameters for each task (e.g., task P001 has a task weight of 0.36, task P002 has a task weight of 0.45, and task P003 has a task weight of 0.19).

[0038] Normalize the task weight parameters for all tasks within the risk task group: First, calculate the sum of all task weight parameters (task P001's task weight parameter of 0.36 plus task P002's task weight parameter of 0.45 plus task P003's task weight parameter of 0.19 equals 1.00). Then, divide each task weight parameter by the sum to obtain the normalized AGV collaborative allocation weight (for example, task P001's AGV collaborative allocation weight value of 0.36 ÷ 1.00 = 0.36). The system creates structured output data: the task number field stores the task identifier (e.g., "P001"), the weight field stores the AGV collaborative allocation weight value (e.g., 0.36), the normalization status flag is set to true, and a timestamp is generated to record the completion time of the process. The final data is written to the AGV collaborative allocation weight result database table for the risk task group.

[0039] Pre-training of the gated recurrent unit model is implemented using historical flexible production line scheduling data. The training dataset contains 50,000 sets of task chain conduction impedance factor time series vectors and corresponding optimal AGV collaborative allocation weight labels (the optimal weight labels are determined by production line scheduling experts based on task urgency and resource utilization). The training process uses the Adam optimization algorithm, and the loss function is defined as the mean squared error between the predicted weight values ​​and the optimal weight labels. Model structure configuration parameters: single-layer gated recurrent unit network structure, 128 hidden units, and 1 fully connected output layer node. Training termination criteria: Training is terminated when the validation set loss value decreases by less than 0.001 for 10 consecutive iterations.

[0040] Implementation Hardware Requirements: Model inference requires a graphics processor accelerator (with a single-precision floating-point computing capability of at least 5 trillion operations per second). Exception Handling: When task dependency timing information is missing, the task chain conduction impedance factor numerical sequence is sorted in ascending order by the task number character code. When the model output task weight parameter is negative or zero, the absolute value is taken and a 0.01 offset is added. When the normalized denominator (the sum of the task weight parameters) is zero or negative, each task is assigned an equal weight (the collaborative weight assigned to each task AGV = 1 ÷ the total number of tasks). All numerical values ​​generated during the calculation process are dimensionless parameters (resource contention, path conduction efficiency, impedance factor, weight parameters, etc. are all dimensionless values).

[0041] S6. Re-allocate the execution order of all tasks in the risk task group based on the AGV collaborative allocation weight and generate AGV scheduling instructions. The specific implementation includes the following steps: The system reads the AGV coordination weight data records corresponding to all tasks in the risk task group from the AGV coordination weight database (for example, risk task group G001 contains three tasks: task number P001 with an AGV coordination weight of 0.36, task number P002 with an AGV coordination weight of 0.45, and task number P003 with an AGV coordination weight of 0.19). The scheduling engine initializes the priority queue data structure and sorts all tasks in the risk task group in descending order of AGV coordination weight: first, the task with the highest AGV coordination weight is selected (for example, P002 with a weight of 0.45 is ranked first), then the task with the next highest weight is ranked (for example, P001 with a weight of 0.36 is ranked second), and finally the task with the lowest weight is ranked (for example, P003 with a weight of 0.19 is ranked third), forming the execution priority list [P002, P001, P003]. During the sorting process, tasks with the same weight are sorted in ascending alphabetical order by task number.

[0042] Task resource allocation: For each task in the execution priority list, the system accesses the task resource requirement database to obtain the task's basic resource requirement (e.g., task P002's basic resource requirement is 2 AGVs). The dynamic generator of the integer coefficient determines the current coefficient value based on the total number of AGVs in the production line's AGV cluster. This is done by obtaining the real-time total number of AGVs (e.g., 80) through the AGV position sensor network. When the total number is between 50 and 100, the integer coefficient of 10 is selected. The task allocation AGV cluster resource quantity calculation engine first multiplies the AGV collaborative allocation weight by the integer coefficient (0.45 × 10 = 4.5), applies a ceiling function to the product to obtain an integer value (4.5 → 5), and then multiplies the task's basic resource requirement by this integer value (2 × 5 = 10). The result is used as the AGV cluster resource allocation quantity for the task. The allocation quantity for each task within the risk task group is calculated using the same rules.

[0043] The time series queue generator loads the execution priority list and the AGV cluster resource allocation results to create the task scheduling time series queue data structure. Each queue element contains five fields: the order position field stores the task's index value in the execution priority list (e.g., index value 1 for P002), the task number field stores the task identifier (e.g., "P002"), the AGV cluster resource allocation number field stores the allocation result (e.g., 10 units), the planned start time field stores an ISO8601 format timestamp (e.g., "2024-07-05T10:00:00Z"), and the planned end time field stores a timestamp (e.g., "2024-07-05T10:30:00Z"). The planned start times of adjacent tasks are set: the first task's planned start time is the current system time; the subsequent task's planned start time is equal to the previous task's planned end time plus a buffer interval (the buffer interval is set to 4 minutes based on historical data statistics).

[0044] The scheduling instruction conversion process converts the task scheduling sequence queue into an executable scheduling instruction set recognizable by the AGV control system. The instruction set is encapsulated in a JSON array format. Each instruction object contains eight fields: command_id stores the instruction's unique identifier, task_id stores the task number, priority stores the execution priority value (such as 1), agv_count stores the number of allocated AGV cluster resources, start_time stores the scheduled start time, and end_time stores the scheduled end time. The command_type field is fixed to "task scheduling instruction," and the status field is initialized to "pending." In the array, instruction objects are arranged in the order of the task scheduling sequence queue (index 0 is the highest priority instruction).

[0045] Dynamic adjustment mechanism for the rounding coefficient: The system monitors changes in the total number of AGV clusters in real time and updates the coefficient value hourly. When the total number of AGVs is less than 50, the rounding coefficient is set to 5; when the total number is between 50 and 100, it is set to 10; and when the total number is greater than 100, it is set to 15. Buffer interval determination rules: Analyze the task switching time records of the production line over the past 30 days, calculate the 90th percentile value of the task switching time (e.g., 180 seconds), and add a safety margin of 60 seconds to obtain the buffer interval value (180 + 60 = 240 seconds). Calculate the planned task duration: Obtain the standard processing time for the task from the process database and multiply it by the inverse coefficient of the number of allocated AGV cluster resources divided by the basic resource requirement for the task (e.g., if the standard task duration is 60 minutes, the allocated number of 10 AGVs divided by the required number of 2 AGVs = 5 times, and the actual duration is calculated as 60 ÷ 5 = 12 minutes).

[0046] Implementation Environment Requirements: The scheduling server must be equipped with a 32-core processor and 64GB of memory, and the AGV position sensor network must support a 5Hz update frequency. Exception Handling Mechanism: When the number of allocated AGV cluster resources exceeds the upper limit of the regional AGV capacity, the system reduces the number of assigned tasks in descending order of execution priority (by one at a time) until the capacity limit is met. If a time window conflict occurs in the task scheduling time queue (e.g., the planned start time is earlier than the previous task's end time), the start time of the lower-priority task is automatically delayed while maintaining a buffer interval. If the integer coefficient calculation results in a zero allocation quantity, one AGV is forcibly assigned and an alarm log is triggered.

[0047] This embodiment, through its task coupling strength assessment mechanism (S2), distinguishes itself from the limitations of traditional dynamic priority scheduling, which only considers single-task attributes, by revealing the temporal and spatial transmission effects of resource conflicts between high-priority tasks. Constructing risk task groups based on topological connectivity (S3) transcends simple threshold filtering rules and accurately captures implicit conflict chains caused by indirect coupling. A dual-factor graph convolution fusion of resource contention and path transmission efficiency (S4) quantifies the resource congestion and diffusion characteristics of task chains, addressing the modeling bias of single resource contention metrics. Gated recurrent unit temporal modeling of task chain transmission impedance factors (S5) effectively analyzes the dynamic evolution of priority conflicts and enables causal correlation decision-making in weight allocation. The integerized coefficient resource allocation rule for AGV collaborative allocation weights (S6) avoids the resource fragmentation flaw of conventional weight allocation. These links form a technical closed loop of "conflict detection → dynamic quantification → collaborative decision-making."

[0048] Example 2: Figure 2 The present invention provides a structural diagram of a flexible production line scheduling system based on multi-AGV collaboration, which includes the following modules: Data acquisition module, used to obtain the task priorities of all tasks to be executed in the flexible production line; Conflict detection module, used to evaluate the task coupling strength between any two high-priority tasks and output the task coupling evaluation results; A risk identification module is used to identify risky task groups based on task coupling assessment results. The risky task groups are composed of tasks whose task coupling correlation strength exceeds a preset coupling threshold. The resource modeling module is used to extract the resource competition and path transmission efficiency of each task in the risk task group, and generate the task chain transmission impedance factor through the graph convolutional neural network; The collaborative decision-making module is used to input the task chain conduction impedance factor into the gated recurrent unit model and output the AGV collaborative allocation weight of the risk task group; The instruction generation module is used to redistribute the execution order of all tasks in the risk task group according to the AGV collaborative allocation weight and generate AGV scheduling instructions.

[0049] The calculations involved in the embodiments are all dimensionless numerical calculations, and the preset parameters and thresholds in the calculations are set by those skilled in the art according to actual conditions.

[0050] The above embodiments may be implemented in whole or in part through software, hardware, firmware, or any other combination thereof. When implemented using software, the above embodiments may be implemented in whole or in part in the form of a computer program product.

[0051] Those skilled in the art will appreciate that the modules and algorithm steps of each example 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 performed in hardware or software depends on the specific application of the technical solution and the invention constraints. Professional and technical personnel 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.

[0052] In addition, each functional module in each embodiment of the present application may be integrated into one processing module, or each module may exist physically separately, or two or more modules may be integrated into one module.

[0053] In the several embodiments provided in this application, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are merely schematic. For example, the division of the modules is only a logical function division. In actual implementation, there may be other division methods, such as multiple modules or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or modules, which can be electrical, mechanical or other forms.

[0054] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of this application. Therefore, the scope of protection of this application should be based on the scope of protection of the claims.

[0055] Finally: The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention should be included in the scope of protection of the present invention.

Claims

1. A flexible production line scheduling method based on multi-AGV collaboration, characterized in that: The steps include: S1. Obtain the task priorities of all tasks to be executed in the flexible production line; S2. Evaluate the task coupling strength between any two high-priority tasks and output the task coupling evaluation result; S3. Identify risky task groups based on the task coupling assessment results. The risky task groups consist of tasks whose task coupling strength exceeds a preset coupling threshold. S4. Extract the resource competition and path transmission efficiency of each task in the risk task group, and generate the task chain transmission impedance factor through the graph convolutional neural network; S5. Input the task chain conduction impedance factor into the gated recurrent unit model and output the AGV collaborative allocation weight of the risk task group; S6. Redistribute the execution order of all tasks in the risk task group based on the AGV collaborative allocation weight and generate AGV scheduling instructions.

2. The flexible production line scheduling method based on multi-AGV collaboration according to claim 1 is characterized in that: Get the task priorities of all pending tasks in the flexible production line, including: Collect task priority data of each task to be executed from the flexible production line control system in real time; The task priority data is dynamically generated by the flexible production line control system according to the urgency of the task triggering event; Task triggering events include equipment failure repair instructions and insert order production instructions.

3. The flexible production line scheduling method based on multi-AGV collaboration according to claim 1 is characterized in that: Evaluate the task coupling strength between any two high-priority tasks and output the task coupling evaluation results, including: Obtain the execution path coordinate set of each high-priority task in the current layout diagram of the flexible production line; Calculate the path overlap ratio between the execution path coordinate sets of two high-priority tasks; Get the task execution time overlap ratio of two high-priority tasks within the scheduling time window; The product of the output path overlap rate and the task execution time overlap rate is used as the task coupling association strength value of the two high-priority tasks and output as the task coupling evaluation result.

4. The flexible production line scheduling method based on multi-AGV collaboration according to claim 3 is characterized in that: The path overlap rate is equal to the ratio of the sum of the Euclidean distances of the overlapping path segments to the total length of the two task paths; the task execution time overlap rate is equal to the ratio of the overlapping duration of the two task execution periods to the total duration of the two tasks.

5. The flexible production line scheduling method based on multi-AGV collaboration according to claim 1 is characterized in that: Identify risky task groups based on the task coupling assessment results. Risky task groups consist of tasks whose task coupling strength exceeds a preset coupling threshold, including: Get the task coupling strength values ​​of all high-priority task pairs; comparing the task coupling association strength value with a preset coupling threshold; Screening high-priority task pairs whose task coupling strength exceeds a preset coupling threshold; Construct risk task groups based on the topological connectivity of the selected high-priority task pairs; Output the set of all high-priority tasks contained in the risk task group as the identification result.

6. The flexible production line scheduling method based on multi-AGV collaboration according to claim 1 is characterized in that: Extract the resource competition and path transmission efficiency of each task in the risk task group, and generate the task chain transmission impedance factor through the graph convolutional neural network, including: For each task in the risk task group, obtain the real-time AGV demand value and available value in the task area, and calculate the resource contention as the ratio of the real-time AGV demand value to the available value; For the same task, obtain the historical path operation log data of the task and calculate the path conduction efficiency as the inverse of the percentage of the path unobstructed period; The resource competition value and the path transmission efficiency value are combined into a binary feature vector, which is associated with the task node corresponding to the risk task group; Based on the resource dependency data between tasks in the risk task group, a task resource dependency topology graph is constructed, where nodes represent tasks and edges represent dependency relationships. The task resource dependency topology graph is input into the graph convolutional neural network to perform neighborhood feature aggregation operations and output the task chain conduction impedance factor value of each task node.

7. The flexible production line scheduling method based on multi-AGV collaboration according to claim 1 is characterized in that: The task chain conduction impedance factor is input into the gated recurrent unit model, and the AGV collaborative allocation weight of the risk task group is output, including: Obtain the task chain conduction impedance factor value sequence of all tasks in the risk task group; Arrange the task chain conduction impedance factor numerical sequence according to the task dependency time sequence to form an impedance factor time sequence input vector; Input the impedance factor timing input vector into the pre-trained gated recurrent unit model to perform timing association fusion operation; The task weight parameters of the tasks in the risk task group are generated through the output layer of the gated recurrent unit model; Normalize the task weight parameters of all tasks in the risk task group to obtain the AGV collaborative allocation weight value of the risk task group.

8. The flexible production line scheduling method based on multi-AGV collaboration according to claim 1 is characterized in that: Redistribute the execution order of all tasks in the risk task group based on the AGV collaborative allocation weight and generate AGV scheduling instructions, including: Obtain the AGV collaborative allocation weight values ​​corresponding to all tasks in the risk task group; Arrange the execution priority of all tasks in the risk task group in descending order according to the AGV collaborative allocation weight value; Allocate the number of AGV cluster resources to each task according to the execution priority order; Generate task scheduling time sequence queue based on execution priority order and the number of allocated AGV cluster resources; The task scheduling timing queue is converted into an executable scheduling instruction set for the AGV control system.

9. The flexible production line scheduling method based on multi-AGV collaboration according to claim 8 is characterized in that: The number of AGV cluster resources allocated to a task is equal to the number of basic resource requirements of the task multiplied by the integer coefficient of the AGV collaborative allocation weight value.

10. A flexible production line scheduling system based on multi-AGV collaboration, used to implement a flexible production line scheduling method based on multi-AGV collaboration according to any one of claims 1 to 9, characterized in that: Includes the following modules: Data acquisition module, used to obtain the task priorities of all tasks to be executed in the flexible production line; Conflict detection module, used to evaluate the task coupling strength between any two high-priority tasks and output the task coupling evaluation results; A risk identification module is used to identify risky task groups based on task coupling assessment results. The risky task groups are composed of tasks whose task coupling correlation strength exceeds a preset coupling threshold. The resource modeling module is used to extract the resource competition and path transmission efficiency of each task in the risk task group, and generate the task chain transmission impedance factor through the graph convolutional neural network; The collaborative decision-making module is used to input the task chain conduction impedance factor into the gated recurrent unit model and output the AGV collaborative allocation weight of the risk task group; The instruction generation module is used to redistribute the execution order of all tasks in the risk task group according to the AGV collaborative allocation weight and generate AGV scheduling instructions.

Images