I investigate the challenging problem of scheduling heterogeneous UAV drones that must perform integrated reconnaissance, strike, and damage assessment missions under coupled constraints. In such missions, each target requires a chain of operations: reconnaissance must precede strike, and strike must precede damage assessment. The UAV drones differ in speed, maximum range, payload capability, communication performance, remaining energy, and task suitability. Therefore, the scheduling problem is not merely an assignment problem; it is a multi-constraint combinatorial optimization problem with strong temporal dependencies, heterogeneous resources, and real-time decision requirements. I propose a learning-based scheduling framework that combines a heterogeneous graph neural network with a pointer-style edge-selection decoder. The framework represents the scheduling state as a heterogeneous disjunctive graph, filters infeasible candidate actions in advance, encodes task-operation nodes, UAV drone nodes, and candidate matching edges, and directly outputs a probability distribution over valid scheduling actions. To train the model without expert labels or online reinforcement learning interaction, I introduce a differentiable surrogate objective based on masked Gumbel-Softmax and constraint penalties. The resulting method can generate feasible schedules quickly while balancing mission benefit, flight-range cost, and damage risk.
My central motivation is that UAV drone swarms are increasingly expected to operate in complex airspaces where targets appear dynamically, time windows are tight, and resources are limited. A single UAV drone cannot efficiently cover large areas or execute long mission chains alone. A swarm can distribute sensing, strike, and assessment tasks across multiple platforms, but coordination becomes difficult when each platform has different capabilities. I therefore focus on a structured representation that preserves task precedence, resource conflicts, capability matching, time windows, range limits, and risk exposure. The representation must also support variable-size candidate sets because the number of valid UAV drones and unscheduled operations changes at every decision step. Pointer-style decoding is naturally suited to this requirement because it selects among an input set rather than using a fixed-dimensional output layer.
My contributions are threefold. First, I construct a heterogeneous disjunctive graph scheduling model for reconnaissance-strike-assessment chains. This model unifies task operations, UAV drone resources, candidate matching relations, and precedence constraints. Second, I design a heterogeneous graph neural network encoder with a pointer-style edge-selection decoder. The encoder learns relation-aware embeddings for operations, UAV drones, and candidate edges. The decoder produces action probabilities over the current valid candidate set. Third, I develop an end-to-end training mechanism based on a differentiable surrogate objective. Masked Gumbel-Softmax approximates discrete edge selection, while constraint penalties enforce time-window, precedence, range, and resource feasibility. I show through simulation that the proposed method achieves a favorable trade-off among mission benefit, flight-range cost, damage risk, and computational efficiency.
Problem Formulation and Mission Model
I consider a mission area where a set of suspected targets has been detected. Each target must be processed by a chain of three operations: reconnaissance, strike, and damage assessment. I denote the target set at time \(t\) as \(M^{(t)} = \{M_1^{(t)}, M_2^{(t)}, \ldots, M_{N_M}^{(t)}\}\). For each target \(M_i\), I define the information set as \(M_i = \{M_i^R, M_i^A, M_i^D, \chi_i, P_{M_i}\}\), where \(M_i^R\) is the reconnaissance subtask, \(M_i^A\) is the strike subtask, \(M_i^D\) is the damage assessment subtask, \(\chi_i\) is the threat level, and \(P_{M_i} = (X_{M_i}, Y_{M_i})\) is the target position. For a reconnaissance subtask, for example, I write \(M_i^R = \{s_i^R, \psi_i, T_i^{\text{consum}}, T_i^{\text{start}}, T_i^{\text{end}}\}\), where \(s_i^R\) is the index of the matched UAV drone, \(\psi_i\) is the task type label, \(T_i^{\text{consum}}\) is the estimated consumption time, \(T_i^{\text{start}}\) is the earliest start time, and \(T_i^{\text{end}}\) is the latest end time.
I define the base set as \(B = \{B_1, B_2, \ldots, B_{N_B}\}\), where \(N_B\) is the number of bases. Each base has a fixed position \(P_{B_l} = (X_{B_l}, Y_{B_l})\). The UAV drone set is \(V = \{V_1, V_2, \ldots, V_{N_V}\}\), where \(N_V = N_R + N_A + N_D\) includes reconnaissance UAV drones, strike UAV drones, and assessment UAV drones. Each UAV drone \(V_k\) has attributes \(V_k = \{T_k, D_k^{\max}, C_k, v_k, Y_k\}\), where \(T_k\) is the type, \(D_k^{\max}\) is the maximum range, \(C_k\) is the value, \(v_k\) is the speed, and \(Y_k\) is the availability state. The operation set is \(O = \{O_{ij} \mid i=1,\ldots,N_M; j=1,\ldots,N_R\} \cup \{S, E\}\), where \(O_{ij}\) is the \(j\)-th operation for target \(i\), \(N_R=3\) corresponds to reconnaissance, strike, and assessment, and \(S\) and \(E\) are virtual start and end operations.
| Symbol | Meaning |
|---|---|
| \(M_i\) | Target \(i\) with reconnaissance, strike, and assessment subtasks |
| \(V_k\) | Heterogeneous UAV drone \(k\) |
| \(O_{ij}\) | Operation \(j\) for target \(i\) |
| \(D_k\) | Accumulated flight distance of UAV drone \(k\) |
| \(D_k^{\max}\) | Maximum flight range of UAV drone \(k\) |
| \(t^s(O_{ij})\) | Start time of operation \(O_{ij}\) |
| \(t^f(O_{ij})\) | Finish time of operation \(O_{ij}\) |
| \(x_{ij,k}\) | Binary variable indicating whether UAV drone \(k\) executes operation \(O_{ij}\) |
| \(\gamma_i\) | Indicator of complete mission-chain execution for target \(i\) |
| \(J_{\text{ben}}\) | Mission benefit |
| \(J_{\text{dis}}\) | Flight-range cost |
| \(J_{\text{dam}}\) | Damage risk |
I assume that the estimated consumption time for a task is determined by distance and speed. For UAV drone \(V_k\) executing target \(i\), the consumption time is
$$
T_i^{\text{consum}} = \frac{D_{ik}}{v_k},
$$
where \(D_{ik}\) is the flight distance from the UAV drone’s current position to the target position. For strike UAV drones, the consumption time also includes the duration from weapon preparation to release completion. These assumptions keep the model focused on scheduling rather than low-level flight control.
I enforce several hard constraints. The flight-range constraint ensures that the accumulated distance of any UAV drone does not exceed its maximum range:
$$
D_k \le D_k^{\max}, \quad \forall V_k \in V.
$$
The resource allocation constraint requires that each operation is executed exactly once:
$$
\sum_{V_k \in V} x_{ij,k} = 1, \quad \forall O_{ij} \in O.
$$
The capability matching constraint ensures that a UAV drone can execute an operation only if its type matches the required capability:
$$
x_{ij,k} = 0 \quad \text{if } T_k \neq \text{req}(O_{ij}).
$$
The time-window constraint requires that each operation starts and finishes within its allowed interval:
$$
t^{\min}(O_{ij}) \le t^s(O_{ij}) \le t^f(O_{ij}) \le t^{\max}(O_{ij}).
$$
The task precedence constraint enforces the fixed order within each target chain:
$$
t^f(O_i^R) \le t^s(O_i^A), \quad t^f(O_i^A) \le t^s(O_i^D).
$$
The resource occupancy constraint states that a UAV drone can execute at most one operation at any time and that an operation cannot be interrupted once started:
$$
\phi_{kt} \in \{0,1\}, \quad \sum_{k} \phi_{kt} \le 1,
$$
where \(\phi_{kt}=1\) if UAV drone \(V_k\) is executing a task at time \(t\), and \(\phi_{kt}=0\) otherwise. The mission-chain integrity constraint ensures that full benefit is credited only when all three subtasks of a target are completed:
$$
\gamma_i =
\begin{cases}
1, & \delta(O_i^R) = \delta(O_i^A) = \delta(O_i^D) = 1, \\
0, & \text{otherwise}.
\end{cases}
$$
I then define the overall optimization objective as a weighted combination of mission benefit, flight-range cost, and damage risk:
$$
\max J = \omega_{\text{ben}} J_{\text{ben}} – \omega_{\text{dis}} J_{\text{dis}} – \omega_{\text{dam}} J_{\text{dam}},
$$
where \(\omega_{\text{ben}}, \omega_{\text{dis}}, \omega_{\text{dam}} \in (0,1)\). The mission benefit is
$$
J_{\text{ben}} = \sum_{M_i \in M} C_{M_i} \gamma_i,
$$
where \(C_{M_i}\) is the inherent value of target \(M_i\). The flight-range cost is
$$
J_{\text{dis}} = \sum_{V_k \in V} \frac{D_k}{D_k^{\max}}.
$$
The damage risk is
$$
J_{\text{dam}} = \sum_{M_i \in M} \sum_{V_k \in V} \sum_{j \in \{R,A,D\}} x_{ij,k} C_{M_i} \rho_{ij,k},
$$
where \(\rho_{ij,k}\) is the threat risk probability when UAV drone \(V_k\) executes operation \(O_{ij}\). The complete optimization problem is
$$
\begin{aligned}
\max \quad & J \\
\text{s.t.} \quad & D_k \le D_k^{\max}, \\
& \sum_{V_k \in V} x_{ij,k} = 1, \\
& x_{ij,k} = 0 \ \text{if} \ T_k \neq \text{req}(O_{ij}), \\
& t^{\min}(O_{ij}) \le t^s(O_{ij}) \le t^f(O_{ij}) \le t^{\max}(O_{ij}), \\
& t^f(O_i^R) \le t^s(O_i^A), \quad t^f(O_i^A) \le t^s(O_i^D), \\
& \phi_{kt} \in \{0,1\}, \quad \sum_{k} \phi_{kt} \le 1, \\
& \gamma_i \in \{0,1\}.
\end{aligned}
$$
| Constraint | Expression | Purpose |
|---|---|---|
| Flight range | \(D_k \le D_k^{\max}\) | Prevent UAV drone exhaustion |
| Resource allocation | \(\sum_{V_k} x_{ij,k} = 1\) | Assign each operation exactly once |
| Capability matching | \(x_{ij,k}=0\) if \(T_k \neq \text{req}(O_{ij})\) | Match UAV drone type to task requirement |
| Time window | \(t^{\min} \le t^s \le t^f \le t^{\max}\) | Respect operational timing |
| Precedence | \(t^f(O_i^R) \le t^s(O_i^A) \le t^f(O_i^A) \le t^s(O_i^D)\) | Enforce reconnaissance-strike-assessment order |
| Resource occupancy | \(\sum_{k} \phi_{kt} \le 1\) | Avoid simultaneous execution by one UAV drone |
| Chain integrity | \(\gamma_i = 1\) only if all subtasks complete | Prevent partial-credit overestimation |
Heterogeneous Disjunctive Graph Representation
Traditional assignment matrices are intuitive but cannot explicitly represent task precedence, resource conflicts, and multi-type constraints. I therefore represent the scheduling state as a heterogeneous disjunctive graph:
$$
G_t = (O, V, \mathcal{P}, \mathcal{C}, \mathcal{A}),
$$
where \(O\) is the set of task-operation nodes, \(V\) is the set of UAV drone nodes, \(\mathcal{P}\) is the set of precedence edges, \(\mathcal{C}\) is the set of candidate operation-UAV drone matching edges, and \(\mathcal{A}\) is the set of already determined execution edges. Operation nodes include all reconnaissance, strike, and assessment operations plus virtual start and end nodes. UAV drone nodes represent available resources. Precedence edges describe the internal order of reconnaissance, strike, and assessment for each target. Candidate matching edges connect an operation node to a UAV drone that may execute it in the current state. At each decision instant, the scheduler selects one edge from the candidate set. If edge \((O_{ij}, V_k)\) is selected, operation \(O_{ij}\) is assigned to UAV drone \(V_k\). The system then updates the task state, UAV drone state, and candidate edge set before proceeding to the next decision instant.
I define operation node features \(\mu_{ij}\) that include whether the operation has been scheduled, the number of candidate UAV drones, the actual start time, the number of unsatisfied predecessor tasks, the estimated finish time, target position, target value, required UAV drone capability, time-window lower bound, time-window upper bound, and operation duration. I define UAV drone node features \(\nu_k\) that include capability type, maximum range, speed, current availability, number of candidate tasks, home base, current position, current task finish time, and accumulated flight distance. I define candidate edge features \(\lambda_{ij,k}\) for edge \(e_{ij,k}=(O_{ij}, V_k)\) that include the distance from the UAV drone’s current position to the target, estimated flight time, execution risk, and remaining range ratio after execution.
| Node or Edge Type | Feature Vector | Included Information |
|---|---|---|
| Operation node \(O_{ij}\) | \(\mu_{ij} \in \mathbb{R}^{12}\) | Scheduled flag, candidate count, start time, predecessor count, finish time, target position, value, required capability, time-window bounds, duration |
| UAV drone node \(V_k\) | \(\nu_k \in \mathbb{R}^{10}\) | Capability type, maximum range, speed, availability, candidate task count, base, position, finish time, accumulated distance |
| Candidate edge \(e_{ij,k}\) | \(\lambda_{ij,k} \in \mathbb{R}^{4}\) | Flight distance, estimated flight time, risk, remaining range ratio |
To reduce the action space and guarantee feasibility, I filter candidate operation-UAV drone matching edges at each decision instant. An edge is retained only if all of the following conditions hold: the operation has not been scheduled; its predecessors have completed; the UAV drone is available or can arrive within the allowed time; the UAV drone capability matches the task requirement; the accumulated range after execution does not exceed the maximum range; and the operation can finish within its time window. The valid candidate edge set is
$$
\mathcal{E}_{\text{valid}}(t) = \{ e_{ij,k} \mid C_1 \land C_2 \land C_3 \land C_4 \land C_5 \land C_6 \},
$$
where \(C_1\) to \(C_6\) correspond to the six conditions above. This filtering mechanism compresses the decision space and prevents the learned policy from outputting illegal scheduling actions. The filtering algorithm traverses unscheduled operations, skips those whose predecessors are incomplete, checks each UAV drone for capability, availability, arrival time, completion time, and accumulated range, and then computes edge features for all feasible matches. If the valid set is empty, the system outputs a wait, termination, or graph-reconstruction signal.
| Condition | Meaning |
|---|---|
| \(C_1\) | Operation is not yet scheduled |
| \(C_2\) | All predecessor operations are complete |
| \(C_3\) | UAV drone is available or can arrive in time |
| \(C_4\) | UAV drone capability matches operation requirement |
| \(C_5\) | Accumulated range after execution does not exceed maximum range |
| \(C_6\) | Operation can complete within its time window |
Heterogeneous Graph Neural Network Encoder
Because operation nodes and UAV drone nodes have different semantics and different raw feature dimensions, I first project each type into a shared latent space using type-specific linear mappings:
$$
h_{O_{ij}} = W_O \mu_{ij} + b_O,
$$
$$
h_{V_k} = W_V \nu_k + b_V,
$$
where \(h_{O_{ij}}\) is the operation node embedding, \(h_{V_k}\) is the UAV drone node embedding, and \(W_O, W_V, b_O, b_V\) are learnable parameters. After feature alignment, I apply a heterogeneous graph attention mechanism to aggregate neighborhood information. For a node \(p\) and a neighbor \(q\), the attention weight is
$$
\alpha_{pq} = \text{softmax}\left( \text{LeakyReLU}\left( \mathbf{a}^T [W h_p \| W h_q \| \phi_e] \right) \right),
$$
where \(\phi_e\) encodes the edge type or edge features, \(\|\) denotes vector concatenation, and \(\mathbf{a}\) and \(W\) are learnable parameters. The node update is
$$
h_p’ = \sigma\left( \sum_{q \in \mathcal{N}(p)} \alpha_{pq} W h_q \right),
$$
where \(\sigma(\cdot)\) is a nonlinear activation function. After multiple graph attention layers, the model fuses task precedence relations, resource matching relations, and candidate execution relations into scheduling-aware node embeddings. I use three attention layers with a hidden dimension of 128 and a dropout probability of 0.1. This configuration provides enough capacity to model complex relations without excessive computational cost.
| Parameter | Value |
|---|---|
| Number of attention layers | 3 |
| Hidden dimension | 128 |
| Dropout probability | 0.1 |
| Operation feature dimension | 12 |
| UAV drone feature dimension | 10 |
| Edge feature dimension | 4 |
I define an atomic scheduling action as the selection of a valid candidate edge \(e_{ij,k}=(O_{ij}, V_k)\). The candidate edge representation is formed by concatenating the operation node embedding, UAV drone node embedding, and edge features:
$$
z_{ij,k} = [h_{O_{ij}} \| h_{V_k} \| \lambda_{ij,k}].
$$
To enhance edge representation, I apply a multi-layer perceptron:
$$
g_{ij,k} = \text{MLP}_e(z_{ij,k}).
$$
The resulting edge representation contains task requirements, UAV drone state, matching relations, flight cost, and risk information. This representation is crucial because the decoder must compare heterogeneous candidate edges that differ in both task semantics and resource implications.
Pointer Decoder and Differentiable Training
The pointer decoder directly points to one candidate object in the current candidate set. Unlike a fixed-dimensional classifier, it can handle variable-size candidate edge sets, which is essential for UAV drone swarm scheduling. I first compute a global graph state representation through attention pooling:
$$
g_t = \sum_{p} \beta_p h_p,
$$
where \(\beta_p\) is the global attention weight of node \(p\). For each valid candidate edge \(e_{ij,k}\), I compute a selection score:
$$
s_{ij,k} = u^T \tanh(W_g g_t + W_e g_{ij,k} + b),
$$
where \(u, W_g, W_e, b\) are learnable parameters. The probability of selecting edge \(e_{ij,k}\) is normalized over the valid candidate set:
$$
P(e_{ij,k} \mid G_t) = \frac{\exp(s_{ij,k})}{\sum_{e’ \in \mathcal{E}_{\text{valid}}(t)} \exp(s_{e’})}.
$$
Because candidate edge selection is discrete, direct argmax operation cannot be trained end-to-end. I introduce masked Gumbel-Softmax to approximate the discrete choice in a differentiable manner. For any valid edge \(e\), the soft selection weight is
$$
y_e(t) = \frac{\exp((\log P(e \mid G_t) + g_e) / \tau)}{\sum_{e’ \in \mathcal{E}_{\text{valid}}(t)} \exp((\log P(e’ \mid G_t) + g_{e’}) / \tau)},
$$
where \(g_e\) is Gumbel noise and \(\tau > 0\) is a temperature parameter. As \(\tau\) decreases, \(y_e(t)\) approaches a one-hot selection. To combine differentiability during training with discrete execution during inference, I use a straight-through strategy. In the forward pass, I execute
$$
e^* = \arg\max_{e \in \mathcal{E}_{\text{valid}}(t)} y_e(t),
$$
while in the backward pass, I propagate gradients through the soft selection weights \(y_e(t)\). This allows end-to-end optimization of the pointer decoder parameters.
I construct a differentiable surrogate objective that aligns training with the scheduling objective. Let \(y_e(t)\) be the soft assignment weight for selecting edge \(e\) at decision instant \(t\). The differentiable approximations of mission benefit, flight-range cost, and damage risk are
$$
\hat{J}_{\text{ben}} = \sum_{M_i \in M} C_{M_i} \hat{\gamma}_i,
$$
$$
\hat{J}_{\text{dis}} = \sum_{t} \sum_{e \in \mathcal{E}_{\text{valid}}(t)} y_e(t) \, d_e,
$$
$$
\hat{J}_{\text{dam}} = \sum_{t} \sum_{e \in \mathcal{E}_{\text{valid}}(t)} y_e(t) \, r_e,
$$
where \(\hat{\gamma}_i\) is the soft indicator of mission-chain completion for target \(M_i\), \(d_e\) is the normalized flight-range cost of edge \(e\), and \(r_e\) is the normalized risk cost of edge \(e\). The objective loss is
$$
\mathcal{L}_{\text{obj}} = -\left( \omega_{\text{ben}} \hat{J}_{\text{ben}} – \omega_{\text{dis}} \hat{J}_{\text{dis}} – \omega_{\text{dam}} \hat{J}_{\text{dam}} \right).
$$
To improve feasibility and robustness, I add explicit penalty terms for time windows, precedence, range, and resource conflicts. The time-window penalty is
$$
\mathcal{L}_{\text{tw}} = \sum_{O_{ij}} \left[ \max(0, t^{\min}(O_{ij}) – \hat{t}^s(O_{ij})) + \max(0, \hat{t}^f(O_{ij}) – t^{\max}(O_{ij})) \right].
$$
The precedence penalty is
$$
\mathcal{L}_{\text{pre}} = \sum_{M_i} \left[ \max(0, \hat{t}^f(O_i^R) – \hat{t}^s(O_i^A)) + \max(0, \hat{t}^f(O_i^A) – \hat{t}^s(O_i^D)) \right].
$$
The range penalty is
$$
\mathcal{L}_{\text{rng}} = \sum_{V_k} \max(0, \hat{D}_k – D_k^{\max}).
$$
The resource conflict penalty is
$$
\mathcal{L}_{\text{res}} = \sum_{V_k} \sum_{a \neq b} \max\left(0, \min(\hat{t}^f_a, \hat{t}^f_b) – \max(\hat{t}^s_a, \hat{t}^s_b)\right),
$$
where \((a,k)\) and \((b,k)\) are two different operations assigned to the same UAV drone \(V_k\). The total training loss is
$$
\mathcal{L} = \mathcal{L}_{\text{obj}} + \lambda_1 \mathcal{L}_{\text{tw}} + \lambda_2 \mathcal{L}_{\text{pre}} + \lambda_3 \mathcal{L}_{\text{rng}} + \lambda_4 \mathcal{L}_{\text{res}},
$$
where \(\lambda_1, \lambda_2, \lambda_3, \lambda_4\) are penalty weights. I optimize the model using AdamW with a warm-up and cosine decay learning rate schedule. The learning rate first rises linearly from \(1.5 \times 10^{-5}\) to \(5.0 \times 10^{-5}\) over 50 warm-up epochs, then decays back to \(1.5 \times 10^{-5}\). I use 1000 training epochs, 64 episodes per epoch, 50 evaluation episodes, gradient accumulation over 8 steps, a gradient clipping threshold of 0.5, a weight decay of \(1 \times 10^{-5}\), an initial Gumbel-Softmax temperature of 2.5, a final temperature of 0.5, and a hard-sampling start at epoch 25.
| Parameter | Value |
|---|---|
| Optimizer | AdamW |
| Training epochs | 1000 |
| Episodes per epoch | 64 |
| Evaluation episodes | 50 |
| Gradient accumulation steps | 8 |
| Gradient clipping threshold | 0.5 |
| Weight decay | \(1 \times 10^{-5}\) |
| Learning rate schedule | Warm-up + cosine decay |
| Learning rate | \(1.5 \times 10^{-5} \rightarrow 5.0 \times 10^{-5} \rightarrow 1.5 \times 10^{-5}\) |
| Warm-up epochs | 50 |
| Initial Gumbel-Softmax temperature | 2.5 |
| Final Gumbel-Softmax temperature | 0.5 |
| Hard-sampling start epoch | 25 |
Training and Online Inference
I train the heterogeneous graph neural network encoder and pointer decoder in an end-to-end manner. The training procedure is as follows. I randomly generate scheduling scenarios of different sizes, including base distributions, UAV drone attributes, target positions, time windows, and threat levels. At each decision instant, I construct the current heterogeneous disjunctive graph \(G_t\), extract operation node features, UAV drone node features, and candidate edge features, and generate the valid candidate edge set \(\mathcal{E}_{\text{valid}}(t)\). I input the graph state into the heterogeneous graph neural network to obtain task node and UAV drone node embeddings, and I construct candidate edge representations. The pointer decoder outputs a probability distribution over candidate edges. I use masked Gumbel-Softmax to generate a differentiable approximate action selection. I approximately update the scheduling state, compute the surrogate objective and constraint penalties, and backpropagate the total loss to update network parameters. I evaluate the objective value, scheduling feasibility rate, mission-chain completion rate, and solution efficiency on a validation set, and I save the best-performing model.
In the online application phase, the system first loads the trained heterogeneous graph neural network and pointer decoder parameters. At each scheduling decision instant, the scheduler constructs the heterogeneous disjunctive graph based on the currently acquired target information, UAV drone states, and task constraints, and generates the valid candidate edge set. The model performs one forward pass to output candidate edge selection probabilities, and the scheduler determines the scheduling action. When task states, resource states, or target information from external perception modules change, the system updates the current scheduling graph and candidate edge set and performs the next round of rolling inference. After each action, the system updates the completion status of the scheduled task, the position, available time, and accumulated range of the corresponding UAV drone, the predecessor constraint status of successor tasks, the candidate edge set, and the accumulated benefit, flight-range cost, and risk of the current schedule.
| Stage | Key Operation | Output |
|---|---|---|
| Training | Generate scenarios, build graphs, encode nodes, decode edges, apply Gumbel-Softmax, compute losses, backpropagate | Trained encoder and decoder parameters |
| Online inference | Build graph, filter valid edges, forward pass, greedy or beam decoding, update state | Feasible schedule |
Simulation Analysis
I evaluate the proposed method in an online test scenario with two UAV drone bases and 18 heterogeneous UAV drones. The UAV drones must cooperatively complete reconnaissance, strike, and damage assessment chains for six targets. The key parameters of the UAV drones, bases, and targets are summarized below. The UAV drone cluster includes reconnaissance, strike, and assessment types with different speeds, maximum ranges, and initial positions. The bases are fixed, and the targets have different values, threat levels, time windows, and operation durations.
| UAV Drone | Type | Base | Speed (m/s) | Maximum Range (km) | Current Position (km) |
|---|---|---|---|---|---|
| 1 | Reconnaissance | 1 | 15.36 | 187.67 | (63.94, 2.50) |
| 2 | Strike | 2 | 16.92 | 128.69 | (27.50, 22.32) |
| 3 | Assessment | 1 | 12.22 | 122.98 | (63.94, 2.50) |
| 4 | Reconnaissance | 2 | 10.19 | 170.54 | (27.50, 22.32) |
| 5 | Strike | 1 | 8.27 | 139.88 | (63.94, 2.50) |
| 6 | Assessment | 2 | 14.50 | 174.49 | (27.50, 22.32) |
| 7 | Reconnaissance | 1 | 10.20 | 178.93 | (63.94, 2.50) |
| 8 | Strike | 2 | 16.09 | 120.65 | (27.50, 22.32) |
| 9 | Assessment | 1 | 16.06 | 189.81 | (63.94, 2.50) |
| 10 | Reconnaissance | 2 | 11.40 | 135.55 | (27.50, 22.32) |
| 11 | Strike | 1 | 17.57 | 153.66 | (63.94, 2.50) |
| 12 | Assessment | 2 | 8.93 | 129.67 | (27.50, 22.32) |
| 13 | Reconnaissance | 1 | 16.47 | 180.37 | (63.94, 2.50) |
| 14 | Strike | 2 | 16.07 | 192.97 | (27.50, 22.32) |
| 15 | Assessment | 1 | 13.36 | 217.31 | (63.94, 2.50) |
| 16 | Reconnaissance | 2 | 11.79 | 175.20 | (27.50, 22.32) |
| 17 | Strike | 1 | 16.29 | 181.85 | (63.94, 2.50) |
| 18 | Assessment | 2 | 16.62 | 177.74 | (27.50, 22.32) |
| Base | Position (km) |
|---|---|
| 1 | (63.94, 2.50) |
| 2 | (27.50, 22.32) |
| Target | Position (km) | Value | Threat | Reconnaissance Window | Reconnaissance Duration | Strike Window | Strike Duration | Assessment Window | Assessment Duration |
|---|---|---|---|---|---|---|---|---|---|
| 1 | (13.83, 49.35) | 40.23 | 0.79 | [4.59, 96.00] | 5 | [4.59, 96.00] | 8 | [4.59, 96.00] | 4 |
| 2 | (68.05, 59.64) | 25.39 | 0.58 | [14.04, 105.14] | 5 | [14.04, 105.14] | 8 | [14.04, 105.14] | 4 |
| 3 | (55.32, 94.24) | 37.21 | 0.19 | [26.54, 155.09] | 5 | [26.54, 155.09] | 8 | [26.54, 155.09] | 4 |
| 4 | (76.86, 34.02) | 21.74 | 0.23 | [0.10, 152.21] | 5 | [0.10, 152.21] | 8 | [0.10, 152.21] | 4 |
| 5 | (71.97, 97.19) | 40.48 | 0.51 | [3.19, 142.53] | 5 | [3.19, 142.53] | 8 | [3.19, 142.53] | 4 |
| 6 | (84.17, 50.77) | 17.96 | 0.40 | [4.85, 175.35] | 5 | [4.85, 175.35] | 8 | [4.85, 175.35] | 4 |
In the online scheduling experiment, I trigger rolling decisions at the start of each target’s reconnaissance window. For example, when \(t=4.59\) and target 1 enters its executable reconnaissance window, the system triggers a rolling decision. The agent outputs the next operation-UAV drone matching action based on the current scheduling state. When \(t=14.04\) and target 2 enters its executable reconnaissance window, another rolling decision is triggered to update the subsequent assignment and execution sequence. Different UAV drones execute tasks in parallel while respecting the reconnaissance-to-strike-to-assessment dependency and resource constraints. The flight phases and execution phases connect continuously on the timeline, which shows that the rolling decision mechanism maintains feasibility and consistency under dynamic constraints.
The performance comparison is shown below. Except for solution time, all metrics are normalized means over 50 independent evaluations. Compared with a genetic algorithm, my method does not require population initialization, crossover, mutation, or multi-generation iterative search during inference, which reduces online search overhead. Compared with a greedy algorithm, my method learns task-resource matching patterns during offline training and performs sequential decisions based on the learned policy rather than selecting only the immediate locally optimal action. Compared with a graph-free learning model, my method explicitly encodes task dependencies, resource matching relations, and candidate execution relations, and extracts structural information through graph message passing.
| Method | Solution Time (s) | Benefit Score | Flight-Range Cost Score | Damage Risk Score |
|---|---|---|---|---|
| Genetic algorithm | 6.89 | 0.62 | 1 | 0.24 |
| Greedy algorithm | 1.94 | 1 | 0.37 | 0.68 |
| Graph-free learning model | 0.76 | 0.59 | 0.57 | 0.83 |
| My method | 0.81 | 1 | 0.827 | 1 |
During training, the loss curve shows that the model quickly learns the mapping between scheduling states and candidate actions in the early stage. After entering the stable stage, the loss curve fluctuates only slightly and does not diverge. This indicates that the heterogeneous graph neural network and pointer decoder have good training stability. The benefit curve initially remains near a high level but fluctuates noticeably between epochs 50 and 350, with a minimum around 151.4. This reflects policy exploration and schedule adjustment in the early stage. As training progresses, the benefit value recovers and stabilizes around 154 after about 400 epochs. The risk curve shows that the model gradually forms a stable risk assessment and scheduling selection mechanism. The path length curve fluctuates in the early stage, then decreases overall, reaching about 450 between epochs 300 and 450. After a temporary increase between epochs 500 and 650, the path length decreases again and stabilizes after about 800 epochs. These trends indicate that my method can reduce overall flight-range consumption while satisfying task constraints and improving path economy.
Overall, the simulation results demonstrate that the proposed heterogeneous graph neural network and pointer decoder can rapidly generate feasible scheduling solutions under task dependencies and resource constraints. The method achieves a good trade-off among mission benefit, flight-range cost, damage risk, and computational efficiency. The valid candidate edge filtering mechanism guarantees hard-constraint feasibility, while the learned encoder and decoder improve the ranking quality of candidate actions. The differentiable surrogate objective avoids reliance on expert-labeled samples and online reinforcement learning interaction.
Conclusion
I have presented a UAV drone swarm task scheduling algorithm based on a heterogeneous graph neural network and a pointer-style decoder. The method targets integrated reconnaissance, strike, and damage assessment missions with heterogeneous resources, coupled constraints, and real-time scheduling requirements. I formulated a multi-constraint optimization model that incorporates task precedence, UAV drone capability matching, time windows, flight-range limits, and damage risk. I represented the scheduling state as a heterogeneous disjunctive graph, where task operations, UAV drone resources, precedence relations, and candidate matching edges are encoded as nodes and edges. I designed a valid candidate edge filtering mechanism to eliminate infeasible actions in advance, thereby compressing the decision space and ensuring feasibility. I used a heterogeneous graph neural network to extract embeddings for operation nodes, UAV drone nodes, and candidate edges, and I introduced a pointer decoder to output scheduling action probabilities over valid candidate edges. I developed an end-to-end training mechanism based on a differentiable surrogate objective, using masked Gumbel-Softmax to approximate discrete edge selection and constraint penalties to enforce feasibility. Simulation results show that my method can quickly generate feasible schedules while achieving a favorable balance among mission benefit, flight-range cost, damage risk, and solution efficiency.
Future work will consider dynamic scenarios such as sudden UAV drone failures, newly appearing targets, changing time windows, and communication restrictions. I will also study lightweight online fine-tuning mechanisms to improve robustness and adaptability in real environments. The proposed framework can be extended to other multi-robot scheduling problems where heterogeneous resources, precedence constraints, and variable-size candidate sets must be handled jointly.