Multi-unmanned aerial vehicle task scheduling method and system with dependence perception and feedback mechanism

Abstract

The invention discloses a multi-UAV (unmanned aerial vehicle) task scheduling method and system with a dependency perception and feedback mechanism, and the method comprises the steps: enabling a commander to input a task demand in a voice or text form, inputting the task into a large language model based on a Python prompt template in combination with environment information and UAV capability configuration, and enabling the large language model to perform task scheduling; and completing subtask disassembly and dependency modeling of the natural language instruction. The method comprises the following steps: establishing a sub-task dependency graph, and determining a sequential relationship and execution logic between tasks; in the aspect of task scheduling, capability vector modeling is carried out on all online unmanned aerial vehicles, and an optimal unmanned aerial vehicle is selected or a multi-vehicle alliance is automatically constructed to execute a task based on a vector matching degree between task skill requirements and unmanned aerial vehicle capabilities. In the task execution process, task state information is collected in real time, and all feedback information is uploaded to the cloud control center for state judgment and abnormity recognition. When the system detects an abnormal condition, task reconstruction, alliance recombination and scheduling graph repair are automatically carried out, and closed-loop adjustment of the task is completed.

Description

Technical Field

[0001] This invention relates to multi-UAV system task scheduling and execution technology, specifically to a multi-UAV task scheduling method based on a large language model with dependency perception and feedback mechanisms, belonging to the interdisciplinary technical field of artificial intelligence, intelligent control and collaborative operation of robotic systems. Background Technology

[0002] In post-disaster emergency response missions, unmanned aerial vehicle (UAV) systems are widely used for disaster reconnaissance, material transportation, and search and rescue due to their advantages of flexible deployment and rapid response. Traditional multi-UAV mission scheduling and control methods mostly adopt explicit programming and centralized control architectures, relying on fixed rules and static task models. These methods are difficult to adapt to the complex and ever-changing post-disaster mission environment, especially in situations with fuzzy instructions, diverse mission types, and heterogeneous agents. They exhibit prominent problems such as strong scheduling rigidity and poor adaptability, which seriously restrict system efficiency and mission completion quality.

[0003] In practical applications, rescue missions often involve command centers issuing vague task instructions in natural language based on disaster assessment results, such as "proceed to point A to carry out a rescue mission." These high-level instructions require the system to have the ability to accurately parse semantic information into a sequence of executable actions, realizing the transformation from "language to action." Simultaneously, it also needs to rapidly coordinate heterogeneous drone swarms to complete various tasks, such as communication restoration, resource delivery, area scanning, and defect detection. This places extremely high demands on the task understanding and dynamic allocation capabilities of traditional systems.

[0004] Large Language Models (LLMs) have shown great potential in multi-agent task systems in recent years due to their powerful semantic understanding and reasoning capabilities. LLMs can parse natural language tasks into structured operational processes, providing executable task planning schemes for unmanned aerial vehicle (UAV) systems and enhancing the system's autonomous decision-making capabilities and interactive intelligence. However, most existing LLM-driven collaborative methods are limited to virtual simulation environments or single-robot task planning, lacking feasibility verification on real UAV platforms and failing to effectively address issues such as communication latency, path uncertainty, and delayed task feedback in actual UAV deployments. Furthermore, related research methods such as SayCan, SWARM-LLM, and SMART-LLM, while making attempts in language-to-action planning and feedback enhancement, suffer from drawbacks such as focusing only on single agents, ignoring UAV sub-task dependencies, and neglecting real-time reasoning feedback from edge UAVs. Particularly for complex rescue processes requiring handling task order and concurrent structures, current methods still lack a general scheduling framework, resulting in low action execution success rates and inefficient resource coordination in real-world scenarios.

[0005] In summary, current LLM-driven multi-UAV cooperative scheduling still faces three key challenges: First, it lacks efficient structured mapping capabilities from natural language to task action sequences; second, it lacks explicit modeling mechanisms for dependencies between subtasks, resulting in insufficient task ordering and concurrent execution strategies; and third, it lacks dynamic adjustment mechanisms driven by edge feedback, leading to a lack of closed-loop control capabilities for task execution and consequently, low completion rates for complex tasks. Therefore, a novel multi-UAV cooperative scheduling method is urgently needed, integrating large language model understanding capabilities, task dependency modeling capabilities, and action feedback perception capabilities to improve the intelligence, robustness, and response efficiency of multi-agent task execution in post-disaster emergency scenarios. Summary of the Invention

[0006] Purpose of the invention: This invention aims to overcome the key problems of existing multi-UAV collaborative scheduling technology in post-disaster emergency mission execution, such as inaccurate natural language command parsing, insufficient task dependency modeling, and lack of feedback adjustment mechanism in the execution process. It proposes a multi-UAV task scheduling method and system based on a large language model with dependency perception and feedback mechanism.

[0007] This invention introduces a structured prompt word construction strategy to guide a large language model to decompose natural language instructions into tasks and establish a dependency graph between subtasks, achieving efficient mapping from fuzzy language instructions to ordered executable task sequences. Furthermore, by combining UAV skill capability modeling and vector matching mechanisms, it enables dynamic formation of multi-UAV alliances and precise task allocation. During the task execution phase, a lightweight edge language model is used to record action feedback during execution and transmit the feedback information back to the cloud, enabling dynamic adjustment of the task plan and closed-loop scheduling control, thereby improving the system's adaptability and task success rate in complex task scenarios.

[0008] The method of this invention is applicable to the collaborative scheduling problem in post-disaster emergency rescue missions, which involves high dynamism, multi-task dependence, and multi-agent heterogeneity. It has advantages such as strong natural language understanding ability, high task allocation accuracy, and complete feedback adjustment mechanism. It significantly improves the mission execution efficiency, stability, and intelligence of multi-UAV systems in complex scenarios, and aims to solve the problems of untimely response and low success rate of existing methods in complex mission planning and execution.

[0009] Technical Solution: A multi-UAV task scheduling method with dependency perception and feedback mechanisms is proposed. This method integrates large language model reasoning, task dependency modeling, heterogeneous UAV alliance scheduling, and action feedback adjustment for multi-UAV task allocation and execution. The overall architecture adopts a "cloud-edge collaboration" approach, organically combining natural language task understanding capabilities with edge-side action feedback control mechanisms to achieve efficient collaborative scheduling and autonomous execution of multi-UAV swarms in complex post-disaster task scenarios.

[0010] During the task reception phase, structured Python prompts are constructed, and a large language model (GPT-4o and DeepSeek-R1) deployed in the cloud is invoked to perform semantic understanding and step-by-step reasoning on the received natural language task instructions. The model automatically decomposes the task according to the instruction intent, outputting multiple subtasks with clear operational goals and input / output requirements, and generating natural language descriptions and structured parameters for each subtask. In this process, the large model can identify and retain the contextual dependencies and temporal information of the original task, providing a structural foundation for subsequent scheduling and graph construction.

[0011] In the task modeling phase, a task dependency graph is constructed based on the subtask order and logical relationships output by the large language model. A directed acyclic graph (DAG) is used to model the sequential relationships, conditional dependencies, and data flow between subtasks. This dependency graph clearly indicates which tasks can be executed in parallel and which must wait for the completion of their preceding tasks, serving as the core data structure for achieving rational task-level scheduling.

