Graph-Attention Constrained DRL for Joint Task Offloading and Resource Allocation in UAV-Assisted Internet of Vehicles

Highlights

What are the main findings?

• A UAV-assisted IoV framework is proposed that jointly optimizes UAV hovering position selection, split task offloading between UAV and RSU, and multi-dimensional communication and computing resource allocation under dynamic vehicular environments.
• A graph-attention-based constrained TD3 (GAT-CTD3) algorithm is developed to solve the resulting CMDP, effectively capturing spatial correlations among vehicular tasks while explicitly enforcing long-term UAV energy constraints.

What is the implication of the main finding?

• The proposed GAT-CTD3 scheme can enhance the task completion rate, reduce end-to-end delay, and lower the energy consumption per task completed by the UAV, especially under dense traffic conditions.
• This provides a scalable and energy-efficient learning framework, offering practical guidance for deploying intelligent UAV-assisted IoV systems under strict latency and energy constraints.

Abstract

Unmanned aerial vehicles (UAVs) acting as mobile aerial edge platforms can deliver on-demand communication and computing for the Internet of Vehicles (IoV) via flexible deployment and line-of-sight (LoS) links, improving reliability and reducing latency. However, high vehicle mobility, time-varying channels, and limited onboard energy make task offloading and resource coordination challenging. This paper studies joint task offloading and resource allocation in a UAV-assisted IoV system, where the UAV selects its hovering position from discrete candidate sites each time slot and splits vehicular tasks between the UAV and a roadside unit (RSU) to relieve backhaul congestion and enhance edge resource utilization. Considering vehicle mobility, multi-stage queue dynamics, and UAV energy consumption for communication, computation, and movement, the online optimization of position selection, task splitting, and bandwidth allocation is formulated as a constrained Markov decision process (CMDP). The goal is to maximize the number of tasks completed within the latency deadlines while satisfying the UAV energy budget. To solve this CMDP, we propose a graph-attention-based constrained twin delayed deep deterministic policy gradient (GAT-CTD3) algorithm. A graph attention network captures spatial correlations and resource competition among active vehicles, while a Lagrangian TD3 framework enforces long-term energy constraints and improves learning stability via twin critics, delayed policy updates, and target smoothing. The simulation results demonstrate that it outperforms the comparative scheme in terms of task completion rate, delay, and energy consumption per completed task, and exhibits strong robustness in situations with dense traffic.

1. Introduction

The rapid development of intelligent transportation systems has accelerated the deployment of the Internet of Vehicles (IoV), where massive sensing, perception, and computing tasks are generated by connected vehicles to support safety-critical and latency-sensitive applications such as autonomous driving [1], cooperative perception [2], and traffic management [3]. In particular, multi-vehicle collaborative perception relies on efficient information sharing and distributed computing processing, but faces critical challenges such as limited communication bandwidth and dynamic environmental uncertainty [4], which puts forward higher requirements for the real-time operation and reliability of vehicular edge computing systems. These applications impose stringent requirements on task execution latency, reliability, and resource efficiency, which pose significant challenges to conventional cloud-centric computing architectures [5].

Mobile edge computing (MEC) has emerged as a promising paradigm to bring computation and storage resources closer to vehicles by deploying roadside units (RSUs) equipped with edge servers [6]. However, due to the limited coverage of RSUs and the highly dynamic mobility of vehicles, RSU-based MEC alone may fail to provide consistent low-latency services, especially in scenarios with sparse infrastructure or traffic congestion. To address these challenges, unmanned aerial vehicles (UAVs) have been introduced as aerial MEC platforms to assist vehicular networks by offering flexible communication links and on-demand computing services [7]. Owing to their high mobility and line-of-sight transmission capability, UAVs can effectively complement terrestrial infrastructure and enhance service availability in IoV systems [8].

In recent years, extensive research efforts have focused on UAV-assisted IoV systems, particularly on task offloading and resource allocation problems [9]. Existing studies have investigated joint optimization of communication bandwidth, transmission power, and computing resources using optimization theory or deep reinforcement learning (DRL) techniques [10]. Despite their effectiveness, most existing works rely on simplified system assumptions that limit their practical performance. First, many studies assume that the UAV operates at a fixed location or follows a predetermined trajectory, thereby neglecting the impact of UAV positioning decisions on channel quality and system performance [11]. Second, task offloading models are often restricted to binary or full offloading schemes, where computation tasks are entirely executed at RSUs or edge servers, leaving the computing capability of UAVs underutilized. As a result, the UAV-to-RSU backhaul link and RSU computing resources may become performance bottlenecks. Third, although DRL-based approaches [12] have shown promise in handling dynamic vehicular environments, most of them incorporate system constraints such as energy consumption and task deadlines through heuristic reward penalties, which cannot guarantee long-term constraint satisfaction in highly dynamic scenarios [13].

In this work, we establish a UAV-assisted collaborative sensing and computing system for the IoV, which consists of a fixed RSU integrated with an MEC server, a single multi-rotor UAV serving as both a mobile aerial edge computing node and a communication relay, and a set of connected vehicles generating latency-sensitive collaborative sensing tasks, as shown in Figure 1. In this system, the UAV can dynamically select its hovering position from a set of discrete candidate sites in each time slot to adapt to the time-varying vehicular distribution, and supports arbitrary split computing of vehicular tasks between the UAV and the RSU to balance the backhaul link load and edge resource utilization. We explicitly model the vehicle mobility, multi-stage task queue dynamics, and the UAV’s total energy consumption including communication, computation, and mobility components, with the goal of maximizing the number of tasks completed within the latency deadline under the strict long-term UAV energy budget constraint.

To address the resulting highly coupled and constrained optimization problem, we formulate the joint decision-making process as a constrained Markov decision process (CMDP), aiming to maximize the long-term task completion performance subject to latency and energy constraints. To efficiently solve the CMDP, we propose a graph-attention-based constrained twin delayed deep deterministic policy gradient (GAT-CTD3) algorithm. In the proposed approach, graph attention networks (GATs) [14] are employed to capture the dynamic spatial topology and interactions among vehicular tasks, while a constrained TD3 framework with Lagrange multipliers is adopted to ensure strict compliance with system constraints. The proposed algorithm enables scalable and adaptive control in environments with time-varying vehicle densities and network conditions.

The main contributions of this paper are as follows:

• We propose a novel UAV-assisted IoV framework that jointly optimizes UAV positioning, split computing between UAV and RSU, and multi-dimensional communication and computing resource allocation.
• We develop a split computing task offloading model that leverages the UAV’s computing capability to alleviate backhaul congestion and RSU workload, thereby improving overall system performance.
• We design a graph-attention-based constrained TD3 algorithm to solve the formulated CMDP, enabling efficient and constraint-aware decision-making in dynamic vehicular environments.
• The simulation results demonstrate that the proposed scheme significantly outperforms the comparative scheme in terms of task completion rate, execution delay, and energy efficiency.

The rest of this paper is organized as follows: Section 2 reviews related work on UAV-assisted task offloading and the application of reinforcement learning in MEC. Section 3 presents the system model and problem formulation. Section 4 presents the proposed GAT-CTD3 algorithm. and analyzes its training procedure and complexity. Section 5 provides simulation results and performance evaluations. Finally, Section 6 concludes the paper and discusses potential future research directions.

2. Related Work

2.1. UAV-Assisted Task Offloading and Resource Allocation for IoV

With the explosive growth of latency-sensitive computing tasks in the Internet of Vehicles, MEC has become a core paradigm to address the limitations of traditional cloud-centric architectures [15]. For vehicular application scenarios, a collaborative vehicular edge computing framework is proposed in work [16], which efficiently leverages heterogeneous edge computing architectures through horizontal and vertical collaboration to support scalable services for large-scale Internet of Vehicles. To compensate for the limited coverage of ground-based RSUs and the dynamic nature of vehicle distribution, UAVs have been introduced as aerial mobile edge computing nodes [17]. They enhance the probability of establishing Line-of-Sight (LoS) links and improve service capabilities in congested areas. In recent years, extensive research has focused on the optimization modeling, resource allocation, and online decision-making of UAV-assisted task offloading.

The work in ref. [18] investigated UAV-assisted offloading in vehicular edge computing (VEC) and addressed long-term energy constraints via a Lyapunov optimization framework, achieving online latency minimization while ensuring queue stability. In more general UAV-assisted mobile edge computing (UAV-MEC) systems, researchers have formulated mixed-integer nonlinear programming (MINLP) problems that jointly optimize UAV trajectory, bandwidth, and computational resources, which are then solved using methods such as successive convex approximation (SCA) and block coordinate descent (BCD) [19]. For the cooperative path planning problem of multi-UAV systems, recent work [20] proposed a dual-centralized Q-network reinforcement learning method, which effectively mitigates the value overestimation bias of critic networks and achieves stable path planning under multiple constraints. The study [21] addressed the issue of insufficient joint optimization between key system parameters and task offloading decisions in UAV-assisted mobile edge computing by proposing a joint optimal design scheme for UAV altitude and task offloading. This was done to overcome the performance limitations in communication and computation resulting from neglecting three-dimensional spatial parameters, thereby achieving optimized enhancement of the overall system performance. The work in ref. [22] addressed the issues of dynamic imbalance in computing resources and inefficient task offloading in vehicular edge computing networks by proposing a UAV-assisted joint task offloading and resource allocation scheme. The work in ref. [23] proposed a digital twin-assisted intelligent partial offloading scheme to address the problem of achieving real-time and precise optimization of offloading decisions and resource allocation in dynamic vehicular environments while ensuring task reliability. The study [24] proposed a coordinated optimization scheme for joint resource allocation and task offloading to address the issue of efficient collaborative utilization of task scheduling and computing and communication resources among multiple UAVs. The study [25] addressed the issues of insufficient heterogeneous resource collaboration and complex dynamic task scheduling in air–ground cooperative UAV-enabled mobile edge computing, proposing a joint task offloading scheduling and resource allocation optimization scheme based on air–ground cooperation.

Overall, while existing studies on UAV-assisted IoV offloading have achieved rich outcomes in system modeling and average performance optimization, insufficient attention has been paid to systematic modeling of reliability and tail latency risk, making it difficult to meet the stability and robustness requirements of safety-critical collaborative sensing applications.

2.2. Task Offloading and Resource Allocation Scheme Based on Deep Reinforcement Learning

