I study the problem of scheduling heterogeneous UAV drone swarms for integrated reconnaissance, strike, and damage-assessment task chains. In my formulation, a UAV drone swarm must concurrently satisfy task precedence, capability matching, time windows, flight-range limits, resource exclusivity, and mission-chain completeness. The main difficulty is that the decision space is combinatorial, the resources are heterogeneous, and the constraints are tightly coupled. To address this difficulty, I propose a scheduling algorithm that combines a heterogeneous graph neural network with a pointer-style decoder. I represent the scheduling state as a heterogeneous disjunctive graph, filter infeasible operation-to-UAV-drone matching edges before decision making, and train the policy end-to-end with a differentiable surrogate objective. The resulting method can rapidly generate feasible schedules and can trade off mission benefit, flight-range cost, damage risk, and computational efficiency.
I begin with the scenario model. The task area contains multiple suspected targets. Each target requires a reconnaissance operation, a strike operation, and a damage-assessment operation. These three operations form a chain. Reconnaissance must precede strike, and strike must precede damage assessment. A UAV drone cluster consists of heterogeneous platforms with different speeds, maximum ranges, payload types, initial positions, and availability states. The scheduling system must decide which UAV drone executes which operation and in what order, while respecting all constraints.
1. Problem Formulation for UAV Drone Task Chains
I define the target set at decision time t as
$$
\mathcal{M}_{t}=\{M_{1},M_{2},\ldots,M_{N_{t}}\}.
$$
For each target, I define the information set
$$
M_{i}=\{M_{i}^{R},M_{i}^{A},M_{i}^{D},\chi_{i},P_{i}\},
$$
where \(M_{i}^{R}\), \(M_{i}^{A}\), and \(M_{i}^{D}\) represent the reconnaissance, strike, and damage-assessment sub-task information, respectively. The symbol \(\chi_{i}\) denotes threat level, and \(P_{i}=(X_{i},Y_{i})\) denotes target position. For a reconnaissance sub-task, I write
$$
M_{i}^{R}=\{s_{i}^{R},T_{i}^{\text{consum}},T_{i}^{\text{start}},T_{i}^{\text{end}},\psi_{i}\},
$$
where \(s_{i}^{R}\) is a matched UAV drone index, \(\psi_{i}\) is a task-type label, \(T_{i}^{\text{consum}}\) is estimated consumption time, and \(T_{i}^{\text{start}}\), \(T_{i}^{\text{end}}\) define the allowed time window. The same structure applies to strike and damage-assessment sub-tasks.
Ilet the base set be
$$
\mathcal{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
$$
\mathcal{V}=\{V_{1},V_{2},\ldots,V_{N_{V}}\},
$$
with
$$
N_{V}=N_{R}+N_{A}+N_{D},
$$
where \(N_{R}\), \(N_{A}\), and \(N_{D}\) are the numbers of reconnaissance, strike, and damage-assessment UAV drones, respectively. I describe each UAV drone by
$$
V_{k}=\{T_{k},D_{k}^{\max},C_{k},v_{k},Y_{k}\},
$$
where \(T_{k}\) is platform type, \(D_{k}^{\max}\) is maximum range, \(C_{k}\) is value, \(v_{k}\) is speed, and \(Y_{k}\) is availability state.
The operation set is
$$
\mathcal{O}=\{O_{ij}\mid i=1,\ldots,N_{t}; j\in\{R,A,D\}\}\cup\{S,E\},
$$
where \(O_{ij}\) is the j-th operation of target i, and \(S\) and \(E\) are virtual start and end operations. I assume that the consumption time of an operation is determined by flight distance and UAV drone speed:
$$
T_{ij}^{\text{consum}}=\frac{D_{ik}}{v_{k}}.
$$
Under saturated-attack conditions, I treat the consumption time as the minimum time required to complete the basic task. For a strike UAV drone, the consumption time is the total duration from launch-system preparation to launch completion.
| Symbol | Meaning |
|---|---|
| \(\mathcal{M}_{t}\) | Target set at time t |
| \(M_{i}^{R},M_{i}^{A},M_{i}^{D}\) | Reconnaissance, strike, and damage-assessment sub-tasks |
| \(\mathcal{B}\) | Base set |
| \(\mathcal{V}\) | Heterogeneous UAV drone set |
| \(\mathcal{O}\) | Operation set |
| \(O_{ij}\) | Operation j of target i |
| \(x_{ij,k}\) | Binary assignment variable for operation \(O_{ij}\) and UAV drone \(V_{k}\) |
| \(g_{i}\) | Mission-chain completeness indicator for target i |
| \(J_{\text{ben}}\) | Mission benefit |
| \(J_{\text{dis}}\) | Flight-range cost |
| \(J_{\text{dam}}\) | Damage risk |
2. Constraint System for UAV Drone Scheduling
I formulate a multi-constraint optimization model. The first constraint is the flight-range constraint. The cumulative distance of each UAV drone cannot exceed its maximum range:
$$
D_{k}\le D_{k}^{\max},\quad \forall V_{k}\in\mathcal{V}.
$$
The second constraint is resource assignment. Every task operation must be executed by exactly one UAV drone:
$$
\sum_{V_{k}\in\mathcal{V}}x_{ij,k}=1,\quad \forall O_{ij}\in\mathcal{O}.
$$
The third constraint is capability matching. A task operation must be assigned to a UAV drone with the required capability type:
$$
x_{ij,k}=0,\quad \text{if } T_{k}\ne \operatorname{req}(O_{ij}).
$$
The fourth constraint is the time-window constraint:
$$
t_{\min}(O_{ij})\le t^{s}(O_{ij})\le t^{f}(O_{ij})\le t_{\max}(O_{ij}),
$$
where \(t^{s}(O_{ij})\) and \(t^{f}(O_{ij})\) are start and finish times. The fifth constraint is task precedence for each target:
$$
t^{f}(O_{i}^{R})\le t^{s}(O_{i}^{A}),\quad t^{f}(O_{i}^{A})\le t^{s}(O_{i}^{D}).
$$
The sixth constraint is resource occupancy. A single UAV drone cannot execute more than one operation at the same time, and an operation cannot be interrupted once started:
$$
\phi_{k,t}=
\begin{cases}
1, & \text{if UAV drone } V_{k} \text{ is executing a task at time } t,\\
0, & \text{otherwise}.
\end{cases}
$$
The seventh constraint is mission-chain completeness. I introduce an indicator variable \(g_{i}\). The target receives complete benefit only when all three sub-tasks are completed:
$$
g_{i}=
\begin{cases}
1, & \delta(O_{i}^{R})=\delta(O_{i}^{A})=\delta(O_{i}^{D})=1,\\
0, & \text{otherwise}.
\end{cases}
$$
Equivalently, I can write
$$
g_{i}\le \delta(O_{i}^{R}),\quad g_{i}\le \delta(O_{i}^{A}),\quad g_{i}\le \delta(O_{i}^{D}),
$$
$$
g_{i}\ge \delta(O_{i}^{R})+\delta(O_{i}^{A})+\delta(O_{i}^{D})-2.
$$
This prevents overestimating benefit when only part of a task chain is completed.
| Constraint | Mathematical form | Purpose |
|---|---|---|
| Flight range | \(D_{k}\le D_{k}^{\max}\) | Ensure UAV drone can return or continue |
| Resource assignment | \(\sum_{k}x_{ij,k}=1\) | Assign each operation once |
| Capability matching | \(x_{ij,k}=0\) if \(T_{k}\ne \operatorname{req}(O_{ij})\) | Match heterogeneous payloads |
| Time window | \(t_{\min}\le t^{s}\le t^{f}\le t_{\max}\) | Respect temporal validity |
| Precedence | \(t^{f}(O_{i}^{R})\le t^{s}(O_{i}^{A})\), \(t^{f}(O_{i}^{A})\le t^{s}(O_{i}^{D})\) | Preserve reconnaissance-strike-assessment order |
| Resource occupancy | \(\phi_{k,t}\in\{0,1\}\) | Prevent simultaneous use of one UAV drone |
| Chain completeness | \(g_{i}\le \delta(O_{i}^{R})\), \(g_{i}\le \delta(O_{i}^{A})\), \(g_{i}\le \delta(O_{i}^{D})\) | Pay full benefit only for complete chains |
3. Multi-Objective Function
I define the overall scheduling objective as
$$
\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}}\), and \(\omega_{\text{dam}}\) are weights in the open interval \((0,1)\). The mission benefit is
$$
J_{\text{ben}}=\sum_{M_{i}\in\mathcal{M}}C_{i}g_{i},
$$
where \(C_{i}\) is the intrinsic value of target \(M_{i}\). The flight-range cost is
$$
J_{\text{dis}}=\sum_{V_{k}\in\mathcal{V}}\frac{D_{k}}{D_{k}^{\max}}.
$$
The damage risk is
$$
J_{\text{dam}}=\sum_{M_{i}\in\mathcal{M}}\sum_{V_{k}\in\mathcal{V}}\sum_{j\in\{R,A,D\}}x_{ij,k}\rho_{ij,k},
$$
where \(\rho_{ij,k}\) is the threat risk probability when UAV drone \(V_{k}\) executes operation \(O_{ij}\). Therefore, the complete optimization problem is
$$
\begin{aligned}
\max \quad & J=\omega_{\text{ben}}J_{\text{ben}}-\omega_{\text{dis}}J_{\text{dis}}-\omega_{\text{dam}}J_{\text{dam}},\\
\text{s.t.}\quad & D_{k}\le D_{k}^{\max},\\
& \sum_{V_{k}\in\mathcal{V}}x_{ij,k}=1,\\
& x_{ij,k}=0 \text{ if } T_{k}\ne \operatorname{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_{k,t}\in\{0,1\},\\
& g_{i}\in\{0,1\}.
\end{aligned}
$$
I solve this model by an offline training and online inference strategy. During training, I parameterize candidate-edge selection with a heterogeneous graph neural network and a pointer decoder. I use masked Gumbel-Softmax to approximate discrete action selection with differentiable weights. During inference, I first filter valid candidate edges to guarantee hard-constraint feasibility, then use greedy decoding or beam search to select operation-to-UAV-drone matching edges until a complete schedule is formed.
| Objective term | Expression | Interpretation |
|---|---|---|
| Mission benefit | \(J_{\text{ben}}=\sum C_{i}g_{i}\) | Reward complete reconnaissance-strike-assessment chains |
| Flight-range cost | \(J_{\text{dis}}=\sum D_{k}/D_{k}^{\max}\) | Penalize excessive UAV drone travel |
| Damage risk | \(J_{\text{dam}}=\sum x_{ij,k}\rho_{ij,k}\) | Control exposure to threat |
| Overall objective | \(J=\omega_{\text{ben}}J_{\text{ben}}-\omega_{\text{dis}}J_{\text{dis}}-\omega_{\text{dam}}J_{\text{dam}}\) | Balance benefit, cost, and risk |
4. Heterogeneous Disjunctive Graph Representation
I represent the scheduling state as a heterogeneous disjunctive graph:
$$
G_{t}=(\mathcal{O},\mathcal{V},\mathcal{P},\mathcal{C},\mathcal{A}),
$$
where \(\mathcal{O}\) is the operation-node set, \(\mathcal{V}\) is the UAV drone-node set, \(\mathcal{P}\) is the precedence-edge set, \(\mathcal{C}\) is the candidate operation-to-UAV-drone matching-edge set, and \(\mathcal{A}\) is the set of already determined execution edges. Operation nodes include reconnaissance, strike, and damage-assessment operations, plus virtual start and end nodes. UAV drone nodes represent available resources. Precedence edges encode the internal order of each target chain. Candidate matching edges connect an operation node to a UAV drone that may execute it. At each decision instant, the scheduler selects one candidate edge from \(\mathcal{C}\). If edge \((O_{ij},V_{k})\) is selected, operation \(O_{ij}\) is assigned to UAV drone \(V_{k}\). The system then updates task states, UAV drone states, and the candidate edge set.
For each operation node \(O_{ij}\), I define a feature vector
$$
\mu_{ij}\in\mathbb{R}^{12},
$$
which includes whether the operation is scheduled, the number of candidate UAV drones, actual start time, number of unfinished predecessors, estimated finish time, target position, target value, required UAV drone capability, time-window lower bound, time-window upper bound, and operation duration. For each UAV drone node \(V_{k}\), I define
$$
\nu_{k}\in\mathbb{R}^{10},
$$
which includes capability type, maximum range, flight speed, current availability, number of candidate tasks, base, current position, current task end time, and cumulative flight distance.
For each candidate edge
$$
e_{ij,k}=(O_{ij},V_{k}),
$$
I define an edge feature
$$
\lambda_{ij,k}\in\mathbb{R}^{4},
$$
which includes flight distance from the current UAV drone position to the target, estimated flight time, execution risk, and remaining-range ratio after execution.
| Entity | Feature vector | Dimension | Representative content |
|---|---|---|---|
| Operation node | \(\mu_{ij}\) | 12 | Schedule flag, predecessor count, time window, duration, target value, capability requirement |
| UAV drone node | \(\nu_{k}\) | 10 | Type, range, speed, availability, position, accumulated distance |
| Candidate edge | \(\lambda_{ij,k}\) | 4 | Distance, flight time, risk, remaining-range ratio |
5. Valid Candidate Edge Filtering
I reduce the action space and enforce feasibility by filtering candidate edges at every decision instant. A candidate edge is valid only if it satisfies six conditions simultaneously: the operation is not scheduled; all predecessors of the operation are complete; the UAV drone is available or can arrive within the allowed time; the UAV drone capability matches the task requirement; the accumulated flight distance does not exceed the maximum range; and the operation can be completed inside its time window. I write the valid candidate edge set as
$$
\mathcal{E}_{\text{valid}}(t)=\{e\in\mathcal{C}\mid C_{1}\land C_{2}\land C_{3}\land C_{4}\land C_{5}\land C_{6}\}.
$$
The six conditions \(C_{1}\) through \(C_{6}\) correspond to the above requirements. By applying this filter, the policy does not search over all operation-UAV-drone combinations. It only selects among currently feasible actions. This mechanism compresses the action space and prevents illegal scheduling actions. The procedure is summarized below.
| Condition | Meaning | Effect |
|---|---|---|
| \(C_{1}\) | Operation is unscheduled | Avoids duplicate execution |
| \(C_{2}\) | Predecessors are complete | Enforces task chain order |
| \(C_{3}\) | UAV drone available or can arrive | Prevents temporal conflict |
| \(C_{4}\) | Capability matches | Ensures payload compatibility |
| \(C_{5}\) | Range limit is respected | Ensures UAV drone reachability |
| \(C_{6}\) | Time window is respected | Guarantees temporal validity |
The filtering algorithm takes the current graph \(G_{t}\), unscheduled operation set, UAV drone state set, task time windows, range limits, and capability requirements as inputs. It outputs the valid edge set \(\mathcal{E}_{\text{valid}}(t)\) and edge features. If the valid set is empty, the system outputs a waiting, termination, or graph-reconstruction signal. Otherwise, the valid set is passed to the pointer decoder for action selection.
6. Heterogeneous Graph Neural Network Encoder
Because operation nodes and UAV drone nodes have different semantics and raw feature dimensions, I first project each type into a unified latent space with type-specific linear mappings:
$$
h_{O_{ij}}=W_{O}\mu_{ij}+b_{O},
$$
$$
h_{V_{k}}=W_{V}\nu_{k}+b_{V}.
$$
Here \(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 use heterogeneous graph attention to aggregate neighborhood information. For node p and neighbor q, the attention weight is
$$
\alpha_{pq}=\operatorname{softmax}\left(\operatorname{LeakyReLU}\left(\mathbf{a}^{T}[W h_{p}\|W h_{q}\|\phi_{e}]\right)\right),
$$
where \(\phi_{e}\) encodes the edge type or edge feature, \(\|\) denotes concatenation, and \(\mathbf{a}\) and \(W\) are learnable parameters. The updated node representation 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.
| Encoder component | Setting |
|---|---|
| Attention layers | 3 |
| Hidden dimension | 128 |
| Dropout probability | 0.1 |
| Operation feature dimension | 12 |
| UAV drone feature dimension | 10 |
| Edge feature dimension | 4 |
7. Candidate Edge Embedding and Pointer Decoder
I define an atomic scheduling action as selecting a valid candidate edge
$$
e_{ij,k}=(O_{ij},V_{k}).
$$
The candidate edge representation is formed from the operation-node embedding, UAV drone-node embedding, and edge features:
$$
z_{ij,k}=[h_{O_{ij}}\|h_{V_{k}}\|\lambda_{ij,k}].
$$
I further transform this representation with a multi-layer perceptron:
$$
g_{ij,k}=\operatorname{MLP}_{e}(z_{ij,k}).
$$
This edge representation contains task demand, UAV drone state, matching relation, flight cost, and risk information. The pointer-style decoder then directly points to one candidate object in the current set. Unlike a fixed-dimensional classifier, the pointer decoder can handle variable candidate-edge sets, which is suitable for UAV drone swarm scheduling at different scales.
I obtain the global graph-state representation by 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}=\mathbf{u}^{T}\tanh(W_{g}g_{t}+W_{e}g_{ij,k}+b).
$$
On the valid candidate edge set \(\mathcal{E}_{\text{valid}}(t)\), I normalize the scores to obtain the scheduling action probability:
$$
P(e_{ij,k}\mid G_{t})=\frac{\exp(s_{ij,k})}{\sum_{e\in\mathcal{E}_{\text{valid}}(t)}\exp(s_{e})}.
$$
This probability represents the likelihood of choosing candidate edge \(e_{ij,k}\) as the next scheduling action under the current scheduling state.
| Decoder element | Expression | Role |
|---|---|---|
| Edge embedding | \(z_{ij,k}=[h_{O_{ij}}\|h_{V_{k}}\|\lambda_{ij,k}]\) | Combine node and edge information |
| Nonlinear edge transform | \(g_{ij,k}=\operatorname{MLP}_{e}(z_{ij,k})\) | Increase representational power |
| Global graph state | \(g_{t}=\sum_{p}\beta_{p}h_{p}\) | Summarize the scheduling state |
| Selection score | \(s_{ij,k}=\mathbf{u}^{T}\tanh(W_{g}g_{t}+W_{e}g_{ij,k}+b)\) | Score each valid candidate edge |
| Action probability | \(P(e_{ij,k}\mid G_{t})=\frac{\exp(s_{ij,k})}{\sum_{e}\exp(s_{e})}\) | Select the next operation-to-UAV-drone edge |
8. Differentiable Surrogate Training
I define the scheduling action at the current decision instant as selecting one candidate edge from \(\mathcal{E}_{\text{valid}}(t)\). The selection probability is
$$
P(e\mid G_{t}),\quad e\in\mathcal{E}_{\text{valid}}(t).
$$
Because edge selection is discrete, a direct argmax operation cannot be trained end-to-end. I introduce masked Gumbel-Softmax to approximate the discrete selection process in a differentiable manner. For any valid edge e, the soft selection weight is
$$
y_{e}(t)=\frac{\exp\left(\left(\log P(e\mid G_{t})+g_{e}\right)/\tau\right)}{\sum_{e’\in\mathcal{E}_{\text{valid}}(t)}\exp\left(\left(\log P(e’\mid G_{t})+g_{e’}\right)/\tau\right)},
$$
where \(g_{e}\) is Gumbel noise and \(\tau>0\) is a temperature parameter. As \(\tau\) decreases, \(y_{e}(t)\) approaches a one-hot selection result. To combine differentiability during training with discrete execution during forward scheduling, 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).
$$
In the backward pass, I still propagate gradients through the soft selection weights \(y_{e}(t)\). This allows end-to-end optimization of the pointer decoder parameters.
To align training with the scheduling objective, I construct a differentiable surrogate objective directly from the comprehensive metric. Let \(y_{e}(t)\) denote the soft assignment weight of candidate edge e at decision time t. The differentiable approximations of mission benefit, flight-range cost, and damage risk are
$$
\hat{J}_{\text{ben}}=\sum_{M_{i}\in\mathcal{M}}C_{i}\hat{g}_{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}.
$$
Here \(\hat{g}_{i}\) is the soft indicator of complete reconnaissance-strike-assessment task chain for target \(M_{i}\). The quantity \(d_{e}\) is the normalized flight-range cost associated with selecting candidate edge e, and \(r_{e}\) is the normalized risk cost. The comprehensive objective loss is
$$
\hat{J}_{\text{obj}}=\omega_{\text{ben}}\hat{J}_{\text{ben}}-\omega_{\text{dis}}\hat{J}_{\text{dis}}-\omega_{\text{dam}}\hat{J}_{\text{dam}}.
$$
This loss encourages the model to increase complete task-chain benefit while suppressing flight cost and execution risk.
9. Constraint Penalties and Total Loss
I explicitly penalize time-window, precedence, range, and resource-conflict violations during differentiable training. These penalties improve feasibility and robustness of the output schedule. The time-window penalty is
$$
\mathcal{L}_{\text{tw}}=\sum_{O_{ij}\in\mathcal{O}}\left[\max(0,t_{\min}(O_{ij})-\hat{t}^{s}(O_{ij}))+\max(0,\hat{t}^{f}(O_{ij})-t_{\max}(O_{ij}))\right],
$$
where \(\hat{t}^{s}\) and \(\hat{t}^{f}\) are differentiable approximations of start and finish times. The task precedence penalty is
$$
\mathcal{L}_{\text{pre}}=\sum_{M_{i}\in\mathcal{M}}\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 constraint penalty is
$$
\mathcal{L}_{\text{rng}}=\sum_{V_{k}\in\mathcal{V}}\max(0,\hat{D}_{k}-D_{k}^{\max}),
$$
where \(\hat{D}_{k}\) is the cumulative flight distance of UAV drone \(V_{k}\) in the differentiable approximate schedule. The resource-conflict penalty captures overlap when the same UAV drone is assigned multiple operations in overlapping time intervals:
$$
\mathcal{L}_{\text{res}}=\sum_{V_{k}\in\mathcal{V}}\sum_{(a,k)\ne(b,k)}\max\left(0,\min(\hat{t}_{a,k}^{f},\hat{t}_{b,k}^{f})-\max(\hat{t}_{a,k}^{s},\hat{t}_{b,k}^{s})\right).
$$
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}\), and \(\lambda_{4}\) are penalty weights.
| Loss term | Mathematical form | Purpose |
|---|---|---|
| Objective loss | \(\hat{J}_{\text{obj}}=\omega_{\text{ben}}\hat{J}_{\text{ben}}-\omega_{\text{dis}}\hat{J}_{\text{dis}}-\omega_{\text{dam}}\hat{J}_{\text{dam}}\) | Optimize benefit, range, and risk |
| Time-window penalty | \(\mathcal{L}_{\text{tw}}\) | Enforce temporal feasibility |
| Precedence penalty | \(\mathcal{L}_{\text{pre}}\) | Enforce reconnaissance-strike-assessment order |
| Range penalty | \(\mathcal{L}_{\text{rng}}\) | Enforce UAV drone range limits |
| Resource penalty | \(\mathcal{L}_{\text{res}}\) | Prevent simultaneous UAV drone use |
| Total loss | \(\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}}\) | Joint training objective |
10. End-to-End Training Procedure
I train the heterogeneous graph neural network encoder and pointer decoder end-to-end. The training procedure is as follows. First, I randomly generate UAV drone swarm scheduling scenarios at different scales, including base distributions, UAV drone attributes, target positions, time windows, and threat levels. Second, 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)\). Third, I input the graph state into the heterogeneous graph neural network to obtain operation-node and UAV drone-node embeddings and to construct candidate-edge representations. Fourth, I use the pointer decoder to output a candidate-edge probability distribution, and I use masked Gumbel-Softmax to generate a differentiable approximate action selection. Fifth, I update the scheduling state approximately and accumulate the comprehensive objective and constraint penalties. Sixth, I backpropagate the total loss and update network parameters. Seventh, I evaluate the comprehensive objective value, scheduling feasibility rate, task-chain completion rate, and solution efficiency on a validation set, and I save the best-performing model.
| Training parameter | Setting |
|---|---|
| Optimizer | AdamW |
| Training epochs | 1,000 |
| Episodes per epoch | 64 |
| Evaluation episodes | 50 |
| Gradient accumulation steps | 8 |
| Gradient clipping threshold | 0.5 |
| Weight decay | \(1\times 10^{-5}\) |
| Learning-rate strategy | Warm-up plus cosine decay |
| Learning-rate range | \(1.5\times 10^{-5}\rightarrow 5.0\times 10^{-5}\rightarrow 1.5\times 10^{-5}\) |
| Warm-up epochs | 50 |
| Gumbel-Softmax initial temperature | 2.5 |
| Gumbel-Softmax final temperature | 0.5 |
| Hard-sampling start epoch | 25 |
The learning rate first rises linearly from \(1.5\times 10^{-5}\) to \(5.0\times 10^{-5}\) for warm-up, then decays by cosine annealing back to \(1.5\times 10^{-5}\). I use this schedule to balance convergence speed, decoding-distribution smoothness, training stability, and final scheduling performance.
11. Online Scheduling with the Trained UAV Drone Policy
In the online application phase, I load the offline-trained heterogeneous graph neural network and pointer decoder parameters. At each decision instant, the scheduler builds a heterogeneous disjunctive graph from the currently acquired target information, UAV drone states, and task constraints. It then generates the valid candidate edge set. The model performs one forward pass to output candidate-edge selection probabilities. According to the current state, the scheduler determines the next 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, I update the following states: the completion status of the scheduled task; the position, available time, and cumulative range of the corresponding UAV drone; the predecessor-constraint status of successor tasks; the candidate edge set; and the cumulative benefit, range cost, and risk of the current schedule. The online scheduling procedure is summarized below.
| Step | Online scheduling operation |
|---|---|
| 1 | Initialize task states, UAV drone states, and schedule \(\Pi\) |
| 2 | While unscheduled operations remain, construct current heterogeneous disjunctive graph \(G_{t}\) |
| 3 | Generate valid candidate edge set \(\mathcal{E}_{\text{valid}}(t)\) under constraints |
| 4 | If \(\mathcal{E}_{\text{valid}}(t)=\varnothing\), stop scheduling and output current schedule |
| 5 | Input \(G_{t}\) and \(\mathcal{E}_{\text{valid}}(t)\) into the trained model |
| 6 | Output selection probability \(P(e\mid G_{t})\) for each candidate edge |
| 7 | Select action \(e_{t}\) by greedy decoding or beam search |
| 8 | Add \(e_{t}\) to schedule \(\Pi\) |
| 9 | Update task states, UAV drone states, and candidate edge set |
| 10 | Return final schedule \(\Pi\) |
12. Simulation Setup for Heterogeneous UAV Drone Swarms
I evaluate the method in an online test scenario with two UAV drone bases. Each base deploys heterogeneous UAV drones, with 18 UAV drones in total. The swarm must cooperatively complete reconnaissance, strike, and damage-assessment task chains for 6 targets. The base, UAV drone, and target parameters are listed in the following tables. The values are representative synthetic settings used to test scalability, constraint handling, and scheduling quality.
| UAV drone | Type | Base | Speed (m/s) | Maximum range (km) | Initial 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) | Benefit | Threat | Reconnaissance time window | Reconnaissance duration | Strike time window | Strike duration | Assessment time 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 |
13. Training Behavior and Scheduling Quality
During training, I observe that the loss curve decreases rapidly in the early phase. The model quickly learns the mapping between scheduling states and candidate actions. In the stable phase, the loss curve shows only small fluctuations and no obvious divergence. This indicates that the heterogeneous graph neural network and pointer decoder have good training stability.
The benefit curve is initially near a relatively high level, then fluctuates during early training. This behavior is expected because the model is still exploring different operation-to-UAV-drone matching edges. As training proceeds, the benefit value rises and stabilizes. The final policy learns effective operation-UAV-drone matching relations and forms a strong benefit-oriented scheduling strategy under multiple constraints.
The risk curve reflects the trade-off among mission benefit, resource matching, and risk constraints. Early in training, the model explores different schedules and the risk value is unstable. Later, the risk value stabilizes, which indicates that the model gradually forms a stable risk-assessment and scheduling-selection mechanism. The path-length curve first fluctuates, then decreases, then stabilizes. This pattern shows that the method can reduce total flight-range consumption while satisfying task constraints, thereby improving path economy of the UAV drone swarm.
| Behavior | Observed trend | Interpretation |
|---|---|---|
| Loss | Fast early decrease, small later fluctuation | Stable end-to-end training |
| Benefit | Early fluctuation, later rise and stabilization | Effective operation-to-UAV-drone matching |
| Risk | Early instability, later stabilization | Balanced risk-aware scheduling |
| Path length | Fluctuation, decline, then stabilization | Improved flight-range economy |
14. Comparison with Alternative Scheduling Methods
I compare the proposed method with a genetic algorithm, a greedy algorithm, and a graph-free learning model. Except for solution time, all indicators are normalized means over 50 independent evaluations. The proposed method does not require population initialization, crossover, mutation, or multi-generation iterative search during inference, so it reduces online search overhead. Compared with a greedy algorithm, the proposed method learns task-resource matching rules during offline training and performs continuous decision making during inference rather than selecting only the immediate local optimum. Compared with a graph-free learning model, the proposed method explicitly encodes task dependencies, resource matching relations, and candidate execution relations 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 |
| Proposed method | 0.81 | 1 | 0.827 | 1 |
The comparison shows that the proposed method achieves a favorable balance among benefit, flight-range cost, damage risk, and solution time. It can generate feasible schedules quickly and achieves strong comprehensive performance in complex constrained scenarios. The graph representation helps the model exploit structural information in the scheduling problem. The pointer decoder enables direct action selection over a variable number of valid candidate edges. The differentiable surrogate training avoids reliance on expert-labeled samples and online reinforcement-learning interaction.
15. Ablation and Sensitivity Analysis
I also examine the contribution of key components. Removing valid candidate edge filtering increases the action space and raises the probability of infeasible actions. Removing the heterogeneous graph encoder weakens the ability to capture task dependency and resource matching relations. Removing the pointer decoder and replacing it with a fixed-dimensional classifier reduces adaptability to variable candidate sets. Removing the differentiable surrogate objective and training only with constraint penalties reduces the quality of the benefit-risk trade-off. These observations confirm that the full architecture is necessary for strong performance.
| Variant | Feasibility rate | Benefit score | Range score | Risk score | Relative solution time |
|---|---|---|---|---|---|
| Full proposed method | High | High | High | High | Moderate |
| Without valid-edge filtering | Reduced | Moderate | Moderate | Moderate | Higher |
| Without heterogeneous graph encoder | Moderate | Reduced | Reduced | Moderate | Lower |
| Without pointer decoder | Moderate | Reduced | Moderate | Reduced | Moderate |
| Without differentiable surrogate objective | Moderate | Reduced | Reduced | Reduced | Moderate |
The sensitivity of the method to penalty weights is also important. If penalty weights are too small, the learned policy may select actions that violate time windows or resource exclusivity. If penalty weights are too large, the policy may become overly conservative and sacrifice benefit. Therefore, I tune the weights to balance feasibility and objective quality. The temperature parameter of Gumbel-Softmax controls the smoothness of the discrete approximation. A high initial temperature encourages exploration. A low final temperature encourages deterministic selection. The warm-up and cosine decay schedule stabilizes training.
| Parameter | Effect when too low | Effect when too high | Desired behavior |
|---|---|---|---|
| Time-window penalty weight | Time-window violations | Over-conservative schedule | Feasible and efficient |
| Precedence penalty weight | Chain-order violations | Delayed task execution | Strict chain order |
| Range penalty weight | Range-limit violations | Underuse of capable UAV drones | Range-safe assignment |
| Resource penalty weight | Simultaneous assignments | Low resource utilization | Conflict-free execution |
| Gumbel temperature | Premature determinism | Noisy selection | Stable exploration then exploitation |
16. Online Gantt-Style Execution Behavior
In the online test, the scheduler triggers rolling decisions when reconnaissance time windows start. For example, when a target enters its executable window, the system triggers a decision instant. The agent outputs the next operation-to-UAV-drone matching action based on the current scheduling state. Different UAV drones execute tasks in parallel while respecting the reconnaissance-to-strike-to-assessment dependency and resource constraints. Flight phases and execution phases are connected continuously on the time axis. This reflects that the rolling decision mechanism can maintain feasibility and consistency under dynamic constraints.
The online experiment indicates that the proposed method can continuously generate executable real-time scheduling decisions. It maximizes cumulative mission benefit while considering flight-range cost and damage risk. Therefore, the algorithm is feasible, responsive, and effective in online UAV drone swarm scheduling.
| Online property | Behavior | Consequence |
|---|---|---|
| Rolling decision | Triggered by time-window events | Adapts to dynamic state changes |
| Parallel execution | Multiple UAV drones operate simultaneously | Improves swarm efficiency |
| Chain consistency | Reconnaissance before strike before assessment | Preserves mission logic |
| Resource consistency | No UAV drone executes conflicting tasks | Maintains feasibility |
| Objective balance | Benefit, range, and risk are jointly considered | Improves comprehensive quality |
17. Discussion
The proposed method has several advantages. First, the heterogeneous disjunctive graph provides a structured representation that unifies task operations, UAV drone resources, candidate matching edges, and precedence constraints. Second, valid candidate edge filtering guarantees that the policy selects only feasible actions at each decision instant. Third, the heterogeneous graph neural network extracts relation-aware embeddings from task nodes, UAV drone nodes, and candidate edges. Fourth, the pointer decoder naturally handles variable-size candidate sets. Fifth, the differentiable surrogate objective enables end-to-end training without expert labels or online reinforcement-learning interaction.
However, several limitations remain. The current model assumes that target information and threat levels are available when decisions are made. In real missions, perception may be noisy or delayed. The model also assumes that UAV drone failures do not occur during a schedule. If a UAV drone fails, the schedule may need to be reconstructed. Communication constraints are not explicitly modeled. Time windows are treated as hard constraints, but in some missions they may be soft or uncertain. Future work should consider sudden UAV drone faults, dynamic target appearance, changing time windows, communication restrictions, and lightweight online fine-tuning mechanisms.
| Dimension | Current treatment | Future extension |
|---|---|---|
| Target information | Available at decision time | Noisy and delayed perception |
| UAV drone health | No sudden failure | Fault-tolerant replanning |
| Communication | Implicitly reliable | Limited connectivity and delay |
| Time windows | Hard constraints | Soft or stochastic windows |
| Online adaptation | Offline training then inference | Lightweight online fine-tuning |
18. Mathematical Summary of the Proposed UAV Drone Scheduling Pipeline
I summarize the complete pipeline in a compact mathematical form. The scheduling state is represented by
$$
G_{t}=(\mathcal{O},\mathcal{V},\mathcal{P},\mathcal{C},\mathcal{A}).
$$
The valid action set is
$$
\mathcal{E}_{\text{valid}}(t)=\{e\in\mathcal{C}\mid C_{1}\land C_{2}\land C_{3}\land C_{4}\land C_{5}\land C_{6}\}.
$$
The node embeddings are
$$
h_{O_{ij}}=W_{O}\mu_{ij}+b_{O},\quad h_{V_{k}}=W_{V}\nu_{k}+b_{V}.
$$
The graph attention update is
$$
h_{p}’=\sigma\left(\sum_{q\in\mathcal{N}(p)}\alpha_{pq}W h_{q}\right).
$$
The candidate edge score is
$$
s_{ij,k}=\mathbf{u}^{T}\tanh(W_{g}g_{t}+W_{e}g_{ij,k}+b).
$$
The action probability is
$$
P(e_{ij,k}\mid G_{t})=\frac{\exp(s_{ij,k})}{\sum_{e\in\mathcal{E}_{\text{valid}}(t)}\exp(s_{e})}.
$$
The differentiable selection weight is
$$
y_{e}(t)=\frac{\exp\left(\left(\log P(e\mid G_{t})+g_{e}\right)/\tau\right)}{\sum_{e’\in\mathcal{E}_{\text{valid}}(t)}\exp\left(\left(\log P(e’\mid G_{t})+g_{e’}\right)/\tau\right)}.
$$
The total 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}}.
$$
This pipeline directly connects graph representation, candidate filtering, neural encoding, pointer decoding, and differentiable optimization. It is designed for heterogeneous UAV drone swarms with reconnaissance, strike, and damage-assessment task chains.
19. Conclusion
I have presented a scheduling algorithm for UAV drone swarms based on a heterogeneous graph neural network and a pointer-style decoder. I formulated a multi-constraint optimization model for integrated reconnaissance, strike, and damage-assessment tasks. I represented scheduling states as heterogeneous disjunctive graphs and used valid candidate edge filtering to compress the action space and guarantee feasibility. I designed a heterogeneous graph neural network to extract task-node, UAV drone-node, and candidate-edge embeddings. I introduced a pointer decoder to output scheduling action probabilities over valid operation-to-UAV-drone matching edges. I trained the model end-to-end with a differentiable surrogate objective using masked Gumbel-Softmax and constraint penalties. Simulation results show that the method can quickly generate feasible schedules and achieves a favorable balance among mission benefit, flight-range cost, damage risk, and solution efficiency. Future work will extend the method to fault-tolerant, communication-limited, and highly dynamic UAV drone swarm missions.