[0012] During the task scheduling phase, heterogeneous capability modeling is performed for each UAV, including its flight parameters, payload capacity, sensor configuration, and remaining energy, which are uniformly encoded into skill vector representations. Simultaneously, the skill requirements of subtasks are transformed into task vectors, and the similarity score between UAVs and subtasks is calculated using semantic vector matching. Based on the directed acyclic graph generated during the task modeling phase, a topological order is established, and a UAV alliance meeting the current task requirements is formed under skill matching constraints. This enables many-to-many allocation of subtasks to the alliance and generates an executable scheduling plan graph.

[0013] During the mission execution phase, each sub-task is completed collaboratively by drones within the alliance. Alliance members record the mission execution status and detect anomalies (including path deviation, image acquisition failure, and battery warnings) using lightweight language models deployed at the edge (locally fine-tuned models), and upload these as structured logs to the cloud-based large model interface. The cloud system dynamically determines whether the current scheduling plan needs adjustment based on the feedback information, and triggers adaptive control actions such as sub-task reallocation and alliance restructuring when necessary, ensuring the method possesses closed-loop feedback capabilities and dynamic scheduling flexibility.

[0014] This invention realizes a complete scheduling closed loop from "natural language command input → task decomposition and dependency modeling → skill matching and alliance scheduling → edge feedback and closed-loop adjustment", effectively solving key problems in post-disaster emergency missions such as difficulty in converting natural language into action, inability to model task logic, high scheduling rigidity and lack of execution feedback mechanism, and significantly improving the response efficiency, collaborative ability and mission success rate of multi-UAV systems in complex environments.

[0015] The method includes the following: (1) Natural language command input By constructing structured Python prompts, user-inputted natural language task instructions are fed into a large language model deployed in the cloud for semantic analysis and hierarchical reasoning. Based on the user input and the structured Python prompts, the large language model converts the user input into structured task descriptions and breaks down the task, generating a task sequence consisting of multiple operational and independent subtasks. Each subtask includes a structured description of the task type, operation object, target region, and execution conditions. The Python prompts designed in this invention employ a three-layer structure of comments, examples, and grammatical organization, improving the language model's understanding accuracy and output stability.

[0016] (2) Task decomposition and dependency modeling Building upon subtask generation, the sequential constraints and logical relationships between tasks are further identified, establishing a dependency structure graph between subtasks. Dependency modeling employs a directed acyclic graph (DAG), where nodes represent subtasks and edges represent sequential or resource dependencies. This dependency graph construction process combines task semantic structure and example learning mechanisms, automatically output by a large language model or constructed after parsing using a topological sorting algorithm, ensuring that task scheduling has a clear execution order and reasonable concurrency logic. This dependency structure will serve as the core constraint basis for subsequent multi-UAV task allocation and scheduling.

[0017] (3) Skill matching and alliance scheduling Capability vector modeling is performed on each drone, extracting its hardware parameters, skill tags, and state attributes, and encoding this information into skill feature vectors. The skills required for each subtask are also encoded in vector form. A semantic matching strategy is used to calculate the skill similarity score between the task and the drone. Under the premise of satisfying dependency constraints, a drone alliance is automatically constructed, and subtasks are dynamically assigned. This step ensures that tasks are assigned to the optimal alliance combination, maximizing the success rate of task execution and resource utilization efficiency.

[0018] (4) Edge feedback and closed-loop regulation During mission execution, a lightweight model is deployed at the edge to record UAV action feedback, execution status, and abnormal events, and the feedback logs are transmitted back to the cloud in real time. The edge-deployed lightweight model uses feedback information to determine whether the task is completed, whether there are failures or delays, etc. If an anomaly occurs, it triggers task reallocation, alliance adjustments, or dependency refactoring, achieving adaptive closed-loop adjustment of task scheduling. This mechanism improves system robustness and ensures stable and efficient operation of multi-UAV systems in dynamic post-disaster environments.

[0019] Furthermore, the specific steps for inputting the content (1) natural language commands are as follows: (1.1) Python prompt word construction: Compared with natural language prompt words, Python-formatted prompt words have stronger structured expressive power, which can reduce linguistic ambiguity and improve executability and parsing efficiency. This invention significantly improves the inference accuracy and output stability of the model in task decomposition and scheduling mapping by designing Python prompt templates for large language models. The prompt words designed in this invention include: (1a) Line comments: help the LLM understand the meaning of each step in converting user input information into structured task description information; for example, add the comment "# Define the context and taskdescription" before defining the task description variable to prompt the model that the statement is a semantic expression of the task objective; add "# Define environment information" before the environment information field to make the model clear about the source of the information; add "# Define the UAV skills" before defining UAV skills information to help the model understand the skill allocation logic.

[0020] (1b) Block annotation: Provide a task summary for each step to help the LLM capture the overall goal of the task; for example, adding the annotation "# Please decompose the task into several executable sub-tasks and generate their dependencies based on the following task description, environmental state and drone skill set" at the beginning can effectively improve the large language model's grasp of the overall intent of the prompt words and help it generate a logically complete and structurally ordered sequence of sub-tasks during the reasoning process.

[0021] (1c) Skill Encoding: The skill information of the UAV is organized using a Python dictionary structure, with each UAV ID as the key and the corresponding skill set as the value. Skill names use standardized English phrases, such as "MoveToObject", "ProvideBaseStation", "Takeoff", and "Landing". This structured skill encoding method enables large language models to directly extract keywords from the skill set for judgment when matching tasks and executors, thereby improving the efficiency of skill matching between UAVs and tasks and avoiding ambiguity and redundancy caused by vague language descriptions.

[0022] The constructed Python prompts are concatenated into a complete text block, which is then input into a large language model deployed in the cloud via API or internal inference interface, triggering the large language model to perform multi-step inference and task structure generation. This structured design not only improves the clarity of the logical expression of the prompts but also significantly reduces the token size required for model inference, reduces contextual redundancy, and improves the efficiency of the language model in decomposing complex tasks and the accuracy of subtask outputs.

[0023] Furthermore, the content (2) task decomposition and dependency modeling refers to the fact that after the initial generation of subtasks, in order to ensure that the subtasks are presented in a structured form, the system needs to perform reasoning again through a large language model to structurally model the execution order, logical dependencies, and resource constraints between each subtask. This step adopts a method combining task semantic analysis and dependency graph generation to output a directed acyclic graph as the key structure for scheduling control and execution coordination. The purpose of dependency modeling is to ensure the correctness, parallelism, and optimal scheduling of task execution. This invention adopts a two-step method of "semantic decomposition + task dependency graph modeling". First, the boundaries of subtasks are refined through semantic parsing; second, the structured modeling of the dependency relationships between tasks is achieved by constructing a directed acyclic graph.

[0024] (2.1) Semantic Decomposition: After task decomposition, the semantic structure of the subtasks is further refined to clarify task boundaries and operational objectives. This process is completed by the DeepSeek-R1 large language model. The model input consists of a task description constructed using Python prompts, environmental information, the UAV skill set, and a preliminary list of subtasks. Based on contextual reasoning capabilities, the model outputs a structured set of subtasks.

[0025] The goal of this process is to break down complex natural language task instructions into multiple operational subtasks with clear objectives and assignability. Taking the task "Communication at point A is restricted, requiring supply delivery" as an example, it can be broken down into independent subtasks such as "Obtain the coordinates of point A," "Restore communication," and "Deliver supplies." The specific steps include: (2a) Task parsing and target extraction: First, perform multiple rounds of semantic analysis on the task instructions to identify core operation targets (such as "communication recovery" and "material delivery"), key objects (such as "point A") and target status (such as "restricted" and "not delivered"), and divide the task units that can be executed independently based on this information.