With the rise of artificial intelligence, DRL has emerged as a mainstream approach for solving high-dimensional sequential decision-making problems in dynamic edge computing environments. The work [26] confirmed the superiority of the DQN algorithm over Q-learning by comparing total costs across different scenarios. The work [27] introduced an entropy-weighted reward function and employed the DQN algorithm to optimize resource allocation strategies, thereby effectively improving the learning efficiency of the agent. The study [28] proposed a deep reinforcement learning-based joint optimization scheme to address the challenge that traditional optimization methods could not adapt in real-time to complex system state dynamics. The study [29] proposed a deep reinforcement learning-based joint task offloading and resource allocation scheme to solve the problem of ensuring task deadline constraints while achieving the global and efficient utilization of computing and communication resources across edge nodes within the federation. The work in [30] proposed a deep reinforcement learning-based edge computing task offloading optimization scheme to address the need for efficient and adaptive real-time decision-making in dynamic network states, while optimizing system latency and reliability. The study [31] proposed a Deep Deterministic Policy Gradient (DDPG)-based joint optimization scheme for task offloading and content caching, aiming to reduce task processing latency while improving content delivery efficiency and network resource utilization. The study [32] proposed a deep reinforcement learning-based joint task partitioning and resource allocation optimization scheme to address the efficient collaborative scheduling of computational and communication resources under complex task structures. The design of a reward function is the core of DRL-based sequential decision-making, and recent work [33] has verified that the combination of extrinsic and intrinsic reward shaping can effectively enhance the agent’s constraint compliance and decision-making performance in complex multi-UAV cooperative scenarios. Existing methods typically adopt scalar value functions to model cumulative rewards, focusing solely on the expectation characteristics of rewards while neglecting the tail behavior of the reward distribution. This renders low-probability yet high-impact events unable to be effectively perceived and controlled. For IoV collaborative perception scenarios where safety and reliability are core requirements, this expectation-driven optimization paradigm struggles to meet stringent latency and reliability constraints. Therefore, there is an urgent need for a task offloading and resource allocation approach that can incorporate tail risk awareness and robust optimization mechanisms while preserving the flexibility and online decision-making capability of DRL.

Existing research on partial offloading in UAV-assisted IoV typically focuses on optimizing offloading ratios and resource allocation but fails to integrate topology-aware representation learning into the decision-making process [34]. DRL methods often assume binary offloading or rely on simple vector concatenation to construct states, making it difficult to effectively capture the coupling relationships among vehicles in dense traffic scenarios [35]. Constrained reinforcement learning approaches in MEC/UAV systems commonly employ heuristic reward penalties or non-topological encoders, which cannot simultaneously achieve scalable spatial modeling and strict long-term energy budget satisfaction. Therefore, there is currently a lack of a unified framework that can jointly explore the integration of split computation with graph-attention-constrained TD3.

In summary, in contrast to the above research, this paper designs an adaptive joint resource allocation scheme for UAV-assisted IoV systems and customizes a GAT-CTD3 agent to support the joint optimization of UAV positioning, split computing, and multi-dimensional communication and computing resources in highly dynamic environments. The proposed method formulates the problem as a constrained Markov decision process and explicitly enforces the long-term UAV energy constraint via a Lagrangian-based learning framework. In addition, by leveraging graph attention networks to capture spatial correlations among active vehicular tasks, the proposed scheme eliminates the dependence on prior environmental information during training and effectively reduces the state representation and space complexity of the adaptive resource allocation model while ensuring robust system performance and scalability.

3. System Modeling

We consider a UAV-assisted collaborative sensing and computing system for the IoV. The system comprises an RSU equipped with an MEC server, a single UAV, and a set of vehicles K denoted by $\mathcal{K}=\{1,2,\dots ,K\}$. The RSU is fixed at a known location, denoted by its horizontal coordinate $\mathbf{r}\in {\mathbb{R}}^2$. The UAV operates at a constant altitude H and provides enhanced communication and computation assistance to ground vehicles. Time is discretized into slots of equal duration $\tau$. The time horizon is indexed by $t\in \{0,1,\dots ,T-1\}$. Each vehicle $k\in \mathcal{K}$ generates a collaborative sensing task. A task is formally defined by a tuple ${\mathrm{Task}}_k=(t_k,D_k,C_k,T_k^{\max })$, where $t_k$ is the task arrival time, $D_k$ is the size of the collected sensing data, $C_k$ represents the required computing resources per bit, and $T_k^{\max }$ is the maximum tolerable end-to-end latency for the task. The main symbols in the system are shown in

Table 1. Key notation in multi-UAV MEC system.

Symbol	Description	Symbol	Description
$\mathcal{K}$	Set of vehicles in the IoV system	k	Index of vehicle and its corresponding task
t	Discrete time-slot index	$\tau$	Duration of one time slot
${\mathcal{K}}_a\left(t\right)$	Set of active vehicular tasks at time slot t	${\mathbf{A}}_k\left(t\right)$	Position of vehicle k at time t
${\mathbf{A}}_U\left(t\right)$	Position of the UAV at time t	${\mathbf{A}}_R$	Fixed position of the RSU
$\mathcal{P}$	Set of candidate UAV hovering positions	$m\left(t\right)$	Index of UAV hovering position at time t
$D_k$	Size of sensing data generated by vehicle k	$C_k$	Required CPU cycles per bit for task k
$T_k^{\max }$	Maximum tolerable latency of task k	$S_k$	Total fused task data size of vehicle k
$L_k$	Total required CPU cycles of task k	${\rho }_k\left(t\right)$	Task split computing ratio between UAV and RSU
${\xi }_{k,U}\left(t\right)$	Bandwidth allocation ratio for vehicle–UAV uplink	${\xi }_{k,R}\left(t\right)$	Bandwidth allocation ratio for UAV–RSU offloading
$B_U$	Total available uplink bandwidth from vehicles to the UAV	$B_R$	Total available backhaul bandwidth from the UAV to the RSU
$P_k^t\left(t\right)$	Transmit power of vehicle k at time slot t	$P_U^t\left(t\right)$	Transmit power of the UAV at time slot t
$f_{k,u}\left(t\right)$	CPU allocation ratio of UAV for task k	$f_k\left(t\right)$	CPU allocation ratio of RSU for task k
$R_{k,U}\left(t\right)$	Uplink transmission rate from vehicle k to UAV	$R_{k,R}\left(t\right)$	Offloading transmission rate from UAV to RSU
$I_{k,U}\left(t\right)$	Remaining uplink data of task k	$I_{k,u}\left(t\right)$	Remaining UAV-side computing workload of task k
$I_{k,R}\left(t\right)$	Remaining offloading data of task k	$I_{k,c}\left(t\right)$	Remaining RSU-side computing workload of task k
$c_{k,U}\left(t\right)$	Indicator of vehicle–UAV uploading stage	$c_{k,u}\left(t\right)$	Indicator of UAV computing stage
$c_{k,R}\left(t\right)$	Indicator of UAV–RSU offloading stage	$c_{k,c}\left(t\right)$	Indicator of RSU computing stage
$r\left(t\right)$	Instantaneous reward at time slot t	$c\left(t\right)$	Instantaneous UAV energy cost at time slot t
$E_U$	Total energy consumption of the UAV	$E_U^{\max }$	Maximum allowable UAV energy budget
$s\left(t\right)$	Original system state at time t	${\mathbf{s}}_e\left(t\right)$	GAT-encoded system state
$a\left(t\right)$	Joint action at time t

.

3.1. Motion Model

We consider a discrete-time system where the position of the ground vehicle k at time slot t is denoted by ${\mathbf{A}}_k\left(t\right)=\left(x_k\left(t\right),y_k\left(t\right),0\right)$. Let ${\mathbf{v}}_k\left(t\right)$ and ${\mathbf{a}}_k\left(t\right)$ represent the velocity and acceleration of vehicle k, respectively. The position update equation can be represented as

$${\mathbf{A}}_k(t+1)={\mathbf{A}}_k\left(t\right)+{\mathbf{v}}_k\left(t\right)\tau +{\displaystyle \frac{1}{2}}{\mathbf{a}}_k\left(t\right){\tau }^2,\forall t,$$

(1)

$${\mathbf{v}}_k(t+1)={\mathbf{v}}_k\left(t\right)+{\mathbf{a}}_k\left(t\right)\tau ,\forall t,$$

(2)

where $\tau$ is the duration of each time slot.

Unlike the conventional assumption of a fixed UAV location, we allow the UAV to dynamically select its horizontal hovering position from a finite set of candidate points $\mathcal{P}=\{{\mathbf{p}}_1,{\mathbf{p}}_2,\dots ,{\mathbf{p}}_M\},$ ${\mathbf{p}}_m=(x_m,y_m,H)$, with H being the fixed UAV altitude. At each time slot t, the UAV chooses an index $m\left(t\right)\in \{1,\dots ,M\}$, so that its three-dimensional position is given by ${\mathbf{A}}_U\left(t\right)={\mathbf{p}}_{m\left(t\right)}$.

To account for practical mobility limitations, we impose a maximum horizontal displacement constraint between consecutive slots:

$$∥{\mathbf{A}}_U(t+1)-{\mathbf{A}}_U\left(t\right)∥\le V_{\max }\tau ,\forall t,$$

(3)

where $V_{\max }$ denotes the maximum horizontal speed of the UAV. The RSU under consideration has a fixed position ${\mathbf{A}}_R\left(t\right)=(x_R,y_R,0)$.

3.2. Communication Model

We assume LoS dominated channels and adopt the free-space path loss model. The distance between vehicle k and the UAV is $d_{k,U}\left(t\right)=\sqrt{H^2+{\parallel {\mathbf{A}}_U\left(t\right)-{\mathbf{A}}_k\left(t\right)\parallel }^2}$, and the UAV–RSU distance is $d_{U,R}\left(t\right)=\sqrt{H^2+{\parallel {\mathbf{A}}_U\left(t\right)-{\mathbf{A}}_R\parallel }^2}$.

Accordingly, the channel gains are given by

$$\begin{array}{cc}\hfill g_{k,U}\left(t\right)& ={\displaystyle \frac{P_U^r}{d_{k,U}^2\left(t\right)}}={\displaystyle \frac{P_U^r}{H^2+{\parallel {\mathbf{A}}_U\left(t\right)-{\mathbf{A}}_k\left(t\right)\parallel }^2}},\forall k,\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill g_{U,R}\left(t\right)& ={\displaystyle \frac{P_R^r}{d_{U,R}^2\left(t\right)}}={\displaystyle \frac{P_R^r}{H^2+{\parallel {\mathbf{A}}_U\left(t\right)-{\mathbf{A}}_R\parallel }^2}},\forall k,\hfill \end{array}$$

(5)

where $P_U^r$ and $P_R^r$ are the received power constants for UAV and RSU, respectively.