[0026] (2b) Subtask decomposition and skill extraction: Based on the subtask sequence initially generated by the large language model, the structured Python prompt words, and the user input information, further generate structured subtasks with clear task boundaries and operation goals, and at the same time extract the skill set required for each subtask (such as "MoveToObject", "ProvideBaseStation", "Provide Material", etc.) as input for subsequent coalition matching.

[0027] (2.2) Task Dependency Graph Modeling: After task decomposition, the execution order relationship between subtasks is structurally modeled. The dependency relationship is represented by a directed acyclic graph. Each node represents an executable subtask, and directed edges represent dependencies, meaning that the target node task can only start after the source node task is completed. Furthermore, there are no loops in the graph, ensuring the topological stability of task scheduling.

[0028] The task dependency extraction process employs two methods: one is the dependency structure directly output by the model (such as nested steps or relational tables); the other is automatic judgment based on the semantic structure of the subtasks. The judgment logic includes whether there is spatial resource sharing (such as overlapping locations or objects); whether there are explicit semantic temporal connectors (such as "first", "after", "after completion"); and whether skill reuse occurs (such as shared navigation for path planning and material transportation).

[0029] Furthermore, the content (3) skill matching and alliance scheduling refers to, based on the completion of subtask decomposition and the construction of dependency graphs, accurately matching tasks to drones or drone alliances with corresponding capabilities according to the skill requirements of each subtask, and generating a scheduling execution graph based on the task dependency structure. This step aims to optimize the allocation of drone capability resources and improve task execution efficiency and system responsiveness.

[0030] (3.1) UAV skill capability modeling: First, capability modeling is performed for each UAV participating in the mission, mainly including hardware parameters such as maximum endurance, flight speed, and payload capacity; mission skill tags such as "path navigation," "image acquisition," "communication relay," and "supply delivery"; and status attributes such as current location, remaining battery power, and current load status. The capability information after capability modeling is represented in a vectorized structure and stored as a UAV capability vector set for subsequent matching and retrieval.

[0031] (3.2) Subtask Skill Extraction and Vector Matching: For each subtask, the set of skills required for its execution is extracted. This set is output by the large language model during the task decomposition stage, or automatically identified by the system based on task semantics. The task skill requirements are also encoded as task skill vectors. Subsequently, cosine similarity, vector inner product, and other methods are used to calculate the skill matching score between each UAV and each subtask.

[0032] (3.3) Alliance Construction and Allocation Strategy: To meet the execution requirements of multi-skill combination sub-tasks or highly complex sub-tasks, the system supports the construction of "drone alliance" execution units. That is, for a task, if no single drone can independently meet its skill requirements or resource conditions, the system will select several drones with the highest matching degree from the entire drone set to form an alliance, creating a collaborative execution unit. The alliance construction follows the following strategy: (3a) Skill coverage priority: First, ensure that there is at least one drone in the alliance that can fulfill each skill requirement; (3b) Minimize capability redundancy: Under the premise that the skills are fully met, select the minimum number of drones to participate in the alliance to reduce communication complexity and scheduling load; (3c) State weight balancing: Prioritize drones with lighter current task load, higher battery level, and located near the execution area.

[0033] (3.4) Task scheduling graph construction and dispatch: Based on the task dependency graph and the coalition matching results, a scheduling graph is generated to guide task assignment and concurrent execution planning. The scheduling graph is a weighted directed graph, where nodes represent subtask execution units, edges represent dependencies, and additional fields include task ID, execution coalition ID, expected execution time window, feasible start time point, and task resource usage.

[0034] The scheduling graph supports dynamic updates and has topology sorting capabilities, enabling the system to distribute task batches in rounds according to dependency levels. The distribution process supports a batch task delivery mechanism. After confirming that the alliance is ready, the task allocation list and the required execution parameters (including task location, required drone capabilities, etc.) are packaged and sent to the corresponding drone terminals of each alliance via control commands, triggering the task execution process.

[0035] This invention enables efficient resource allocation and collaborative execution of multiple UAVs during mission execution, effectively improving the system's response efficiency, execution robustness, and energy utilization in complex post-disaster missions.

[0036] Furthermore, the aforementioned content (4), edge feedback and closed-loop adjustment, refers to the real-time monitoring and feedback recording of the task execution status through lightweight perception and inference modules deployed locally on each UAV during the execution of scheduling tasks by a multi-UAV system. The feedback results are then uploaded to the cloud scheduling system, thereby achieving dynamic perception of the task execution status, adaptive adjustment of scheduling results, and closed-loop control of system operation. This mechanism is a key link in building a highly reliable multi-agent collaborative system, and is particularly suitable for application scenarios with high risk of task failure and strong path uncertainty in post-disaster environments.

[0037] (4.1) Edge Feedback Acquisition Mechanism: To achieve real-time monitoring and feedback recording during task execution, each UAV executing a task is equipped with an edge feedback acquisition module. This module has basic data perception capabilities, continuously monitors the UAV's operational status, and records execution events according to task type. This module is implemented through a state judge and a lightweight language model, and runs on the UAV's onboard processing unit.

[0038] During task execution, the feedback module monitors key actions for each subtask, such as entering the target area, performing specific operations (e.g., establishing communication, releasing supplies, acquiring images), and uploading completed signals. Once an action is completed or interrupted, an action execution record is automatically generated. This record includes not only the task number, action type, start and end times, but also core fields such as whether the execution was successful, exception flags, and error type labels (e.g., "target not reached," "course deviation," "equipment not responding").

[0039] In addition, to ensure the continuity of feedback and data integrity, a local log caching mechanism is adopted. Action logs are formatted as structured data (JSON objects), written to the drone's local cache, and then uploaded to the cloud dispatch center via the 4G / 5G communication module. If communication is interrupted, the logs will be cached with a delay and automatically resent after the network is restored to avoid data loss.

[0040] (4.2) Feedback Upload and Summary Judgment: Edge feedback information from each UAV is uploaded to the cloud scheduling center via the communication link during mission execution. The scheduling center continuously monitors the feedback data stream and classifies, aggregates, and performs semantic judgment on it to accurately identify abnormal states and violations during mission execution. Each time the scheduling center receives an action feedback log, it matches it with the corresponding sub-task node in the scheduling graph and updates the execution status of that task node.

[0041] The dispatch center's processing logic for feedback logs includes three parts: task status comparison, execution path verification, and exception type attribution. First, it checks whether the task started on time and completed successfully, judging by criteria such as whether it entered the designated target area, completed the target action, and reported its status in a timely manner. Second, it compares the task dependency graph structure to check for violations such as "premature execution of subsequent tasks," "missing critical paths," or "failure to meet prerequisites." Finally, if the task execution fails, the cause of failure is attributed based on the status code and error type field recorded in the feedback log, such as "path blockage," "image acquisition failure," "payload release failure," or "insufficient power," and then structurally marked.

[0042] All judgment results are integrated into a task execution status matrix, where each row represents a subtask, and each column contains information such as the task's current status (e.g., "success", "failure", "abnormal interruption", "waiting"), feedback timestamp, failure reason, and scheduling repair suggestions. This matrix serves as the input carrier for the subsequent closed-loop scheduling adjustment mechanism, realizing the organic linkage from feedback perception to system response.

[0043] (4.3) Closed-loop scheduling adjustment mechanism: Upon detecting a subtask execution failure, abnormal UAV response, or task execution order violation, the cloud-based scheduling center will initiate a scheduling repair process to dynamically reconstruct the original scheduling graph. The goal of scheduling repair is to restore the executability of the scheduling graph to the minimum extent possible, while maintaining dependency chain constraints and the principle of optimal resource allocation.

[0044] First, based on the task execution status matrix, the task nodes that need to be reassigned are located. For isolated failed tasks, priority is given to selecting drones that are currently idle, possess the required skills, and are closest to the task objective for alternative scheduling. If the failed task was originally to be executed by an alliance, the system will remove the faulty member from the alliance and automatically add a new member through a matching strategy to reconstruct the alliance composition.

[0045] Secondly, for path breaks caused by dependency failures, the system will roll back to the most recent successfully executed node based on the dependency graph's topology, and reactivate all subtasks on subsequent paths. Simultaneously, the scheduling center supports a flexible dependency refactoring mechanism, allowing skipping non-critical path tasks or using equivalent alternative task chains under specific conditions, improving scheduling recovery efficiency. After refactoring, a new scheduling graph is generated, including the updated subtask execution order, the new alliance allocation structure, and estimated start and end times. The new scheduling graph is then distributed to the relevant drones via the communication module, allowing task execution to resume and re-enter the closed-loop cycle of execution → feedback → adjustment.

[0046] This scheduling and repair mechanism ensures that multi-UAV systems have robust adaptability and mission continuity in highly dynamic environments, significantly improving overall mission success rate and stability.

[0047] Through the aforementioned edge feedback acquisition, state determination analysis, and scheduling adjustment linkage mechanism, this invention realizes a closed-loop control chain from task scheduling planning to execution feedback and then to dynamic updates, which significantly improves the system's stability, task completion rate, and system resilience in dynamic and uncertain task environments such as after disasters, and has the technical advantages of high reliability and multi-agent adaptive collaboration.

[0048] Furthermore, by applying the above methods to a post-disaster emergency drone mission scheduling system, it is possible to achieve rapid response to mission instructions in disaster-stricken areas, automatic understanding of mission objectives, and intelligent allocation and collaborative scheduling execution of drone swarms in emergency scenarios such as earthquakes, floods, and building collapses. This invention can significantly improve the efficiency of emergency mission deployment, solving the problems of slow response, mission conflicts, and high failure rates in traditional manual scheduling methods when time is tight and the environment is dynamic and complex. It ensures that core needs in disaster areas (such as communication relay, material delivery, and area detection) are completed in an orderly and efficient manner.

[0049] The post-disaster emergency drone mission scheduling system includes: The Natural Language Task Input Module receives natural language task instructions submitted by rescue personnel via voice, text, or control terminals. The system uses embedded structured Python prompt templates to convert these instructions into a standard task request format, including a task description, environmental information (such as communication status and terrain obstacles), and a list of available drone skills. This module then passes the standardized input as a prompt to the cloud-based large language model, triggering the task decomposition process.

[0050] Task parsing and dependency modeling module: This module is responsible for receiving the set of subtasks and their execution order information returned by the large language model. The system transforms the parsed results into a task execution graph, using a directed acyclic graph structure to encode the logical dependencies between tasks, such as prerequisite tasks, concurrent tasks, and conditional triggers. The parsed task structure will serve as the core logic input of the scheduling system, used to control the execution order and determine task dependencies.

[0051] Skill Matching and Alliance Scheduling Module: This module maintains the capability resource pool of all current drones, including each drone's skill tags (such as "image acquisition," "navigation," "resource release," etc.), platform parameters (such as endurance, flight speed), and real-time status (such as battery level, location). The skill requirements of sub-tasks are converted into task skill vectors after model output or automatic extraction. The system calculates the matching degree using a vector matching algorithm. If a single drone cannot complete the task independently, multiple drones are selected from the drone pool to form an execution alliance, generating a task-alliance mapping table and forming a scheduling plan.

[0052] Edge Feedback and Closed-Loop Adjustment Module: This module consists of a local edge execution feedback unit on the drone and a cloud-based status analyzer. During execution, the drone continuously records the execution status (success, failure, deviation, interruption), generates structured logs, and uploads them periodically or triggered by events. The cloud system compares all feedback data with the task status. If issues such as task failure, drone disconnection, or scheduling path conflicts are detected, the scheduling plan will be automatically reconstructed, the execution alliance will be rematched, and an updated execution graph will be issued, thus forming a closed-loop control mechanism for task execution.

[0053] The implementation process and methods of the system are the same, and will not be repeated here.

[0054] A computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the multi-UAV mission scheduling method with a dependent perception and feedback mechanism as described above.

[0055] A computer-readable storage medium storing a computer program, which, when executed by a processor, implements the multi-UAV mission scheduling method with a dependency perception and feedback mechanism as described above.

[0056] Beneficial Effects: Compared with existing multi-UAV scheduling methods, this invention addresses the problems of slow response, reliance on manual planning, difficulty in handling complex dependency task structures, and lack of execution feedback control in traditional scheduling schemes. It proposes a scheduling method with semantic understanding, structural modeling, skill matching, and dynamic feedback closed-loop control capabilities. By introducing a large language model to structurally decompose natural language task instructions and construct a task dependency graph, it can automatically convert ambiguous instructions into clear task flow structures, significantly reducing the human cost and response time of task planning. The method achieves precise adaptation between subtasks and UAVs through a capability vector matching mechanism and automatically forms alliances when UAV resources are insufficient, achieving skill synergy coverage and task load balancing. During task execution, the edge module monitors the real-time status of each action node and uploads task execution logs to the cloud for aggregation and judgment, thereby dynamically identifying failed tasks, resource anomalies, and dependency conflicts. It also supports automatic task reallocation and alliance reconstruction, constructing a task closed-loop control mechanism of "task decomposition → scheduling execution → feedback perception → dynamic repair". The scheduling method of this invention has high intelligence, adaptability and task fault tolerance, and can be widely applied to high-uncertainty multi-UAV mission environments such as post-disaster relief, urban inspection and battlefield deployment. It effectively improves the completion rate, resource utilization and scheduling robustness of multi-UAV missions, and has significant engineering practical value and social security significance. Attached Figure Description

[0057] Figure 1 This is a flowchart of a method according to an embodiment of the present invention; Figure 2 This is a functional block diagram of an embodiment of the present invention; Figure 3 This is a subtask dependency diagram for instruction decomposition in an embodiment of the present invention. Detailed Implementation

[0058] The present invention will be further illustrated below with reference to specific embodiments. It should be understood that these embodiments are for illustrative purposes only and are not intended to limit the scope of the invention. After reading the present invention, any modifications of the present invention in various equivalent forms by those skilled in the art will fall within the scope defined by the appended claims.

[0059] like Figure 1 As shown, the multi-UAV task scheduling and execution method based on a large language model with task dependency perception and action feedback capabilities includes the following steps: (1) Natural language command input (1.1) Python Prompt Construction: Users input task requirements in natural language via the terminal, such as "Deliver 70kg of supplies to point A". This method organizes the task description, environmental information, and UAV skill list into structured Python prompts to guide the large language model in decomposing and reasoning about the task. The prompts include the following three key components: Task description annotation: used to explain the task objectives and context, such as "# Define the context and task description", to clarify the semantic role of the code segment; Environment object description annotation: such as "# Define environment information", listing the key locations and status information involved in the task (such as "Communication is restricted at point A", "Supplies not delivered"); UAV skill dictionary structure: representing each UAV number and its corresponding skill list in Python dictionary format, with skill tags using standard English phrases, such as "MoveToObject", "Takeoff", "Provide Material", so that the large language model can clearly understand the execution capabilities of each UAV. In addition, the prompts also include several example task decomposition guides to help the language model learn the logical rules of subtask decomposition and skill allocation, thereby improving the consistency and accuracy of reasoning.