To eliminate inter-vehicle interference, we adopt orthogonal frequency division multiple access (OFDMA). We define $B_U$ as the total bandwidth available at the UAV for vehicle to UAV uplink, and $B_R$ denote the total bandwidth at the RSU for UAV to RSU offloading. We define ${\xi }_{k,U}\left(t\right)\in [0,1]$ as the bandwidth ratio allocated to vehicle k at slot t, and ${\xi }_{k,R}\left(t\right)\in [0,1]$ as the bandwidth ratio allocated to the offloading flow of vehicle k on the UAV to RSU link. Then the achievable transmission rates are

$$\begin{array}{cc}\hfill R_{k,U}\left(t\right)& ={\xi }_{k,U}\left(t\right)B_U{log}_2\left(1+{\displaystyle \frac{g_{k,U}\left(t\right)P_k^t\left(t\right)}{{\sigma }_{k,U}^2}}\right),\forall t,\hfill \end{array}$$

(6)

$$\begin{array}{cc}\hfill R_{k,R}\left(t\right)& ={\xi }_{k,R}\left(t\right)B_R{log}_2\left(1+{\displaystyle \frac{g_{U,R}\left(t\right)P_U^t\left(t\right)}{{\sigma }_{U,R}^2}}\right),\forall t,\hfill \end{array}$$

(7)

where $P_k^t\left(t\right)$ and $P_U^t\left(t\right)$ denote the transmit powers of vehicle k and the UAV, and ${\sigma }_{k,U}^2$ and ${\sigma }_{U,R}^2$ are the noise powers on the corresponding links.

3.3. Computation Model

In addition to the vehicle sensing data $D_k$, the UAV collects local sensing data of size $D_{U,k}$ associated with vehicle k. Thus, the fused task data size is $S_k=D_k+D_{U,k}$. The total required CPU cycles for processing the fused task is $L_k=C_k·S_k$.

We enable split computing between the UAV and the RSU. We define ${\rho }_k\left(t\right)\in [0,1]$ as the computing split ratio for vehicle k at slot t; i.e., a ${\rho }_k\left(t\right)$ fraction of the fused CPU cycles is processed at the UAV, while the remaining $1-{\rho }_k\left(t\right)$ fraction is processed at the RSU. Therefore, the UAV computing workload and RSU computing workload are

$$L_{k,U}^{\mathrm{cmp}}\left(t\right)={\rho }_k\left(t\right)L_k,L_{k,R}^{\mathrm{cmp}}\left(t\right)=(1-{\rho }_k\left(t\right))L_k.$$

(8)

Moreover, we assume that the UAV-side processing reduces the amount of data to be offloaded to the RSU proportionally; i.e., only the unprocessed fraction needs to be offloaded:

$$S_k^{\mathrm{off}}\left(t\right)=(1-{\rho }_k\left(t\right))S_k.$$

(9)

This proportional reduction assumption is motivated by common collaborative sensing tasks such as feature extraction, data compression, or preliminary filtering, where the output data size is roughly proportional to the fraction of processed workload. For example, in object detection or environment mapping tasks, processing a portion of the raw sensor data typically yields a correspondingly smaller set of features or reduced-resolution outputs. This linear relationship simplifies the queueing dynamics and resource coupling, making the problem tractable for DRL-based optimization while still capturing the essential trade-off between local computation and backhaul offloading. However, we acknowledge that this assumption may not hold for all task types. In certain applications (e.g., cryptographic operations or full-data analytics), the output size may be independent of the processing fraction, or processing may even increase the data volume (e.g., through data augmentation). In such cases, a more sophisticated data-dependent model would be required. We leave the extension to non-linear or task-specific data reduction models as future work, noting that the core algorithmic framework remains applicable with appropriate modifications to the state and transition functions.

3.4. Queueing Dynamics and Delay Model

Each task is completed via four sequential stages: (i) vehicle-to-UAV uploading, (ii) UAV computing, (iii) UAV-to-RSU offloading, and (iv) RSU computing. We use binary stage indicators $c_{k,U}\left(t\right),c_{k,u}\left(t\right),c_{k,R}\left(t\right),c_{k,c}\left(t\right)\in \{0,1\}$ to denote whether task k is in stage (i)–(iv) at slot t, satisfying

$$c_{k,U}\left(t\right)+c_{k,u}\left(t\right)+c_{k,R}\left(t\right)+c_{k,c}\left(t\right)\le 1,\forall k,t.$$

(10)

3.4.1. Vehicle-to-UAV Uploading

We define $I_{k,U}\left(t\right)$ as the remaining uplink data of task k to be uploaded. Given $I_{k,U}\left(t_k\right)=D_k$, its evolution is

$$I_{k,U}(t+1)={\left[I_{k,U}\left(t\right)-c_{k,U}\left(t\right)R_{k,U}\left(t\right)\tau \right]}^{+},\forall t,$$

(11)

where ${[·]}^{+}=\max \{·,0\}$.

3.4.2. UAV Computing

We define $F_U$ as the total CPU frequency of the UAV. Define $f_{k,u}\left(t\right)\in [0,1]$ as the CPU ratio allocated to task k at the UAV, with ${\sum }_k{f}_{k,u}\left(t\right)\le 1$. We define $I_{k,u}\left(t\right)$ as the remaining UAV-side CPU cycles. Given $I_{k,u}\left(t_k\right)={\rho }_k\left(t_k\right)L_k$, the evolution is

$$I_{k,u}(t+1)={\left[I_{k,u}\left(t\right)-c_{k,u}\left(t\right)f_{k,u}\left(t\right)F_U\tau \right]}^{+},\forall t.$$

(12)

3.4.3. UAV-to-RSU Offloading

We define $I_{k,R}\left(t\right)$ as the remaining offloading data from the UAV to the RSU. Given $I_{k,R}\left(t_k\right)=S_k^{\mathrm{off}}\left(t_k\right)$, its evolution is

$$I_{k,R}(t+1)={\left[I_{k,R}\left(t\right)-c_{k,R}\left(t\right)R_{k,R}\left(t\right)\tau \right]}^{+},\forall t.$$

(13)

3.4.4. RSU Computing

We define $F_R$ as the RSU MEC server CPU frequency. Define $f_k\left(t\right)\in [0,1]$ as the RSU CPU ratio allocated to task k, with ${\sum }_k{f}_k\left(t\right)\le 1$. We define $I_{k,c}\left(t\right)$ as the remaining RSU-side CPU cycles. Given $I_{k,c}\left(t_k\right)=(1-{\rho }_k\left(t_k\right))L_k$, its evolution is

$$I_{k,c}(t+1)={\left[I_{k,c}\left(t\right)-c_{k,c}\left(t\right)f_k\left(t\right)F_R\tau \right]}^{+},\forall t.$$

(14)

3.4.5. End-to-End Delay Calculation

Each task is processed sequentially through the four stages defined above, and the end-to-end execution delay $T_k^{end}$ of task k is defined as the total time elapsed from the task arrival time $t_k$ to the time when all four processing stages are fully completed.

Specifically, we denote the time slot when task k completes the vehicle-to-UAV uploading stage as $t_{k,1}$, the time slot when it completes the UAV local computing stage as $t_{k,2}$, the time slot when it completes the UAV-to-RSU offloading stage as $t_{k,3}$, and the time slot when it completes the RSU computing stage as $t_{k,finish}$. The end-to-end delay is formally calculated as:

$$T_k^{end}=t_{k,finish}-t_k,\forall k$$

(15)

where the duration of each processing stage is determined by the queue dynamics defined in Equations (11)–(14), and the time slot duration $\tau$. For a task that is fully processed at the UAV (i.e., ${\rho }_k\left(t_k\right)=1$), the UAV-to-RSU offloading and RSU computing stages are skipped, and its end-to-end delay is $T_k^{end}=t_{k,2}-t_k$.

3.5. Energy Consumption Model

In UAV-assisted IoV systems, energy efficiency is a critical design concern, as the UAV operates under a limited onboard battery capacity. In this work, we explicitly model the UAV energy consumption, which serves as a long-term system constraint in the subsequent optimization and learning framework. The total UAV energy consumption consists of three components: communication energy, computation energy, and mobility energy.

3.5.1. Vehicle Transmission Energy

Although the energy consumption of ground vehicles is not directly constrained in this work, we model the uplink transmission energy for completeness and performance evaluation. The uplink transmission energy consumed by vehicle k is given by

$$E_k^{\mathrm{tx}}=\sum _t{c}_{k,U}\left(t\right)P_k^t\left(t\right)\tau ,$$

(16)

where $P_k^t\left(t\right)$ denotes the transmit power of vehicle k at slot t. This term captures the energy cost incurred during the vehicle-to-UAV data uploading stage.

3.5.2. UAV Transmission, Computing, and Mobility Energy

The UAV communication energy arises from transmitting partially processed task data to the RSU over the UAV-to-RSU backhaul link. The corresponding transmission energy is modeled as

$$E_U^{\mathrm{tx}}=\sum _t\sum _k{c}_{k,R}\left(t\right)P_U^t\left(t\right)\tau ,$$

(17)

where $P_U^t\left(t\right)$ denotes the UAV transmit power.

The UAV computing energy is modeled using the widely adopted dynamic CPU power consumption model, where power scales cubically with the CPU frequency.

Specifically, the UAV computational energy consumption is given by

$$E_U^{\mathrm{cmp}}=\sum _t\sum _k{c}_{k,u}\left(t\right){\kappa }_U{\left(f_{k,u}\left(t\right)F_U\right)}^3\tau ,$$

(18)

where $F_U$ denotes the total UAV CPU frequency, $f_{k,u}\left(t\right)$ is the CPU allocation ratio for task k, and ${\kappa }_U$ is the effective switched-capacitance coefficient of the UAV processor. In addition to communication and computation, the UAV expends energy when changing its hovering position.

Given the discrete UAV positioning model, the UAV mobility energy is approximated as a linear function of the horizontal displacement:

$$E_U^{\mathrm{mov}}=\sum _t{\eta }_U\parallel {\mathbf{A}}_U(t+1)-{\mathbf{A}}_U\left(t\right)\parallel ,$$

(19)

where ${\eta }_U$ denotes the propulsion energy cost per unit distance. The total UAV energy is

$$E_U=E_U^{\mathrm{tx}}+E_U^{\mathrm{cmp}}+E_U^{\mathrm{mov}}.$$

(20)

In our discrete hovering positioning framework, we adopt this linear mobility model, where the UAV performs only small displacement adjustments between adjacent candidate locations in each time slot. Under such low-speed and short-distance movements, the linear approximation incurs relatively minor prediction error compared with high-fidelity nonlinear propulsion models. Meanwhile, it effectively reduces the state-space complexity of the subsequent DRL-based decision framework. This modeling setting is widely adopted in UAV-assisted edge computing studies with similar discrete hovering scenarios.

3.6. Problem Formulation

Our objective is to maximize the number of tasks completed within their delay deadlines by jointly optimizing UAV positioning, split computing, and communication/computing resource allocation. Let the decision variables be

$$X={\left\{{\xi }_{k,U}\left(t\right),{\xi }_{k,R}\left(t\right),f_{k,u}\left(t\right),f_k\left(t\right),{\rho }_k\left(t\right),m\left(t\right)\right\}}_{\forall k,t}.$$

(21)

We define $y_k$ to represent whether the collaborative sensing task of vehicle k is completed within the delay threshold as follows: if completed, $y_k=1$; otherwise, $y_k=0$. Therefore, the optimization problem can be formulated as

$$\mathbf{P}:\underset{X}{\max }\sum _{k=1}^K{y}_k$$

s.t.

$$\begin{array}{cc}\hfill C1:& 0\le {\xi }_{k,U}\left(t\right)\le 1,0\le {\xi }_{k,R}\left(t\right)\le 1,\forall k,t,\hfill \\ \hfill C2:& \sum _{k=1}^K{\xi }_{k,U}\left(t\right)\le 1,\sum _{k=1}^K{\xi }_{k,R}\left(t\right)\le 1,\forall t,\hfill \\ \hfill C3:& 0\le f_{k,u}\left(t\right)\le 1,0\le f_k\left(t\right)\le 1,\forall k,t,\hfill \\ \hfill C4:& \sum _{k=1}^K{f}_{k,u}\left(t\right)\le 1,\sum _{k=1}^K{f}_k\left(t\right)\le 1,\forall t,\hfill \\ \hfill C5:& 0\le {\rho }_k\left(t\right)\le 1,\forall k,t,\hfill \\ \hfill C6:& m\left(t\right)\in \{1,\dots ,M\},\forall t,\hfill \\ \hfill C7:& \parallel {\mathbf{A}}_U(t+1)-{\mathbf{A}}_U\left(t\right)\parallel \le V_{\max }\tau ,\forall t,\hfill \\ \hfill C8:& T_k^{end}\le T_k^{\max }+(1-y_k)\mathsf{\Delta },\forall k,\hfill \\ \hfill C9:& E_U\le E_U^{\max }.\hfill \end{array}$$

where $\mathsf{\Delta }$ is a sufficiently large constant used to link $y_k$ and the delay constraint, C1–C2 characterize the feasible bandwidth allocation regions for task transmission and offloading; C3–C4 specify the admissible computing resource allocation at the UAV and RSU, respectively; C5 constrains the task split computing ratio; C6–C7 ensure feasible UAV positioning and mobility across time slots; C8 represents the end-to-end delay requirement of each task, which must not exceed its maximum tolerable latency; and C9 enforces the UAV energy budget constraint.

Due to the coupled continuous and discrete decisions, non-linear wireless rates, and multi-stage queueing dynamics, Problem $\mathbf{P}$ is difficult to solve using conventional optimization methods. Moreover, stochastic task arrivals, time-varying channels, and long-term energy constraints lead to a sequential decision-making problem with unknown system dynamics. These characteristics motivate reformulating Problem $\mathbf{P}$ as a CMDP, which is addressed using a learning-based approach in the following section.

4. Approach Design

4.1. CMDP Formulation

We formulate the joint UAV positioning, split computing, and resource allocation problem as a CMDP. This formulation enables online decision-making under uncertainty while explicitly enforcing the UAV energy budget. A CMDP is defined by a tuple

$$\mathcal{M}=\langle \mathcal{S},\mathcal{A},\mathcal{P},r,c,\gamma \rangle ,$$

(22)

where $\mathcal{S}$, $\mathcal{A}$, and $\mathcal{P}$ denote the state space, action space, and state transition probability, respectively; r and c represent the reward and cost functions; and $\gamma \in (0,1)$ is the discount factor.

State: At time slot t, We define ${\mathcal{K}}_a\left(t\right)$ as the set of active vehicular tasks that have arrived but have not yet been completed. The system state is defined as

$$s\left(t\right)=\left({\left\{{\mathbf{x}}_k\left(t\right)\right\}}_{k\in {\mathcal{K}}_a\left(t\right)},\mathbf{z}\left(t\right)\right),$$

(23)

which consists of task-level features and global system features. ${\mathbf{x}}_k\left(t\right)$ is the feature vector of task k, including normalized remaining uplink data $I_{k,U}\left(t\right)$, remaining UAV/RSU computation queues $I_{k,u}\left(t\right)$, $I_{k,c}\left(t\right)$, remaining offloading data $I_{k,R}\left(t\right)$, remaining deadline $T_k^{\max }-T_k^{end}$, and the instantaneous vehicle–UAV channel gain $g_{k,U}\left(t\right)$. $\mathbf{z}\left(t\right)$ represents global information, including the current UAV hovering position index $m\left(t\right)$, the UAV–RSU channel gain $g_{U,R}\left(t\right)$, and the remaining UAV energy budget.

Action: The action at slot t consists of a mixed discrete-continuous decision vector, defined as

$$\begin{array}{c}\hfill a\left(t\right)=(m(t+1),\{{\xi }_{k,U}\left(t\right),{\xi }_{k,R}\left(t\right),\\ \hfill f_{k,u}\left(t\right),f_k\left(t\right),{\rho }_k\left(t\right){\}}_{k\in {\mathcal{K}}_a\left(t\right)}).\end{array}$$

(24)

where $m(t+1)\in \{1,\dots ,M\}$ determines the UAV’s next hovering position, ${\rho }_k\left(t\right)$ is the task split computing ratio between the UAV and the RSU.

In implementation, different activation functions are adopted to enforce heterogeneous feasibility constraints. Specifically, Softmax operations are applied to bandwidth and CPU allocation variables $\{{\xi }_{k,U},{\xi }_{k,R},f_{k,u},f_k\}$ to satisfy the simplex constraints across active tasks, while the task split computing ratio ${\rho }_k\left(t\right)$, which is independently bounded within $[0,1]$, is generated using a Sigmoid function.

Reward/Cost: The reward function is designed to directly reflect the system-level performance objective; i.e., maximizing the number of vehicular tasks that are successfully completed within their delay deadlines. If task k is completed within time t, then $Tk=1$; otherwise, $Tk=0$. Specifically, at time slot t, the instantaneous reward is defined as

$$r\left(t\right)=\sum _{k\in \mathcal{K}}\mathbb{I}\left(Tk\mathrm{and}{T}_k^{end}\le T_k^{max}\right),$$

(25)

where $\mathbb{I}(·)$ is the indicator function, and $T_k^{end}$ denotes the actual end-to-end execution delay of task k. This reward formulation encourages the learning agent to prioritize timely task execution and implicitly captures both communication and computation delays across multiple processing stages. We adopt a completed-task counting reward structure, which records the number of tasks successfully finished before their deadlines at each time slot. This design is directly aligned with the system-level optimization objective defined in Problem $\mathbf{P}$, namely maximizing the number of tasks that satisfy latency constraints, and it simplifies the complex weight tuning process typically required in multi-objective optimization. In addition, the explicit completion signal helps reduce the variance of policy gradient estimation, thereby improving learning stability.

In addition, the UAV operates under a limited onboard battery capacity, making energy efficiency a critical design concern. To explicitly account for this constraint, we define the instantaneous cost as the total energy consumption of the UAV within time slot t, which is formally expressed as:

$$c\left(t\right)=\mathsf{\Delta }{E}_U\left(t\right),$$

(26)

where $\mathsf{\Delta }{E}_U\left(t\right)$ denotes the incremental energy consumption of the UAV in the discrete time slot t, and the symbol $\mathsf{\Delta }$ is used to emphasize that this cost corresponds to the energy consumption within a single time slot (duration $\tau$). This per-slot energy consumption is strictly derived from the three energy components defined in Equations (17)–(20), and its specific calculation formula is:

$$\mathsf{\Delta }{E}_U\left(t\right)=\mathsf{\Delta }{E}_U^{tx}\left(t\right)+\mathsf{\Delta }{E}_U^{cmp}\left(t\right)+\mathsf{\Delta }{E}_U^{mov}\left(t\right).$$

(27)

Based on the definition of the cost per-slot, we further clarify the numerical link between the instantaneous cost $c\left(t\right)$ and the long-term energy budget $\overline{C}$ in the CMDP optimization objective. The total discounted long-term energy consumption of the UAV is the cumulative sum of the instantaneous cost per-slot $c\left(t\right)$ with the discount factor $\gamma$, and the upper bound of this cumulative value is the maximum allowed long-term energy budget $\overline{C}$. In the simulation implementation, $\overline{C}$ is numerically set according to the total energy capacity of the UAV’s onboard battery, the number of time slots in a single episode, and the discount factor, to ensure that the long-term constraint matches the actual physical energy limit of the UAV.

Based on the above definitions, the objective of the CMDP is to maximize the expected long-term discounted cumulative reward while ensuring that the long-term UAV energy consumption does not exceed a predefined budget. The CMDP optimization problem is expressed as

$$\underset{\pi }{\max }{J}_r\left(\pi \right)={\mathbb{E}}_{\pi }\left[\sum _{t=0}^{\infty }{\gamma }^{t}r\left(t\right)\right],$$

$$\mathrm{s}.\mathrm{t}.J_c\left(\pi \right)={\mathbb{E}}_{\pi }\left[\sum _{t=0}^{\infty }{\gamma }^{t}c\left(t\right)\right]\le \overline{C},$$

(28)

where $\pi$ denotes the control policy and $\overline{C}$ represents the maximum allowable long-term energy consumption of UAV.

This CMDP formulation explicitly decouples performance optimization and energy constraint enforcement, providing a basic foundation for applying constrained deep reinforcement learning to jointly optimize UAV positioning, split computing, and resource allocation in dynamic IoV environments.

4.2. GAT Encoder

In UAV-assisted IoV systems, multiple vehicular tasks coexist and compete for limited communication and computing resources. These tasks exhibit strong spatial correlations, since their channel conditions, queueing dynamics, and execution delays are jointly affected by the hovering position of the UAV and the geographical distribution of the vehicles. Simply concatenating task-level features is insufficient to capture such inter-task dependencies, which may lead to inefficient resource allocation decisions.