[0060] The aforementioned prompt words are concatenated into a semantically clear and structurally stable text block, and transmitted via API to the cloud-based large language models GPT-4o and DeepSeek-R1. GPT-4o is used to process simple text information; its low latency (average 320 milliseconds) and multilingual optimization make it suitable for real-time task inference feedback. DeepSeek-R1 is used to process complex task-dependent information; it excels in mathematical and logical reasoning and long text processing, and has excellent Chinese support. After receiving the prompt words, the model automatically initiates the task parsing process based on its natural language inference capabilities, outputting a structured list of subtasks and their execution semantics.

[0061] as follows Figure 2As shown, in the task "Deliver 70kg of supplies to point A," a complete structured Python prompt was constructed based on the user's natural language input, including information such as "# Define the context and task description" mentioned above. This prompt clearly identifies the task target "point A" and the task object "70kg of supplies," and describes contextual information such as regional communication status and supply delivery status through environment fields. Simultaneously, the prompt provides the skill set of currently available UAVs in a standard dictionary structure; the example shows that UAV1 supports "MoveToObject" and UAV2 supports "Provide Material." Through annotation tags and field structures, the prompt effectively organizes the task context, environmental features, and UAV capabilities, providing a clear and structured input context for the large language model to accurately understand the task intent and execution constraints.

[0062] (2) Task Decomposition and Dependency Modeling: After the initial generation of subtasks, the initially generated subtasks need to be structured again to ensure subsequent structured modeling. The execution order, logical dependencies, and resource constraints between subtasks need to be structured. This step uses a combination of task semantic analysis and dependency graph generation to output a directed acyclic graph, which serves as the key structure for scheduling control and execution coordination. The purpose of dependency modeling is to ensure the correctness, parallelism, and optimal scheduling of task execution. This invention adopts a two-step method of "semantic decomposition + task dependency graph modeling." First, the boundaries of subtasks are refined through semantic parsing; second, the structured modeling of dependencies between tasks is achieved by constructing a directed acyclic graph.

[0063] (2.1) Semantic Decomposition: After the model initially generates subtasks as mentioned in (1), the semantic structure of the subtasks needs to be further refined to clarify the task boundaries and operational objectives. This process is completed by the deep reasoning function of the DeepSeek-R1 large language model deployed in the cloud. At this time, the model input is the initially generated list of subtasks, the task description constructed by Python prompts, environmental information and UAV skill set, and specific prompts such as "clarify the subtask boundaries based on the Python structured prompts and the subtask list: the subtask operation required, the subtask operation objective, the UAV skill required for the subtask, etc." The DeepSeek-R1 model outputs a structured set of subtasks based on contextual reasoning capabilities, and adds operational objectives, execution conditions and required skills to each subtask. The goal of this process is to decompose complex natural language task instructions into multiple operational subtasks with clear objectives and executable capabilities, further interpret the user's natural language input information, and ensure that tasks can be effectively scheduled and resources matched.

[0064] as follows Figure 2 As shown, when the user inputs the task "go to point A to deliver 70kg of supplies", the model first identifies "point A" as the key spatial location, and "communication restoration" and "supply delivery" as the two core target behaviors; at the same time, it parses the environmental context state (such as "communication at point A is restricted" and "supplies have not yet been delivered") from the prompt words constructed in (1), and initially generates two sub-tasks: restore communication at point A and go to point A to deliver supplies. After that, it is necessary to further decompose the sub-tasks to confirm that the sub-tasks are presented in a structured state, and further call the DeepSeek-R1 model in the cloud to generate the following sub-task structured information: {"Sub-task ID": "Task-01","Task Name": "Locate and move to point A","Operation Target": "Point A (location: X1, Y1)","Preconditions": "UAV take-off completed","Execution Conditions": "UAV1 has MoveToObject skill","Required Skills": ["Takeoff", "MoveToObject"],"Assign UAV": "UAV1"}. Through this semantic decomposition process, the method establishes a logical hierarchy of the task's internal structure, laying a semantic foundation for subsequent dependency modeling and scheduling execution.

[0065] (2.2) Task Dependency Graph Modeling: After semantic decomposition, the execution order, logical dependencies, and resource constraints among all identified subtasks are structurally modeled to generate a task dependency graph. This dependency graph is constructed using a directed acyclic graph structure, where each node represents a schedulable subtask, and directed edges represent dependencies. That is, the task corresponding to the source node must be completed before the task of its target node can begin execution, ensuring the orderliness and safety of task execution.

[0066] This invention employs two main methods for task dependency extraction: First, the DeepSeek-R1 model can directly output nested structures or dependency tables based on the generated subtask list. Second, it can automatically determine dependencies based on the semantic structure of the subtasks. The determination logic includes, but is not limited to: whether there is spatial resource sharing (e.g., overlapping execution regions), whether it contains temporal conjunctions (e.g., "first," "after," "after completion"), and whether there is skill reuse (e.g., shared navigation paths). The resulting directed acyclic graph will serve as the foundational data structure for task scheduling, scheduling graph generation, and execution coordination.

[0067] After DeepSeek-R1 returns a preliminary dependency table, it doesn't directly use this structure as the final scheduling basis. Instead, it further refines and cross-validates the task semantic structure using a second approach. A topological sorting method is employed to review the spatial, resource, and temporal elements of the execution scenario against the model's output dependencies, identifying potentially overlooked implicit dependencies or conflicting paths. For example, if two subtasks, though not explicitly labeled with their sequential relationship, have overlapping operational regions or competing resource scheduling, corresponding dependency edges will be automatically added to ensure the safety and correctness of the scheduling process. Simultaneously, semantic hierarchy reconstruction is performed using temporal expressions in task annotations to correct inconsistent or potentially ambiguous dependency directions. Through this rule enhancement and graph structure completion mechanism, robust verification of the language model's generated results and optimization of the scheduling structure can be achieved, ensuring that the final generated task dependency graph meets the requirements of orderliness, conflict-free operation, and optimal scheduling.

[0068] The task dependency paths extracted in the above manner will be converted into a directed acyclic graph structure, which will serve as the core basis for task scheduling, sorting, and batch dispatch.

[0069] as follows Figure 3 As shown, the language model outputs four subtasks I1 to I4 based on the input task. After analyzing the logical relationships between the subtasks, it is identified that I2 depends on I1, I3 depends on I1, and I4 depends on both I2 and I3. Therefore, the following dependency structure is generated: subtask I1 has no prerequisite dependencies and can be executed first; subtasks I2 and I3 must be started after I1 is completed; subtask I4 must wait for both I2 and I3 to be completed before it can be executed.

[0070] (3) Skill matching and alliance scheduling: Based on the completion of sub-task decomposition and the construction of dependency graphs, it is necessary to match drones or drone combinations with corresponding capabilities according to the skill requirements of each sub-task, and construct a scheduling execution graph for actual scheduling and dispatch. The goal of this step is to achieve optimized allocation of multi-drone resources, improve the parallel efficiency of task execution, matching accuracy and multi-drone response capability.

[0071] (3.1) UAV skill capability modeling: First, a unified capability model is performed on the currently available UAV resources. The capability modeling content of each UAV includes the following three dimensions: platform parameters, including maximum endurance, flight speed, maximum payload capacity, etc.; task skill tags, including functional action tags such as "path navigation", "communication relay", "image acquisition", "material delivery", "visual recognition", etc., indicating the execution skills of the UAV; status attributes, including current location information, battery level, payload status, idle / busy status, etc.

[0072] The above information is encoded into a unified capability vector structure, which stores the drone's capabilities in a custom vector pool for subsequent similarity calculation with sub-task skill requirements.

[0073] (3.2) Subtask Skill Extraction and Vector Matching: After completing the construction of the UAV capability vector pool, the skill requirements of each subtask need to be extracted and vectorized to achieve accurate UAV matching and task allocation in the future. The first step in this process is to extract the skills required for the task. With the help of the function mentioned in (2.1) above, the skill information of the subtask can be directly returned by the DeepSeek-R1 large language model in the task generation stage, or it can be automatically identified through the built-in semantic parsing module. Specifically, it will combine fields such as task name, operation target, and task description to analyze the action intentions and functional requirements involved, and then extract standardized skill tags, such as "path navigation", "material delivery", and "visual recognition".

[0074] After extraction, these skill tags are encoded into structured skill vectors with dimensions consistent with the UAV's capability vectors for matching and evaluation. The construction of skill vectors considers not only whether a skill is possessed (i.e., a 0 / 1 flag) but also introduces weight differences when the actual task requirements are clearly defined. For example, high-priority critical skills, such as "communication deployment" or "navigation accuracy," can be assigned higher weights to highlight their importance in the matching calculation. Furthermore, for complex tasks, it supports packaging multiple skills into a single skill cluster to improve matching efficiency.

[0075] After the skill vectors are constructed, a matching calculation is performed between each task skill vector and the drone's capability vector. The matching algorithm mainly uses two mainstream methods—cosine similarity and weighted vector inner product—to evaluate the closeness between the two, and is further optimized by combining real-time status information (including current battery level, location, and battery health). Finally, a "matching score" is output to measure whether each drone is suitable for a specific task. To ensure the effectiveness of scheduling, this score reflects not only the matching degree at the skill level but also the combined impact of resource status and spatial location on scheduling feasibility.

[0076] Based on the scoring results, drones scoring above a set threshold (default 0.8) are included in the candidate list and labeled with priority and scheduling tags. This process enables the rapid selection of the optimal execution entity for each task in a dynamic and heterogeneous drone resource environment, providing a high-quality decision-making basis for subsequent scheduling and task collaboration.

[0077] as follows Figure 2 As shown, subtask 2 is marked as delivering supplies. UAV2 and UAR1, which have a high matching degree, were selected from the capability pool, and an alliance is to be built.

[0078] (3.3) Alliance Construction and Allocation Strategy: In scenarios where the skill complexity of certain tasks is high and the resource requirements exceed the carrying capacity of a single UAV, an alliance construction mechanism will be activated to dynamically combine multiple UAVs with complementary skills and resource conditions to form a collaborative execution unit to meet the task execution requirements. As a key link in the task allocation strategy, alliance construction is automatically completed based on multi-factor decision-making logic, without relying on manual intervention, and supports a fully automated scheduling system.

[0079] Three core strategies are followed when building the alliance. The first is the "skill coverage priority" principle. Taking the task skill vector as the target benchmark, the alliance searches for a set of drones that meet all skill requirements in the capability vector pool to ensure that there are no gaps in the overall skill coverage. This step uses Boolean operations on the skill set for judgment. First, the required skill set {Navigate, MoveToObject, ProvideMaterial} is constructed based on the corresponding information of the sub-task. Then, the drone capabilities are searched in the drone skill vector pool constructed in (3.1), and a drone set {UAV2, UAR1} is constructed.

[0080] Secondly, there is the "capability redundancy minimization" strategy, which prioritizes the combination with the fewest members among multiple combinations that can meet the skill coverage requirements, in order to reduce resource overhead such as synchronous communication, path planning, and cooperative waiting during task execution. In this strategy, a greedy matching algorithm is used to compare cost indicators of different combination structures in turn, including task execution time estimation and cooperative scheduling complexity, to determine the minimum cost combination scheme.

[0081] The third principle is the "state weight balancing" principle. A state scoring factor is introduced into the candidate drones in the alliance, comprehensively evaluating them based on five indicators: remaining battery percentage, estimated shortest path from the current geographical location to the mission target area, whether the drone is idle, current load percentage, and communication quality. The default weights are 0.35, 0.25, 0.2, 0.1, and 0.1, respectively. These indicators are weighted and fused to form a state score, which participates in the alliance's screening and ranking process. Drones with significantly low state scores are eliminated to avoid mission interruptions due to insufficient energy, path delays, or resource consumption.

[0082] Once the alliance is established, its structure is mapped to the task scheduling graph, forming a many-to-many execution binding relationship between "subtask nodes and alliance nodes". Each alliance is encapsulated as an execution entity, equivalent to a logical execution unit in the scheduling process, possessing independent execution plans, scheduling priorities, and resource locking information. The subtask alliance structure will also be divided into tasks and responsibilities. For example, in a material transportation task requiring a 70kg delivery target, the payload can be divided based on the remaining payload capacity of each member UAV, such as UAV2 carrying 40kg and UAR1 carrying 30kg. The takeoff sequence and trajectory overlap avoidance strategies will be determined based on the path scheduling module.

[0083] as follows Figure 2 As shown, taking the task of "delivering 70kg of supplies to point A" as an example, the task is identified as containing two core sub-tasks: communication restoration and supply delivery. The former, after skill matching and status assessment, is assigned to UAV1, which has communication relay capabilities and is in good condition, for independent execution. The latter, due to the supply weight exceeding the single-machine carrying capacity, selects UAV2 from the capacity pool, both of which have high matching degrees and whose combined carrying capacity meets the task requirements, thus constructing a collaborative transportation alliance. This alliance structure is represented by an execution block in the scheduling graph and bound to the Task-02 (supply delivery) node, achieving a clear mapping from sub-tasks to the alliance execution entity, providing a highly consistent input foundation for subsequent scheduling and path planning modules.

[0084] (3.4) Task Scheduling Graph Construction and Dispatch: After completing task decomposition, dependency modeling, and alliance allocation, a task scheduling graph for scheduling control is generated based on the task dependency graph structure and the UAV alliance matching results. This scheduling graph is constructed in the form of a weighted directed graph, which has the characteristic of topological sorting and is used to guide the overall process of task allocation and concurrent execution. Its nodes are sub-task execution units, and the edges represent task dependency paths. The graph also contains the following fields: sub-task number and corresponding execution alliance ID; estimated time window and starting feasible time point; resource consumption identifier and constraints; and status update field (used for subsequent closed-loop feedback tracking).

[0085] The scheduling graph is dynamically updatable. When the drone's status changes (such as sudden low battery or navigation deviation), the scheduling graph structure can be recalculated and an updated graph structure generated for repair. During the scheduling execution phase, subtasks are dispatched to the corresponding alliance drone terminals in batches according to task dependencies, along with execution parameters, target locations, and task constraints. Each drone automatically executes its task based on the received scheduling instructions and reports feedback until the entire task chain is completed.

[0086] like Figure 2As shown, after the user inputs the task "Deliver 70kg of supplies to point A", it is broken down into two dependent subtasks: I1 "Communication Restoration" and I2 "Supply Delivery". According to the scheduling diagram structure, I2 depends on I1, meaning that I2 can only be started after task I1 is completed.