To explicitly model the interactions among active tasks, we adopt a GAT to encode the system state in a structure-aware manner.

At time slot t, let ${\mathcal{K}}_a\left(t\right)$ denote the set of active vehicular tasks that have arrived but are not yet completed. Each active task is generated by a unique vehicle. For notational convenience, we use the same index k to denote both vehicle k and the task generated by vehicle k, since each vehicle generates at most one task at a time.

Each task is represented as a graph node with feature vector ${\mathbf{x}}_k\left(t\right)$. To capture spatial proximity and communication relevance, we construct a sparse undirected task graph based on the Euclidean distance between the corresponding vehicles. Specifically, for each task node k, we connect it to its $K_n$ nearest neighboring task nodes, forming a local interaction neighborhood $\mathcal{N}\left(k\right)$. This K-nearest-neighbor (KNN) construction preserves essential spatial correlations while maintaining scalability as the number of active tasks varies over time. We fix $K_n$ = 5 instead of adopting density-dependent connectivity. A fixed neighborhood size ensures a stable graph structure and consistent-dimensional state embeddings under dynamic vehicle densities, which is crucial for the training stability of the DRL agent.

We define ${\mathbf{h}}_k^{\left(0\right)}\left(t\right)={\mathbf{x}}_k\left(t\right)$ as the initial embedding of the task node k. In the ℓ-th GAT layer, node representations are updated by aggregating information from neighboring nodes using an attention mechanism.

First, the unnormalized attention score between task node k and its neighbor $j\in \mathcal{N}\left(k\right)$ is computed as

$$\begin{array}{c}\hfill e_{kj}^{(\ell )}\left(t\right)=LeakyReLU\left({\mathbf{a}}^{(\ell )\top }\right[{\mathbf{W}}^{(\ell )}{\mathbf{h}}_k^{(\ell )}\left(t\right)\\ \hfill \Vert {\mathbf{W}}^{(\ell )}{\mathbf{h}}_j^{(\ell )}\left(t\right)\left]\right),\end{array}$$

(29)

where ${\mathbf{W}}^{(\ell )}$ is a learnable weight matrix, ${\mathbf{a}}^{(\ell )}$ is the attention vector, and ‖ denotes the concatenation operator.

The attention coefficients are then normalized across the neighborhood of node k using the softmax function:

$${\alpha }_{kj}^{(\ell )}\left(t\right)={\displaystyle \frac{exp\left(e_{kj}^{(\ell )}\left(t\right)\right)}{{\sum }_{u\in \mathcal{N}\left(k\right)}exp\left(e_{ku}^{(\ell )}\left(t\right)\right)}},$$

(30)

which reflects the relative importance of neighboring task j when updating the representation of task k.

Based on the computed attention coefficients, the embedding of node k is updated as

$${\mathbf{h}}_k^{(\ell +1)}\left(t\right)=\sum _{j\in \mathcal{N}\left(k\right)}{\alpha }_{kj}^{(\ell )}\left(t\right){\mathbf{W}}^{(\ell )}{\mathbf{h}}_j^{(\ell )}\left(t\right).$$

(31)

By stacking multiple GAT layers, each task node progressively incorporates higher-order interaction information from its spatial neighbors.

After $L_g$ GAT layers, we obtain the final task-level embeddings ${\mathbf{h}}_k^{\left(L_g\right)}\left(t\right)$ for all $k\in {\mathcal{K}}_a\left(t\right)$. To generate a permutation-invariant representation of the entire set of active tasks, we apply mean pooling:

$$\mathbf{g}\left(t\right)={\displaystyle \frac{1}{|{\mathcal{K}}_a\left(t\right)|}}\sum _{k\in {\mathcal{K}}_a\left(t\right)}{\mathbf{h}}_k^{\left(L_g\right)}\left(t\right).$$

(32)

Finally, the pooled task embedding is concatenated with the global system state $\mathbf{z}\left(t\right)$, yielding the encoded state representation

$${\mathbf{s}}_e\left(t\right)=\left[\mathbf{g}\left(t\right)\Vert \mathbf{z}\left(t\right)\right],$$

(33)

which serves as the input to both the actor and critic networks in the proposed GAT-CTD3 algorithm.

This graph-attention-based encoder enables the learning agent to capture spatial correlations and resource competition among vehicular tasks, thereby facilitating scalable and informed decision-making in dynamic UAV-assisted IoV environments.

4.3. GAT-CTD3

Classical DRL methods such as DDPG may suffer from overestimation bias and unstable training in continuous control. To improve robustness and learning stability, we adopt Twin Delayed Deep Deterministic Policy Gradient (TD3) as the backbone, and incorporate a Lagrangian-based constraint handling mechanism to enforce the long-term UAV energy budget, as shown in Figure 2. As mentioned previously, the GAT encoder maps the raw CMDP state $\mathbf{s}\left(t\right)$ into a fixed-dimensional embedding ${\mathbf{s}}_e\left(t\right)$. Based on ${\mathbf{s}}_e\left(t\right)$, we construct an actor network ${\pi }_{\theta }(·)$ that outputs the joint action $a\left(t\right)$, two critic networks $Q_{{\varphi }_1}(·)$ and $Q_{{\varphi }_2}(·)$ to mitigate overestimation bias (twin critics), and corresponding target networks ${\pi }_{{\theta }^{\prime }}(·)$, $Q_{{\varphi }_1^{\prime }}(·)$, and $Q_{{\varphi }_2^{\prime }}(·)$ for stable bootstrapping.

The CMDP objective in Equation (28) maximizes the long-term discounted reward while ensuring the long-term discounted energy cost satisfies $J_c\left(\pi \right)\le \overline{C}$. We handle this constraint by introducing a nonnegative Lagrange multiplier $\lambda \ge 0$, and define the penalized reward

$$\tilde{r}\left(t\right)=r\left(t\right)-\lambda (c\left(t\right)-\overline{C}).$$

(34)

This transformation converts the constrained optimization into a saddle-point problem: the policy seeks high reward while the multiplier increases whenever the energy budget tends to be violated.

Given a transition $({\mathbf{s}}_e\left(t\right),a\left(t\right),\tilde{r}\left(t\right),{\mathbf{s}}_e(t+1))$ sampled from the replay buffer, TD3 constructs a smoothed target action to reduce sensitivity to function approximation errors:

$$a^{\prime }(t+1)={\pi }_{\theta }\left({\mathbf{s}}_e(t+1)\right)+ϵ,$$

$$ϵ\sim \mathrm{clip}(\mathcal{N}(0,{\sigma }^2\mathbf{I}),-c_0,c_0),$$

(35)

where $\sigma$ controls exploration noise and $c_0$ is the clipping bound.

The TD target is then computed using the minimum of the two target critics:

$$y\left(t\right)=\tilde{r}\left(t\right)+\gamma \underset{i\in \{1,2\}}{min}{Q}_{{\varphi }_i^{\prime }}({\mathbf{s}}_e(t+1),a^{\prime }(t+1)),$$

(36)

which effectively alleviates overestimation bias.

Each critic minimizes the mean-squared Bellman error:

$${\mathcal{L}}_Q\left({\varphi }_i\right)=\mathbb{E}\left[{\left(Q_{{\varphi }_i}({\mathbf{s}}_e\left(t\right),a\left(t\right))-y\left(t\right)\right)}^2\right],i=1,2.$$

(37)

To further stabilize training, TD3 updates the actor less frequently than the critics. Every d critic updates, the actor is optimized by maximizing the expected Q-value under the current policy:

$$\underset{\theta }{\max }\mathbb{E}\left[Q_{{\varphi }_1}\left({\mathbf{s}}_e\left(t\right),{\pi }_{\theta }\left({\mathbf{s}}_e\left(t\right)\right)\right)\right].$$

(38)

Because the critics are trained with the augmented reward $\tilde{r}\left(t\right)$, the actor implicitly learns to trade off task completion performance and energy consumption through $\lambda$.

The Lagrange multiplier is updated via projected gradient ascent to enforce the long-term energy constraint:

$$\lambda \leftarrow {\left[\lambda +{\eta }_{\lambda }({\widehat{J}}_c-\overline{C})\right]}^{+},$$

(39)

where ${[·]}^{+}=\max \{·,0\}$, ${\eta }_{\lambda }$ is the multiplier learning rate, and ${\widehat{J}}_c$ denotes an empirical estimate of the discounted energy cost (e.g., batch-average of $c\left(t\right)$ in the sampled transitions). Intuitively, when ${\widehat{J}}_c>\overline{C}$, $\lambda$ increases and imposes a stronger penalty on energy usage; otherwise, $\lambda$ decreases toward zero.

The actor outputs heterogeneous decision variables subject to different feasibility constraints. For simplex-constrained allocations $\left\{{\xi }_{k,U}\left(t\right)\right\}$, $\left\{{\xi }_{k,R}\left(t\right)\right\}$, $\left\{f_{k,u}\left(t\right)\right\}$, and $\left\{f_k\left(t\right)\right\}$, we apply Softmax across active tasks so that the sum-to-one constraints are satisfied. For the split-computing ratio ${\rho }_k\left(t\right)\in [0,1]$, we apply a Sigmoid function independently. For the discrete hovering decision $m(t+1)\in \{1,\dots ,M\}$, we adopt a continuous relaxation during training: the actor outputs an M-dimensional probability vector via Softmax, and the environment executes the discrete action by selecting the maximum-probability index (i.e., an argmax projection). This preserves differentiability in policy learning while ensuring feasibility in execution. This design enables the proposed method to leverage TD3’s continuous-control stability while supporting the required discrete UAV positioning decision.

The target networks are softly updated as

$${\theta }^{\prime }\leftarrow {\tau }_s\theta +(1-{\tau }_s){\theta }^{\prime },$$

$${\varphi }_i^{\prime }\leftarrow {\tau }_s{\varphi }_i+(1-{\tau }_s){\varphi }_i^{\prime },i=1,2,$$

(40)

where ${\tau }_s\in (0,1)$ is the Polyak averaging coefficient. A replay buffer is used to store past transitions and perform off-policy updates, improving sample efficiency and breaking temporal correlations. The pseudo-code implementation is presented in Algorithm 1.

To ensure the full reproducibility of the proposed GAT-CTD3 algorithm and clarify the detailed design of the core neural network modules, we summarize the key architecture parameters of the GAT encoder, TD3 actor network, and twin critic networks in

Table 2. Core architecture and training parameters of the GAT-CTD3 network.