[0087] UAV1, possessing the "Provide BaseStation" capability, is assigned to execute I1. UAV2 and UAR1 form an alliance, possessing the "Provide Material" and "MoveToObject" skills, and jointly execute I2. In the scheduling graph, node I1 is assigned to UAV1, I2 points to UAV2+UAR1, and the dependency edge points from I1 to I2.

[0088] During execution, I1 is first dispatched to UAV1. Once UAV1 completes communication recovery and sends back a success status, the scheduling event I2 is triggered, synchronously dispatching task information and execution parameters to UAV2 and UAV1. This scheduling method ensures correct task order and improves the efficiency of multi-machine parallel collaboration.

[0089] (4) Edge Feedback and Closed-Loop Adjustment: This refers to the real-time monitoring and feedback recording of the task execution status through lightweight perception and inference modules deployed locally on each UAV during the scheduling process of multiple UAVs. The feedback results are then uploaded to the cloud scheduling center, which, in conjunction with the deep inference function of DeepSeek-R1, achieves dynamic perception of the task execution status, adaptive adjustment of the scheduling results, and closed-loop control of task execution. This mechanism is a key link in building highly reliable multi-agent collaborative scheduling, and is particularly suitable for application scenarios with high risk of task failure and strong path uncertainty in post-disaster environments.

[0090] (4.1) Edge Feedback Acquisition Mechanism: In order to realize real-time monitoring and feedback recording of the task execution process, each UAV performing the task is equipped with an edge feedback acquisition module. This module has basic data perception capabilities and can continuously monitor the UAV's action status. This module is implemented based on the MQTT protocol, which meets the requirements of lightweight design and can obtain the UAV's flight status (including battery level, speed, altitude, latitude and longitude, etc.) in real time and record execution events according to the task type.

[0091] During task execution, this module identifies and records the key actions of each subtask (such as entering the target area, completing task operations, and reporting signals). Once an action is completed or an abnormal interruption occurs, a standardized action execution log will be automatically generated. The log content includes: task number, action type, start and end time, execution success flag, exception flag, and error type label (such as "target not reached", "device not responding", "path offset", etc.).

[0092] To ensure data integrity and latency tolerance, a local log caching mechanism is employed. Logs are stored in a local cache as structured JSON objects and uploaded to the cloud via a 4G / 5G communication module. If communication is disrupted, the logs will be temporarily stored and automatically resent once the network is restored, ensuring that feedback is neither lost nor delayed.

[0093] as follows Figure 2 As shown, during the execution of the "communication restoration" task, UAV1 completes the deployment of the communication base station, and the feedback module automatically generates a successful execution record and sends it back. This feedback serves as the trigger condition for the "material delivery" task. Upon receipt, it initiates the subsequent scheduling process, demonstrating the closed-loop feedback characteristic of "edge acquisition - feedback reporting - scheduling linkage" in this invention.

[0094] (4.2) Feedback Upload and Summary Judgment: Feedback data uploaded by each UAV is summarized and semantically judged in real time at the cloud-based scheduling center. The scheduling center matches each feedback log with the corresponding subtask node in the task scheduling graph and updates the execution status information of the task. This operation is mainly based on the DeepSeek-R1 deep inference function and backend processing logic. Structured information is constructed based on log information and task scheduling graph information and sent to the DeepSeek-R1 model. After obtaining preliminary results, the backend feedback processing logic will make further judgments.

[0095] The feedback processing includes three key logics: Task status comparison: determining whether the task started and completed successfully as expected; Execution path verification: checking whether the task execution process conforms to the topological order of the dependency graph, such as whether there are violations such as "premature execution of subsequent tasks" or "skipping of critical paths"; Anomaly attribution analysis: if the task fails, the anomaly is automatically classified according to the error type field in the feedback, such as "path blockage", "image acquisition failure", "payload not released", "power depletion", etc., and then structured and marked.

[0096] The above analysis results are integrated into a task execution status matrix. Each row in the matrix corresponds to a subtask, and each column records its current status (e.g., "success", "failure", "interrupted", "waiting"), feedback timestamp, failure reason, scheduling suggestion, etc. This matrix serves as the input basis for adaptive scheduling adjustments.

[0097] like Figure 2 As shown, after the "communication restoration" task is successfully executed and feedback is uploaded, the I2 task is identified as meeting the start conditions, triggering UAV2 and UAR1 to execute the "material delivery" sub-task. If a payload anomaly occurs in UAR1 en route, the feedback module will record the status and push it to the cloud, and will respond based on the matrix results.

[0098] (4.3) Closed-loop scheduling adjustment mechanism: When a subtask execution failure, UAV response anomaly, or task execution order violation is detected, a scheduling repair process will be initiated to dynamically reconstruct the original scheduling graph locally. The goal of scheduling repair is to achieve the minimum scope of scheduling recovery while keeping dependency chain constraints unchanged, and to ensure the overall continuity of the task.

[0099] The specific process is as follows: 1. First, locate the failed node based on the task execution status matrix. For isolated failed tasks, prioritize scheduling other currently idle, in good condition, and skill-matched drones to perform the task as replacements.

[0100] 2. If the task is performed by the alliance, invalid members in the alliance will be removed, and new members will be added to reconstruct the alliance using the original greedy algorithm.

[0101] 3. If a dependency path breaks, the system will roll back to the most recently successful node based on the topology and reactivate all affected subtasks on its subsequent paths.

[0102] Finally, a new scheduling graph is generated based on the updated execution units and dependency structure, and then sent to the relevant UAV terminals via the communication link. The scheduling process restarts, and the task continues to execute, forming a complete adaptive loop of "task execution - feedback collection - closed-loop repair".

[0103] This mechanism ensures that multiple drones have continuous operation capability and high fault tolerance in highly dynamic and uncertain environments, significantly improving the overall mission success rate, scheduling flexibility and operational robustness of multi-drone scheduling.

[0104] as follows Figure 2 As shown, if UAV2 malfunctions during the "supply delivery" process, such as release failure or position deviation, the mission is deemed a failure based on the reported logs. The scheduling module will then select a backup UAV (such as UAV4) to replace UAV2, reconstruct the mission coalition, and re-execute the supply delivery mission. Mission dependencies remain unchanged; only the scheduling path is partially rearranged, achieving complete mission execution and closed-loop regulation.

[0105] Obviously, those skilled in the art should understand that the steps of the multi-UAV task scheduling method based on a large language model with dependency perception and feedback mechanisms described in the above embodiments of the present invention, or the multi-UAV collaborative scheduling module involved, can be implemented using general-purpose computing devices. These devices can be centrally deployed on a single device or distributed across a network system composed of multiple computing devices. Optionally, the above-mentioned functional modules and processing flows can be implemented using computer-executable program code and stored in a readable storage medium, and executed by a central processing unit or edge computing unit. Depending on the specific application scenario, some steps in the method can be executed in different orders, or implemented as independent integrated circuit units, or multiple functional modules can be integrated into an integrated hardware module for physical encapsulation and scheduling support. Therefore, the embodiments of the present invention are not limited to any specific combination of software structure, hardware platform, or system architecture. Any equivalent transformations and functional extensions made within the spirit and essence of the present invention should be covered within the protection scope of the present invention.

Claims