Network Module	Core Parameter	Value
1. GAT Encoder
GAT Encoder	Input feature dimension per task node	7
	Number of GAT layers $L_g$/attention heads	2/4
	Node embedding dimension $d_g$	64
	Activation function	LeakyReLU
	KNN neighbor size $K_n$/Dropout rate	5/0.1
	Final encoded state dimension $d_s$	67
2. TD3 Actor–Critic Networks
Actor Network	Network structure	3-layer fully connected MLP
	Input dimension	67
	Hidden layer dimensions	256, 128
	Output activation	Softmax/Sigmoid
Twin Critic Networks	Number of independent critics	2
	Network structure per critic	3-layer fully connected MLP
	Hidden layer dimensions	256, 128

. All parameter settings are strictly consistent with the algorithm design in Section 4 and the computational complexity analysis in Section 4.4, providing a complete technical reference for the implementation and replication of the model.

Algorithm 1 GAT-CTD3 for Joint UAV Positioning, Split Computing, and Resource Allocation

1: Initialize actor ${\pi }_{\theta }$, twin critics $Q_{{\varphi }_1},Q_{{\varphi }_2}$, target networks ${\pi }_{{\theta }^{\prime }},Q_{{\varphi }_1^{\prime }},Q_{{\varphi }_2^{\prime }}$, replay buffer $\mathcal{D}$, and $\lambda \leftarrow 0$ 2: for each episode do 3:       for each slot t do 4:             Build the task graph and obtain embedding ${\mathbf{s}}_e\left(t\right)$ using GAT 5:             Select mixed action $a\left(t\right)$ using ${\pi }_{\theta }\left({\mathbf{s}}_e\left(t\right)\right)$ 6:             Execute $a\left(t\right)$; observe reward $r\left(t\right)$, cost $c\left(t\right)$, and next state $s(t+1)$ 7:             Encode $s(t+1)$ as ${\mathbf{s}}_e(t+1)$ using GAT 8:             Store $({\mathbf{s}}_e\left(t\right),a\left(t\right),r\left(t\right),c\left(t\right),{\mathbf{s}}_e(t+1))$ into $\mathcal{D}$ 9:             if update step then 10:                 Sample a mini-batch from $\mathcal{D}$ and compute $\tilde{r}\leftarrow r-\lambda \left(c-\overline{C}\right)$ 11:                 Update $Q_{{\varphi }_1},Q_{{\varphi }_2}$ by minimizing ${\mathcal{L}}_Q$ 12:                 if every d steps then 13:                       Update actor ${\pi }_{\theta }$ 14:                       Update $\lambda \leftarrow {\left[\lambda +{\eta }_{\lambda }({\widehat{J}}_c-\overline{C})\right]}^{+}$ 15:                       Soft-update target networks 16:                 end if 17:             end if 18:       end for 19: end for

4.4. Complexity and Stability

In this subsection, we analyze the computational complexity of the proposed GAT-CTD3 algorithm and discuss its training stability properties. The computational complexity of the proposed method primarily consists of two components: one part is the state encoding based on the graph attention mechanism, and the other part is the actor–critic updates in TD3.

We define $N=|{\mathcal{K}}_a\left(t\right)|$ as the number of active vehicular tasks at time slot t, and let E denote the number of edges in the constructed task graph. Using the KNN construction described in Section 4.2, each node connects to at most $K_n$ neighbors, yielding $E=\mathcal{O}\left(N{K}_n\right)$.

For a GAT encoder with $L_g$ layers and embedding dimension $d_g$, the computational cost per forward pass is

$$\mathcal{O}\left(L_g\left(E{d}_g+N{d}_g^2\right)\right),$$

(41)

where the first term corresponds to neighborhood attention aggregation and the second term accounts for linear transformations of node features. This complexity scales linearly with the number of active tasks, making the encoder suitable for dynamic vehicular environments.

To provide a concrete illustration, consider a typical medium-load scenario in our experiments with $N=20$ active tasks, $K_n=5$ neighbors per node, $d_g=64$, and $L_g=2$ (consistent with our default experimental settings in Section 5.1). With the undirected KNN graph construction, the number of edges scales as $E\approx N{K}_n=100$. Substituting these values into Equation (41), the GAT encoder requires approximately $2\times (100\times 64+20\times {64}^2)=\mathrm{176,640}$ floating-point operations (FLOPs) per forward pass.

The TD3 component consists of standard multilayer perceptrons (MLPs) for the actor and twin critics. Let $d_a$ denote the action dimension and $d_s$ denote the dimension of the encoded state $s_e\left(t\right)$. The per-update complexity of the actor–critic networks is

$$\mathcal{O}\left(d_s{d}_a+d_s^2\right),$$

(42)

which is independent of the graph size and typically dominated by the GAT encoder when N is moderately large.

For our experimental setup, the encoded state dimension is $d_s=d_g+\left|z\right|=64+3=67$, where $\left|z\right|=3$ corresponds to the three global system features: UAV hovering position index, UAV-RSU channel gain, and remaining UAV energy budget. The action dimension is $d_a=M+5N=25+100=125$, where $M=25$ is the number of UAV candidate hovering positions, and 5 continuous allocation variables (${\xi }_{k,U}\left(t\right),{\xi }_{k,R}\left(t\right),f_{k,u}\left(t\right),f_k\left(t\right),{\rho }_k\left(t\right)$) are required for each active task. Thus, the actor–critic update cost in Equation (42) is $d_s{d}_a+d_s^2=67\times 125+{67}^2=\mathrm{12,864}$ FLOPs per update.

Overall, the total per-step computation is on the order of $1.9\times {10}^5$ FLOPs. This computational overhead is extremely lightweight for practical real-time decision making: even on a low-power edge computing platform, the full per-step inference can be completed within the 20 ms time slot duration $\tau$ defined in our system model, fully meeting the real-time requirements of dynamic IoV scenarios.

The training stability of the algorithm is achieved through an integrated design combining a GAT encoder, the TD3 framework, and a Lagrangian constraint mechanism. First, TD3’s twin critics, delayed policy updates, and target smoothing reduce value overestimation and variance, crucial for the mixed action space. Second, the GAT encoder provides a stable, permutation-invariant state representation that generalizes across dynamic task numbers and reduces noise. Third, the Lagrangian multiplier dynamically balances task performance with the UAV’s long-term energy constraint, preventing inefficient solutions. Finally, experience replay and soft target updates further enhance stability by relating samples and smoothing learning.

Overall, these design choices ensure that the proposed GAT-CTD3 algorithm achieves stable convergence and robust performance in dynamic UAV-assisted IoV environments with stochastic task arrivals and time-varying channel conditions.

5. Experiments and Analysis

5.1. Base Settings

In our experiments, we utilize TensorFlow 2.13.0 on an Anaconda3-2018.12 Windows x64 server, equipped with 4 NVIDIA GeForce RTX 2080 Ti GPUs and 1 AMD Ryzen 7@3.80 GHz CPU. The system is equipped with 64 GB of RAM. The simulation environment is built on Python 3.8. We consider a 3D urban road scenario of size $500\times 500\times 100$ m. The RSU is fixed at position $A_R=(250,250,0)$ m. The UAV altitude is fixed at $H=50$ m, and at each time slot, it selects a hovering position from the candidate set $P=\{p_1,\dots ,p_M\}$. Let $M=25$, with adjacent candidate points spaced 100 m apart. The speed constraint of the UAV is $V_{\max }=25\mathrm{m}/\mathrm{s}$, time slot $\tau =20\mathrm{ms}$, satisfying Equation (3). Vehicles move along predefined lanes with speeds between 8 to 15 m/s and follow the motion model defined in Equations (1) and (2). The UAV uplink bandwidth is $B_U=10\mathrm{MHz}$, and the RSU backhaul bandwidth is $B_R=20\mathrm{MHz}$. In terms of transmit power, the vehicle transmit power is $P_k^t=23\mathrm{dBm}$, and the UAV transmit power is $P_U^t=30\mathrm{dBm}$. The system noise power is set to ${\sigma }^2=-174\mathrm{dBm}/\mathrm{Hz}$. The channel path loss follows a free-space LoS model to simulate communication performance under ideal propagation conditions. The UAV CPU frequency is $F_U=10\mathrm{GHz}$, and the RSU CPU frequency is $F_R=50\mathrm{GHz}$. For task modeling, the vehicle task data size $D_k$ is uniformly distributed in the range $[10,20]\mathrm{Mbits}$, while the locally generated relevant data at the UAV, $D_{U,k}$, is uniformly distributed in $[5,10]\mathrm{Mbits}$. The CPU cycles $C_k$ required per bit for the task are between 500 and 1000 cycles/bit. Furthermore, the maximum tolerable latency for each task $T_k^{\max }$ is initialized to 0.5 to 1.0 s, serving as the delay constraint for task completion.

According to multiple experiments, the model training uses a batch size of $B=128$ and a learning rate of $\alpha =0.001$. Within the reinforcement learning framework, the discount factor is set to $\gamma =0.98$, and the experience replay buffer size is ${10}^5$. The graph attention network consists of $L_g=2$ layers with an embedding dimension of $d_g=64$. In the implementation of the TD3 algorithm, a delayed update strategy is applied: the Actor network is updated once every 2 updates of the Critic network. The target network soft update coefficient is ${\tau }_s=0.005$. For state encoding, a GAT encoder is used, which consists of 2 layers with a hidden dimension of 64 and 4 attention heads. The graph is constructed using the K-nearest neighbors method with $K_n=5$ neighbors. Furthermore, when employing the Lagrangian relaxation method to handle constraints, the learning rate for its multiplier is set to ${\eta }_{\lambda }=0.01$. Please refer to

Table 3. Key experimental parameter settings.

Parameter Category	Symbol	Value/Range	Unit
1. System and Environment Parameters
UAV fixed flight altitude	H	50	m
Maximum horizontal speed of UAV	$V_{max}$	25	m/s
Duration of one discrete time slot	$\tau$	20	ms
Vehicle moving speed	-	8–15	m/s
Task data size generated by vehicle	$D_k$	10–20	Mbits
UAV local fused sensing data size	$D_{U,k}$	5–10	Mbits
CPU cycles required per bit of task data	$C_k$	500–1000	cycles/bit
Maximum tolerable end-to-end latency of task	$T_k^{max}$	0.5–1.0	s
UAV propulsion energy cost per unit distance	${\eta }_U$	8	J/m
Effective switched-capacitance coefficient of UAV processor	${\kappa }_U$	${10}^{-28}$	F
2. Communication and Computing Parameters
Total uplink bandwidth (vehicle to UAV)	$B_U$	10	MHz
Total backhaul bandwidth (UAV to RSU)	$B_R$	20	MHz
Vehicle transmit power	$P_k^t$	23	dBm
UAV transmit power	$P_U^t$	30	dBm
System noise power spectral density	${\sigma }^2$	−174	dBm/Hz
Total CPU frequency of UAV	$F_U$	10	GHz
Total CPU frequency of RSU MEC server	$F_R$	50	GHz
3. Algorithm and Training Hyperparameters
Training batch size	B	128	-
Actor–critic network learning rate	$\alpha$	0.001	-
Discount factor	$\gamma$	0.98	-
Experience replay buffer size	-	${10}^5$	-
Number of GAT layers	$L_g$	2	-
GAT node embedding dimension	$d_g$	64	-
Number of GAT attention heads	-	4	-
GAT KNN neighbor size	$K_n$	5	-
TD3 delayed update frequency (Critic:Actor)	-	2:1	-
Target network soft update coefficient	${\tau }_s$	0.005	-
Lagrange multiplier learning rate	${\eta }_{\lambda }$	0.01	-

for detailed information.

To verify the stability and reproducibility of the proposed algorithm, all experiments are conducted with 5 different fixed random seeds. All performance metrics are reported as the mean ± standard deviation across 5 runs, with best and worst values provided to illustrate performance variance. Please refer to

Table 4. Performance comparison of different schemes with mean ± standard deviation across 5 independent random seeds.

Number of Vehicles K	Scheme	Task Completion Rate (Mean ± Std)	Average Execution Delay (Mean ± Std, Unit: s)	Energy Consumption per Task (Mean ± Std, Unit: J/Task)
10 (Low Load)	GAT-CTD3 (Ours)	0.98 ± 0.008	0.46 ± 0.021	115 ± 3.2
	TD3	0.95 ± 0.015	0.51 ± 0.028	130 ± 4.1
	DDPG	0.93 ± 0.017	0.58 ± 0.032	145 ± 4.5
	HGRA	0.88 ± 0.022	0.74 ± 0.037	161 ± 5.1
20 (Medium Load)	GAT-CTD3 (Ours)	0.94 ± 0.010	0.54 ± 0.023	122 ± 3.4
	TD3	0.85 ± 0.020	0.67 ± 0.032	160 ± 4.9
	DDPG	0.81 ± 0.024	0.79 ± 0.037	175 ± 5.3
	HGRA	0.72 ± 0.029	0.99 ± 0.042	204 ± 6.3
30 (High Load)	GAT-CTD3 (Ours)	0.90 ± 0.012	0.63 ± 0.024	130 ± 3.6
	TD3	0.78 ± 0.023	0.82 ± 0.035	191 ± 5.8
	DDPG	0.72 ± 0.028	0.98 ± 0.041	206 ± 6.2
	HGRA	0.55 ± 0.031	1.25 ± 0.045	252 ± 7.3

for detailed information.

In this work, a free-space LoS path loss model is used under ideal conditions to isolate the impact of joint hovering control and split computing optimization from stochastic channel effects. Realistic environments introduce probabilistic LoS/NLoS transitions, shadowing, and fading, causing transmission rate variability that may increase delay variance and reduce task completion ratios. The learned policy could mitigate this by selecting hovering positions nearer to vehicle clusters. Notably, the proposed CMDP formulation and GAT-CTD3 framework are channel-agnostic; sophisticated channel models can be incorporated by replacing the data rate expression. Evaluating under realistic fading and probabilistic LoS models is an important future direction.

5.2. Comparative Algorithms

To evaluate the performance of the proposed GAT-CTD3 algorithm, it is compared against several baseline methods commonly used in task offloading scenarios, and ablation baselines designed to verify the performance contribution of our core algorithm modules.

5.2.1. TD3-Based Joint Optimization (TD3-JO)

This method [36] uses the standard TD3 algorithm without graph attention encoding and Lagrangian constraint handling. It directly concatenates task features as state input and optimizes UAV positioning, split computing, and resource allocation via reward shaping with energy penalty.

5.2.2. Deep Deterministic Policy Gradient (DDPG)

The core idea of this method [37] is to use deterministic policy gradients with a single critic network for continuous action control. Instead of employing a Lagrangian multiplier method based on Constrained Markov Decision Processes, it handles constraints such as energy by directly adding penalty terms to the reward function.

5.2.3. Heuristic Greedy Resource Allocation (HGRA)

This is a rule-based heuristic method. UAV selects the nearest candidate position to the centroid of active vehicles. Tasks are fully offloaded to the RSU if its queue length is below a threshold; otherwise, split computing is applied with a fixed ratio ${\rho }_k=0.5$. Bandwidth and CPU are allocated proportionally to the remaining data for the task and the deadline.

5.2.4. GAT-TD3 with Heuristic Reward Penalty (GAT-TD3-RP)

This ablation baseline is designed to verify the superiority of the Lagrangian-based constrained optimization mechanism in our proposed GAT-CTD3 algorithm, compared with the widely used heuristic reward penalty method for constraint handling. This baseline adopts the exact same two-layer GAT encoder and standard TD3 framework as our proposed method, with the only difference being that it does not use the Lagrangian multiplier method to explicitly enforce the long-term energy constraint. Instead, it incorporates the UAV energy consumption into the reward function via a fixed penalty coefficient; i.e., the reward is defined as $r_{rp}\left(t\right)=r\left(t\right)-\beta ·\mathsf{\Delta }{E}_U\left(t\right)$, where $\beta$ is the pre-defined fixed energy penalty coefficient. This baseline is completely consistent with our proposed method in all other settings except the constraint handling mechanism, which can accurately isolate the performance contribution of the Lagrangian-based constrained TD3 framework.

5.3. Experimental Results and Analysis

Figure 3 illustrates the convergence of the reward during the training process of the proposed GAT-CTD3 algorithm under different learning rates. It can be observed that the learning rate of 0.001 yields the best convergence performance: the curve rises rapidly in the early phase and stabilizes at a high level later, indicating that this setting ensures substantial update steps while maintaining good training stability. In contrast, when the learning rate is reduced to 0.0001, the reward increases noticeably slower and ultimately stabilizes at a level lower than that of the 0.001 case. This is primarily because a smaller learning rate reduces the step size of each parameter update, thereby slowing down policy improvement; under a given number of training episodes, this may lead to insufficient convergence or difficulty in escaping local optima quickly, resulting in slightly inferior final convergence quality compared to the 0.001 case. Conversely, when the learning rate is increased to 0.01, the reward exhibits obvious non-convergence behavior, with the curve fluctuating significantly within a low or even negative range over a long period. This occurs because deep reinforcement learning training relies on relatively stable and gradual parameter updates. An excessively large learning rate leads to oversized update steps, causing instability in the exploration and optimization process, which ultimately manifests as oscillations or even divergence. Based on the comparative results above, we adopt 0.001 as the default learning rate in subsequent experiments to balance convergence speed with training stability.

Figure 4 illustrates the variation in the average task completion rates of different schemes under varying numbers of vehicles in the test environment. It can be observed that as the number of vehicles increases from 10 to 30, all schemes exhibit varying degrees of decline in completion rates. This is because a larger number of vehicles leads directly to increased concurrent service loads and intensified resource competition, thereby elevating the risk of congestion in uplink transmission, backhaul links, and edge computing queues. As a result, tasks are more likely to exceed latency constraints, ultimately leading to a reduction in the overall completion rate.

Specifically, when the number of vehicles is 10, the completion rate of GAT-CTD3 approaches 0.98. Even as the vehicle count increases to 25 and 30, it maintains relatively high levels of approximately 0.92 and 0.90, respectively. This indicates that the proposed method can dynamically schedule both communication and computational resources through intelligent decision-making, thereby retaining strong task assurance capability under high-load scenarios. In contrast, the completion rate of TD3 gradually declines as the number of vehicles grows, suggesting that its strategy value estimation and resource allocation remain insufficient when the task scale expands and system coupling intensifies, resulting in a noticeable performance drop. DDPG exhibits more significant performance degradation, which is generally attributed to its higher sensitivity to estimation bias in the single-critic value estimation: in complex and dynamic IoV environments, estimation errors can lead to unstable policy updates, thereby resulting in poorer resource allocation decisions and lower completion rates. HGRA performs the worst, with an almost linear decline in performance. This is because heuristic rules lack effective perception and adaptive adjustment mechanisms for environmental states and task requirements, making it difficult to perform targeted scheduling when resource competition intensifies, which causes resource utilization efficiency to continuously deteriorate.

Figure 5 illustrates the variation in the average task execution delay of the four schemes under different numbers of vehicles, aiming to evaluate the impact of increasing traffic scale and system load on the algorithms’ end-to-end latency control capability. An increase in the number of vehicles typically leads to intensified access contention and queuing effects, consequently causing a rise in delay. As the number of vehicles increases from 10 to 30, the average task execution delay for all four schemes shows an upward trend. This indicates that higher vehicle density exacerbates competition for uplink transmission, backhaul links, and UAV/RSU computing resources, simultaneously increasing both queuing wait times and transmission delays.

Specifically, the proposed GAT-CTD3 consistently maintains the lowest average delay, at approximately 0.46 s when K = 10 and still around 0.63 s when K = 30. It should be noted that this delay metric covers the complete four-stage end-to-end processing pipeline of each task, including vehicle-to-UAV uplink transmission, UAV local computing, UAV-to-RSU backhaul offloading, and RSU edge computing. In comparison, the delay for TD3 increases from about 0.51 s to 0.82 s, DDPG rises from about 0.58 s to 0.98 s, while the heuristic rule-based HGRA exhibits the most significant delay growth, increasing from about 0.74 s to 1.25 s. This is because HGRA, as a heuristic rule-based method, lacks the capability to adaptively schedule resources based on dynamic channel and queue states. When the number of vehicles increases, it is prone to uneven resource allocation and congestion accumulation, leading to the fastest increase in delay. DDPG, due to its value estimation bias and unstable policy updates, struggles to form stable and efficient resource allocation strategies in complex dynamic environments, resulting in its delay being significantly higher than that of TD3. Although TD3 enhances training stability through mechanisms such as twin critics, its overall coordination capability in high-density task scenarios remains inferior to GAT-CTD3. Notably, GAT-CTD3 introduces graph-attention-based state encoding and a constraint-driven joint decision-making mechanism, enabling the algorithm to more accurately capture the spatial correlations and resource competition among multiple vehicle tasks. Consequently, it performs finer-grained scheduling of bandwidth, computational frequency, and task splitting, thereby effectively reducing the average task execution delay.