1. A multi-UAV task scheduling method with a dependent perception and feedback mechanism, characterized in that, Includes the following: (1) Natural language instruction input: By constructing structured Python prompt words, the task description, environmental information and UAV skill information are input into the large language model; (2) Task decomposition and dependency modeling: The large language model generates a set of subtasks based on the input content and prompt word specifications, and constructs a dependency graph between tasks; (3) Skill matching and alliance scheduling: Model the capabilities of the UAVs and match them with the UAVs based on the skill requirements of the sub-tasks. If a UAV cannot complete the task, an alliance of UAVs is formed to complete the sub-task. (4) Edge feedback and closed-loop adjustment: During the execution of the mission, the UAV collects action feedback information and uploads it to the cloud. The cloud dynamically adjusts the sub-task scheduling diagram according to the feedback results to realize closed-loop control of the mission.

2. The multi-UAV task scheduling method with dependency perception and feedback mechanism according to claim 1, characterized in that, In (1), the constructed structured Python prompts include three elements: task description, environmental information and UAV skills. Semantic annotation is performed through line comments and block comments. UAV skill information is encoded in Python dictionary form and each skill is represented by a standardized English phrase. The prompts are concatenated and input into the cloud-based large language model through an interface to trigger subtask decomposition and dependency generation.

3. The multi-UAV task scheduling method with dependency perception and feedback mechanism according to claim 1, characterized in that, In the task decomposition and dependency modeling described in (2), the task structure is constructed using the method of "semantic decomposition + task dependency graph modeling", including the following: (2.1) Semantic decomposition: The deployed large language model is invoked to perform multi-round semantic parsing on the input natural language task instructions. Combined with the task description, environmental information and UAV skill set, the operation actions, execution objects and target status information in the task are identified, and a structured list of subtasks is automatically generated. Each subtask has clear execution semantics, operation objectives and skill requirements to support subsequent alliance scheduling and task allocation. (2.2) Task dependency graph modeling: After completing the subtask parsing, based on the semantic logic, sequence relationship and resource dependency between tasks, a task dependency graph is constructed to represent the execution order between subtasks in the form of a directed acyclic graph; Each node in the graph corresponds to a subtask, and directed edges represent dependencies between tasks. Dependencies originate from the output of large language models or are automatically inferred and generated by the cloud based on spatial resource sharing, key semantic connectors, and skill reuse rules.

4. The multi-UAV task scheduling method with dependency perception and feedback mechanism according to claim 1, characterized in that, In (3) skill matching and alliance scheduling, based on the completion of sub-task decomposition and dependency modeling, the UAV capability information is matched according to the task skill requirements and the alliance execution structure is constructed, thereby generating the scheduling diagram and completing task dispatch, including the following: (3.1) Modeling of UAV skills and capabilities: Model the capabilities of each UAV participating in the scheduling. The capabilities include flight platform parameters, mission skill tags and status attributes. The platform parameters include maximum endurance, flight speed and payload capacity. The skill tags include path navigation, image acquisition, communication relay and material delivery. The status attributes include current position, remaining battery power and current load status. All capability information is encoded in vector form and stored in a capability vector set for subsequent task matching and retrieval; (3.2) Subtask skill extraction and vector matching: Extract the skill set required for each subtask. This skill set comes from the output of the large language model or is automatically identified and encoded into task skill vectors by the cloud. Then, the skill matching score between the UAV and the task is calculated using cosine similarity and vector inner product, which is used for execution entity screening and recommendation. (3.3) Alliance construction and allocation strategy: In the case that a single UAV cannot complete the task independently, based on the three principles of skill coverage priority, capability redundancy minimization and state weight balance, the UAV with the highest matching degree in the capability pool is automatically selected to build an alliance to realize the sub-task allocation mechanism for collaborative execution. (3.4) Task scheduling graph construction and dispatch: Based on the task dependency graph and the alliance allocation results, a scheduling execution graph is generated. This graph is a weighted directed graph, where nodes represent sub-task units, edges represent dependencies, and information such as task number, execution alliance ID, expected execution time window, and resource usage is attached. The scheduling graph supports topology sorting and dynamic updates. Tasks are dispatched to the corresponding UAV terminals of the alliance in batches according to the graph structure to trigger the task execution process.

5. The multi-UAV task scheduling method with dependency perception and feedback mechanism according to claim 1, characterized in that, In the (4) edge feedback and closed-loop adjustment, the real-time monitoring and dynamic scheduling repair of the task execution status are realized through the collaborative mechanism between the UAV local and cloud, including the following: (4.1) Edge feedback acquisition mechanism: An edge feedback acquisition module is deployed locally on each UAV performing the task. This module has the ability to perceive the task status and can record the status of key actions in real time during the execution process, including whether the target area has been entered, whether the action has been completed, and whether an abnormal event has occurred. Feedback information is recorded in the form of structured logs, with fields including task number, action type, status code, timestamp, and exception flag. It is temporarily stored through a local caching mechanism and then uploaded to the cloud via the communication module. When the network is interrupted, the logs support a delayed resending mechanism to avoid information loss. (4.2) Feedback upload and summary judgment: After receiving the action feedback logs from each UAV, the cloud performs state matching and consistency verification in conjunction with the scheduling diagram to identify whether the task execution was successful, whether there were any execution violations, path interruptions, or time delays; through task state comparison, dependency order verification, and failure cause attribution logic, a task execution state matrix is ​​formed, and scheduling repair suggestions are generated based on the abnormal type tags extracted from the logs. (4.3) Closed-loop scheduling adjustment mechanism: When a task fails, an alliance member fails, or a dependency path breaks, a scheduling repair process is initiated based on the state matrix. The repair strategy includes task reassignment, alliance member replacement, dependency path rollback, and topology adjustment to ensure the continuity and executability of the scheduling graph. Finally, the scheduling graph is updated and redistributed to the relevant UAVs to restore the task execution process, forming a closed-loop control mechanism of language-reasoning-execution-feedback.

6. A multi-UAV mission scheduling system with a dependent perception and feedback mechanism, characterized in that, include: Natural Language Task Input Module: This module receives natural language task instructions submitted by rescue personnel via voice, text, or control terminals. The system converts these instructions into a standard task request format using an embedded structured Python prompt template. The content includes a task description, environmental information, and a list of available drone skills. This module then sends the standardized input as a prompt to the cloud-based large language model, triggering the task decomposition process. Task parsing and dependency modeling module: This module is responsible for receiving the set of subtasks and their execution order information returned by the large language model; the system transforms the parsing results into a task execution graph, and uses a directed acyclic graph structure to encode the logical dependencies between tasks; the parsed task structure will be used as input to the scheduling system to control the execution order and task dependency judgment; Skill Matching and Alliance Scheduling Module: This module is used to maintain the capability resource pool of all current drones, including the skill tags, platform parameters, and real-time status of each drone; the skill requirements of subtasks are converted into task skill vectors after being output by the model or automatically extracted; the system calculates the matching degree through a vector matching algorithm. If a single drone cannot complete the task independently, multiple drones are selected from the drone pool to form an execution alliance, generating a task-alliance mapping table and forming a scheduling plan diagram. Edge Feedback and Closed-Loop Adjustment Module: This module consists of a local edge execution feedback unit on the drone and a cloud-based state analyzer. During execution, the drone continuously records the execution status, generates structured logs, and uploads them periodically or via event-triggered events. The cloud system will compare the task status of all feedback data. If it finds that the task has failed, the drone has lost contact, or there is a scheduling path conflict, it will automatically reconstruct the scheduling plan, rematch the execution alliance, and issue an updated execution graph, thus forming a closed-loop control mechanism for task execution.

7. A computer device, characterized in that, The computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the multi-UAV mission scheduling method with a dependent perception and feedback mechanism as described in any one of claims 1-6.

8. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the multi-UAV mission scheduling method with a dependency perception and feedback mechanism as described in any one of claims 1-6.

Images