Figure 6 illustrates the variation in the UAV’s energy consumption per completed task across different schemes under varying numbers of vehicles, which is used to evaluate the energy efficiency and energy-saving capability of resource scheduling strategies as vehicle density increases and the system load becomes heavier. As the number of vehicles increases from 10 to 30, the energy consumption per task for all four schemes shows an overall upward trend. This is attributed to the increased number of concurrent tasks that the system must handle due to the higher vehicle count, which simultaneously elevates the UAV’s workload in uplink reception, backhaul forwarding, and local computing. Furthermore, meeting task latency constraints often necessitates more aggressive resource scheduling, further driving up communication and computational energy consumption.

Despite this overall increasing trend, the proposed GAT-CTD3 maintains the lowest energy consumption per task across all vehicle-count settings. Specifically, it consumes approximately 115 J/task when K = 10 and only about 130 J/task when K = 30, demonstrating a relatively small increase. The unit of this energy metric is Joule (J), which counts the full-scope total energy consumption of the UAV for each completed task, including mobility energy for position adjustment, communication energy for data receiving and offloading, and on-board computing energy for local task processing. In comparison, TD3 exhibits energy consumption ranging from approximately 130 J/task to 191 J/task, while DDPG consumes about 145 J/task to 206 J/task. HGRA shows the highest and fastest-growing energy consumption, increasing from roughly 161 J/task to 252 J/task. This is because HGRA lacks a joint perception and coordination mechanism for dynamic channels, task urgency, and queue states, often resulting in coarse or even averaged resource allocation. Consequently, some tasks are forced to consume more energy to meet deadlines, leading to consistently high energy consumption per task. DDPG suffers from value estimation bias and unstable policy updates, which tend to generate suboptimal or highly fluctuating scheduling behaviors in complex environments, resulting in significantly higher energy consumption than TD3. Although TD3 offers better training stability than DDPG, its lack of powerful state representation and joint optimization capabilities makes it difficult to achieve energy-optimal resource allocation when vehicle numbers increase and task interdependencies strengthen. In contrast, GAT-CTD3 employs graph attention encoding to capture the spatial correlations and competition among multiple vehicular tasks, combined with a joint decision-making mechanism that co-optimizes bandwidth, computation, and task splitting. This enables the UAV to serve tasks in a more reasonable manner, thereby significantly reducing the energy required per completed task while still ensuring a high task completion rate.

Figure 7 illustrates the impact of GAT encoding on the task completion rate under varying numbers of vehicles. As shown in the figure, the completion rates of both schemes exhibit a declining trend as the number of vehicles increases from 10 to 30. This indicates that the intensified resource competition and enhanced system coupling resulting from a larger vehicle scale reduce the probability of completing tasks within the latency constraints.

Specifically, when K = 10, the completion rate of the scheme with GAT encoding is approximately 0.98, while that without GAT is about 0.95. When the number of vehicles increases to K = 20, the corresponding completion rates are approximately 0.94 and 0.86, respectively. Under the higher-load scenario of K = 30, the scheme with GAT encoding remains around 0.90, whereas the scheme without GAT drops to about 0.75, widening the performance gap to approximately 0.15. These results demonstrate that GAT encoding can significantly improve decision quality in scenarios with dense vehicles and strong task coupling. This is because, in the multi-task offloading and resource allocation problem within UAV-assisted IoV, significant spatial correlations and resource competition exist among vehicular tasks. GAT encoding can adaptively aggregate features of neighboring tasks through an attention mechanism, thereby providing more discriminative state representations for the subsequent policy network. In contrast, concatenation-based MLP encoding often suffers from the curse of dimensionality and loss of structural information as the number of vehicles increases, making it difficult to effectively capture inter-task relationships. Consequently, resource scheduling is more prone to deviating from the optimal solution under high-load conditions, resulting in a rapid decline in task completion rates.

To quantitatively verify the effectiveness of the Lagrangian-based constrained optimization framework proposed in this paper, we compare the performance of our GAT-CTD3 with the ablation baseline GAT-TD3-RP under different vehicle densities, with the core results under high-load scenario (K = 30) shown in

Table 5. Ablation results of constraint handling mechanism (K = 30).

Scheme	Task Completion Rate	Average Delay (s)	Energy Consumption per Task (J/Task)	Long-Term Constraint Satisfaction Rate (%)
GAT-TD3-RP	0.84 ± 0.018	0.72 ± 0.031	162 ± 4.8	81.2 ± 3.5
GAT-CTD3 (Ours)	0.90 ± 0.012	0.63 ± 0.024	130 ± 3.6	99.6 ± 0.3

.

The experimental results show that, under the same UAV energy budget constraint and with 30 vehicles, the baseline model GAT-TD3-RP, which adopts a heuristic reward–punishment mechanism, achieves lower task completion rates and energy efficiency compared to our proposed GATCTD3. More critically, the heuristic reward–punishment approach cannot strictly satisfy the long-term energy budget constraint, leading to higher constraint violation rates under high-load scenarios.

This significant performance gap stems from the inherent limitations of the heuristic reward–punishment approach. In highly dynamic vehicular environments, fixed penalty coefficients fail to dynamically balance task completion performance and energy constraints. When the system load is low, excessively large penalty coefficients lead to conservative UAV scheduling, reducing task completion rates; when the system load is high, overly small penalty coefficients cause the UAV to exceed its energy budget, failing to ensure long-term constraint satisfaction. In contrast, the Lagrangian-based constrained TD3 framework adopted by our GAT-CTD3 dynamically updates the multiplier $\lambda$ based on the UAV’s real-time energy consumption, achieving a high long-term energy budget constraint satisfaction rate while maximizing task completion performance.

5.4. Hyper-Parameter Ablation and Robustness Analysis

To verify the robustness of the proposed GAT-CTD3 algorithm and the impact of key hyper-parameters on system performance, we conduct systematic ablation experiments on three core hyper-parameters: the UAV long-term energy budget $\overline{C}$, the KNN neighbor size $K_n$ in the GAT encoder, and the discount factor $\gamma$. All experiments are conducted under the high-load scenario of 30 vehicles, and the default values of other parameters are consistent with those in Section 5.1.

5.4.1. Ablation of UAV Energy Budget

As shown in Figure 8, the UAV energy budget $\overline{C}$ serves as the core constraint in the CMDP formulation, directly determining the upper limit of available energy for the UAV during long-term decision-making. We set five different energy budget levels to evaluate the performance variations of different schemes. It can be observed that the task completion rates of all schemes improve as the energy budget expands, because a larger energy budget enables more flexible mobility scheduling, higher transmission power, and more sufficient computing resource allocation, thereby allowing more tasks to be completed within their latency deadlines. However, our proposed GAT-CTD3 consistently achieves the best performance across all energy budget settings.

In addition, the energy consumption per completed task of GAT-CTD3 shows a slow and gentle upward trend as the energy budget increases, which indicates that our algorithm can make more efficient use of the increased energy budget to optimize the scheduling strategy, rather than simply increasing the energy consumption. In contrast, the energy efficiency of other baselines deteriorates significantly under low energy budget constraints, which further verifies that our proposed Lagrangian-based constrained optimization framework can still maintain stable and efficient decision-making under strict energy constraints.

5.4.2. Ablation of GAT KNN Neighbor Size

As shown in Figure 9, the KNN neighbor size $K_n$ determines the spatial interaction range captured by the GAT encoder, which directly affects the state representation capability of the algorithm. We tested the performance of GAT-CTD3 under different $K_n$ values (3, 5, 7, 9, 11). The results show that when $K_n=5$, the algorithm achieves the optimal balance between performance and computational complexity. When $K_n<5$, the GAT encoder cannot fully capture the spatial correlations and resource competition among vehicular tasks, resulting in a slight decrease in task completion rate; when $K_n>5$, the algorithm introduces redundant neighborhood information, which increases computational complexity without significant performance improvement, and even leads to a slight performance degradation due to over-smoothing of node embeddings. This ablation result justifies our choice of $K_n=5$ in the experiment and verifies the robustness of the GAT encoder to the neighbor size hyperparameter.

5.4.3. Ablation of Discount Factor

As shown in Figure 10, the discount factor $\gamma$ determines the weight of long-term rewards in the DRL optimization objective, which is a key hyperparameter affecting the convergence and long-term decision-making capability of the algorithm. We test the performance of GAT-CTD3 under different $\gamma$ values (0.90, 0.95, 0.98, 0.99). The experimental results show that when $\gamma =0.98$, the algorithm achieves the best comprehensive performance. A smaller $\gamma$ (e.g., 0.90) makes the algorithm focus on short-term rewards, leading to excessive energy consumption in the early stage and failure to meet the long-term energy budget constraint; a larger $\gamma$ (e.g., 0.99) slows down the convergence speed of the algorithm, and makes it difficult to balance the immediate task completion reward and long-term energy constraint. This ablation result verifies the rationality of our default hyperparameter setting, and demonstrates that the proposed algorithm has good robustness to the discount factor within a reasonable range.

6. Conclusions

This paper investigates joint task offloading and resource allocation in UAV-assisted IoV systems under highly dynamic mobility, time-varying air–ground links, multi-stage queueing, and strict UAV energy constraints. A comprehensive system model is developed in which the UAV adaptively selects its hovering location from discrete candidate positions in each time slot, while vehicular tasks can be flexibly partitioned between the UAV and the RSU. This split-computing design alleviates backhaul congestion and improves the utilization of edge computing resources. The coupled decisions of UAV positioning, task partitioning, and multi-dimensional communication and computing resource allocation are formulated as a CMDP with the objective of maximizing the number of tasks completed within latency deadlines. To solve this problem, a graph-attention constrained deep reinforcement learning algorithm, termed GAT-CTD3, is proposed. The graph attention mechanism captures spatial correlations and resource competition among active vehicular tasks, enabling scalable state representation, while the Lagrangian-based TD3 framework enforces long-term UAV energy constraints and stabilizes training. The simulation results demonstrate that the proposed method consistently outperforms baseline schemes in terms of task completion ratio, average execution delay, and energy consumption per completed task, particularly under dense traffic and high-load conditions.

It is worth noting that the current evaluation is conducted under several simplifying assumptions, including a single-UAV deployment, LoS-dominated air–ground channels, and discrete hovering positions, which are adopted to focus on the reliability-aware offloading mechanism and maintain computational tractability. Future work will extend the framework to continuous UAV trajectory optimization, decentralized multi-UAV coordination, and more realistic channel and traffic models. In addition, comparisons with recent graph-based reinforcement learning and advanced constrained reinforcement learning approaches will be explored to further assess the scalability and effectiveness of the proposed method.