Paper deep dive
Graph Neural Assisted Actor-Critic for Latency-Efficient Edge Vision System
Alam Noor, Luis Almeida, Kai Li, Jiyan Wu, Miguel Gutiérrez Gaitán, Eduardo Tovar
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 8/23/2026, 1:27:35 AM
Summary
This paper proposes a Graph Convolutional Network-assisted Advantage Actor-Critic (GCN-Assisted A2C) deep reinforcement learning model to optimize video transmission latency in UAV edge vision systems. By using GCN to identify pixel-correlated regions of interest (RoI) and A2C to select optimal sub-groups for transmission, the system reduces latency and false detection rates compared to state-of-the-art models like EdgeDuet and FlexPatch.
Entities (8)
Relation Signals (6)
GCN-Assisted A2C → appliedto → UAV
confidence 95% · UAV on-board vision systems... propose a... system model
GCN-Assisted A2C → reduces → Latency
confidence 95% · Experimental results show that GCN-assisted A2C reduces video frame transmission latency
GCN → supervises → A2C
confidence 92% · the GCN supervises the A2C model, which selects a subgroup to enhance transmission latency
GCN-Assisted A2C → outperforms → EdgeDuet
confidence 90% · GCN-assisted A2C reduces video frame transmission latency... over other DRL and state-of-the-art models
GCN-Assisted A2C → outperforms → FlexPatch
confidence 90% · GCN-assisted A2C reduces video frame transmission latency... over other DRL and state-of-the-art models
GCN-Assisted A2C → uses → YOLO-Nano
confidence 90% · We use the YOLO-Nano model to define the bounding box for detected UAVs
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:UAV on-board vision systems are widely used for different activities, including monitoring in no-fly zones. In this case, the vision-equipped UAV streams a video to a ground server where an operator assists its activities. The latency of video transmission has a profound impact on the effectiveness of the operator assistance. However, most techniques available for video transmission still incur significant latency costs. In this paper, we propose a graph convolutional neural network-assisted (GCN-Assisted A2C) deep reinforcement learning (DRL) system model to find the optimal pixel-correlated area of a suspicious object. We combine the Lagrangian dual form with gradient descent to prevent lack of convergence and over- and under-penalization constraint violation during latency optimization. The proposed system model sends a sub-group pixel-correlated area of the frame from the UAV to the server rather than the transmission of the whole video frame. The proposed framework utilizes the GCN model to explore hidden representations of feature-correlated groups of pixels. Moreover, the GCN supervises the A2C model, which selects a subgroup to enhance transmission latency, thus supervising the training of UAV actions in A2C. Experimental results show that GCN-assisted A2C reduces video frame transmission latency together with false detection rate in UAV vision systems over other DRL and state-of-the-art models.
Tags
Links
- Source: https://arxiv.org/abs/2608.16142v1
- Canonical: https://arxiv.org/abs/2608.16142v1
Trouble viewing inline? Open PDF directly →
Full Text
62,442 characters extracted from source content.
Expand or collapse full text
Graph Neural Assisted Actor-Critic for Latency-Efficient Edge Vision System Alam Noor1, Luis Almeida2, Kai Li3, Jiyan Wu4, Miguel Gutiérrez Gaitán5 and Eduardo Tovar1 Affiliation: 1CISTER Research Center, Porto, Portugal. Affiliation: 2Instituto de Telecomunicações, Faculdade de Engenharia, Universidade do Porto, Portugal. Affiliation: 3Department of Information Technology, Kennesaw State University, USA. Affiliation: 4OmniVision Technologies Inc. Affiliation: 5Department of Electrical Engineering, Pontificia Universidad Católica de Chile, Santiago 7820436, Chile. Abstract UAV on-board vision systems are widely used for different activities, including monitoring in no-fly zones. In this case, the vision-equipped UAV streams a video to a ground server where an operator assists its activities. The latency of video transmission has a profound impact on the effectiveness of the operator assistance. However, most techniques available for video transmission still incur significant latency costs. In this paper, we propose a graph convolutional neural network-assisted (GCN-Assisted A2C) deep reinforcement learning (DRL) system model to find the optimal pixel-correlated area of a suspicious object. We combine the Lagrangian dual form with gradient descent to prevent lack of convergence and over- and under-penalization constraint violation during latency optimization. The proposed system model sends a sub-group pixel-correlated area of the frame from the UAV to the server rather than the transmission of the whole video frame. The proposed framework utilizes the GCN model to explore hidden representations of feature-correlated groups of pixels. Moreover, the GCN supervises the A2C model, which selects a subgroup to enhance transmission latency, thus supervising the training of UAV actions in A2C. Experimental results show that GCN-assisted A2C reduces video frame transmission latency together with false detection rate in UAV vision systems over other DRL and state-of-the-art models. Index Terms: Latency Optimization; GCN, Reinforcement Learning; UAVs; Mobile Edge Computing. I Introduction Unmanned Aerial Vehicles (UAVs) are used for a wide spectrum of mobile vision applications, such as augmented reality [7], trajectory planning [11], or visual surveillance systems (e.g., to detect intruders in no-fly zones) [13, 17, 15]. Many of these applications rely on real-time computer vision and require UAVs to detect both large and small objects in dynamic environments with high accuracy. For this purpose, an edge computing approach is common, having the UAVs stream video to a server in a ground station for assistance, getting important data from the server after preprocessing to identify objects with high accuracy [3][23]. However, the transmission of video frames with high resolution imposes long delays that hinder real-time operation. Similarly, doing local video processing onboard the UAV is highly constrained due to limited computing resources, imposing long delays and/or low video resolution [2]. A promising solution to combine low latency and high accuracy detection following the edge computing paradigm is to offload to an edge server equipped with GPUs running deep learning models the processing of just specific areas of the video frames representing regions-of-interest (RoI) [18, 27, 24]. This reduces the amount of information to be transferred, leading to lower transmission time, thus reducing the latency of the Edge support. However, user-side parameters like image resolution and encoding rate and server-side parameters like neural network architecture have a significant impact on video analysis if we do not consider how the pixels of the RoI correlate with the pixels of the video frame background environment [27]. Wang et al. [18] studied a split-based object detection model (EdgeDuet) between UAVs and the Edge. The detection of small objects is offloaded to the server using an RoI of the frame and content-prioritized tiles. The RoI of the frame transmitted with pixel blocks potentially contains small objects of high resolution. The rest of the frame has large objects that can be detected with low resolution onboard the UAV. However, EdgeDuet is based on tile selection, with tiles having an area that is unrelated to the size of the small objects, thus potentially causing the transmission of more information than strictly needed, incurring unnecessarily longer transmission latency. Moreover, as shown in Fig.1, the use of tiles may also hinder the accuracy of server detection. Yang et al. [24] introduced the Flexpatch model that allows for the detection of small objects with a small delay while also addressing occlusion, changes in object appearance, and the presence of additional objects. However, the Flexpatch model is based on optical flow with static cameras, thus unsuited for moving cameras onboard UAVs. Figure 1: EdgeDuet non-optimal region selection for the transmission of small objects to an Edge server. In this work we aim at managing the sizes of the sub-area video frames to reduce the amount of information to be transferred and the associated transmission delay (Fig. 2). The key of the system model is a Graph Convolutional Network (GCN) that selects from a video frame the RoI of small objects and the group of neighboring pixel regions that are correlated with the centroid of the RoI. Then, it is important to select the group of pixels-correlated regions from the output of the GCN module that optimizes the latency subject to satisfying the accuracy of object identification. Figure 2: Onboard UAV processing video to detect suspicious UAVs. For this purpose, we propose a novel GCN-assisted Advantage Actor Critic Deep Reinforcement Learning model (GCN-assisted-A2C) that is fast, accurate, and flexible to accommodate the movement of the onboard UAV camera. Our objective is to efficiently optimize and control the transmission delay in order to accurately identify intruding UAVs in a no-fly zone. We use the YOLO-Nano model to define the bounding box for detected UAVs. The GCN uses the bounding box center to find the group of pixels-correlated regions with a strong relationship with the RoI centroid. The A2C module of the proposed GCN-assisted-A2C model selects the actual group of pixels-correlated regions to be sent to the server. Finally, the server finds the object and sends back the information of accuracy and latency for the GCN-assisted-A2C model to optimize the latency efficiently, reducing the transmission delay by selecting a minimum group of pixels-correlated regions that allows meeting a given target accuracy. In summary, the main contribution of this paper is a novel GCN-assisted A2C model that encompasses the following two parts: • A GCN that uses the bounding boxes of RoI produced by an onboard YOLO-Nano algorithm and creates clusters of feature-correlated groups of pixels and regions of hidden pixel relationships. The GCN model is trained with a SLIC segmentation of frames as ground truth for the groups of pixel regions. • An A2C that uses the GCN as a state based on a group of pixels correlation values of future predictions to process the output, take action, and transmit it to the server. The A2C reward is based on the Lagrangian dual form for checking the sensitivity of the objective function. The aim is to reduce the risk of temporal difference learning error estimation for both the critic and the actor loss to update the policy. We use dual gradient descent to update the λ parameter and avoid lack of latency convergence and over- and under-penalization constraint violation during latency optimization. We trained the proposed GCN-assisted-A2C model on a YouTube dataset to assess its real-world performance and compared it with three benchmark models: FlexPatch, EdgeDuet, and DRL. The proposed model achieved an inference latency of 45 ms, approximately half of what was achieved with the competing approaches. It also achieved an average precision of 70.72%, with a mean Intersection over Union (IoU) of 60.30%, indicating more accurate RoI selection and higher overall detection performance when compared against the benchmark methods. Beyond the proposed GCN-assisted A2C, this work uses the following technologies in the end-to-end video pipeline: • UAV side: An onboard camera combined with YOLO-Nano inference for real-time object detection. When the detection confidence falls below a predefined threshold, region-of-interest (RoI) image crops are extracted and transmitted to the edge server using an intra-coded image encoding scheme (H.264 Intra-only), enabling efficient and robust transmission of independent RoI frames. • Edge server side: ESRGAN to regenerate missing contextual information, FFDNet for image denoising, Zero-DCE for low-light enhancement, followed by a large-scale YOLO model for accurate object detection and refinement. The rest of the paper is organized as follows. Section I discusses related work, Section I presents the mathematical system modeling, Section IV introduces the GCN-assisted A2C system model, and Section V validates the proposed model with an experimental study and discusses the results. Finally, Section VI concludes the paper. I Related Work Monitoring no-fly zones for suspicious flying objects, particularly UAVs, can be achieved by resorting to a legal UAV that captures and streams live video from the air. However, this approach requires a significant volume of live video transmission from the UAV to an Edge server, consuming computing resources and incurring high transmission latency [5][8]. To address these challenges, the previous system models might be categorized in different classes based on their primary approach to minimizing the transmission latency and improving the performance of real-time detection of UAVs. Several researchers introduced low-latency video streaming system models to reduce video transmission latency and improve real-time detection. Dong et al. [2] introduced an ultra-low latency frame delivery model using the UDP-based QUIC protocol and the widely compatible TS format, achieving latency below 200ms. Wang et al. [19] studied feature-based video transmission, using Lagrangian dual decomposition to optimize the transmission latency and semantic image segmentation for video feature selection. Qu et al. [14] studied UAV-swarm-aided modeling based on a disaster response platform for the video transmission from UAVs to the ground as air-to-ground coordination, while Khan et al. [9] presented a public safety communication network model that uses observation UAVs to receive video streams from ground users in an affected area and transmit them to a nearby supporting ground station. Some works focused on combining edge and cloud computation to optimize latency. Anurag et al. [4] studied edge and cloud collaborative work to use heavy deep learning models at the cloud and small models at the edge to fuse their predictions to optimize latency. Liu et al. [12] designed a multi-approach model that reduces latency by extending splitting-merging streaming and multi-link retransmission to reduce the packet loss. Yaqoob et al. [25] presented a DRL-based soft actor-critic model to improve the quality of experience of video transmission latency from a UAV to a ground server. Meanwhile, Song et al. [16] introduced an AI-driven, multipath transmission of a UAV live streaming system to optimize bandwidth aggregation and transmission reliability, while Wu et al. introduced a multiobjective control strategy learning for a UAV using a soft actor-critic DRL algorithm to manage the unstable transmission quality problem of videos in a dynamic topology network [20]. Other approaches focus on detecting objects efficiently by RoI and object-centric models to transmit video to relevant areas. Zhang et al. [27] worked on an instance segmentation technique executed on the Edge (EdgeIS) to segment an RoI and transfer it to a mobile device with low latency. The EdgeIS model detects objects and tracks their motions with mask transferring. Moreover, EdgeIs models utilize the contour-instructed edge inference acceleration scheme to reduce latency. Wang et al. [18] studied EdgeDuet, a split-based object detection framework between UAVs and the Edge, where regions of interest (RoIs) containing small objects are transmitted to an Edge server using content-prioritized tiles, while the remaining regions are processed onboard at lower resolution. Although effective, EdgeDuet relies on tile-based RoIs whose areas are not aligned with the actual size of small objects, potentially leading to unnecessary data transmission, increased latency, and reduced detection accuracy. Yang et al. [24] introduced Flexpatch, an RoI-based approach that enables low-latency detection of small objects by tracking and transmitting adaptive patches corresponding to regions of interest, while being robust to occlusion and appearance changes; however, Flexpatch relies on optical flow with static cameras, making it unsuitable for moving cameras onboard UAVs. Among the works referred to above, only a few aim at reducing the video transmission latency for the specific purpose of flying objects real-time detection [2, 18, 27, 24]. Some of the works [18, 27, 24], though, still stress the use of the network channel bandwidth transmitting areas of the video frames of no interest for flying object detection. This fact limits their capacity to reduce video latency and packet losses since there will be more packets transmitted than strictly needed. In our work we pursue an approach based on identifying regions of interest in the video frames and transmit just these RoIs, leaving to the Edge server the task of accurately identifying small objects in those RoIs, even with poor video quality or environmental effects. The works that best relate to ours are EdgeDuet [18] and Flexpatch [24], which we will use for comparison. Our work is, to the best of our knowledge, the only one that trades off Average Precision (AP) with latency, using an A2C DRL approach to get the lowest latency (by means of selecting the smallest RoIs) that allows meeting a given AP target. I Mathematical System Modeling We consider a sequence of encoded video frames Ft\F_t\ of spatial size W×HW× H pixels captured by a UAV. A light onboard detector (e.g., YOLO-Nano) produces at times t a bounding box bt=(xc,yc,ζW,ζH)b_t=(x_c,y_c, _W, _H) with center (xc,yc)(x_c,y_c) and size (ζW,ζH)( _W, _H). ζW _W and ζH _H are the width and height of the detected bounding box. The transmitter chooses an action EtE_t that parameterizes a region of interest ft(Et)f_t(E_t) centered at (xc,yc)(x_c,y_c) with scale factors αt _t and βt _t (Eq. 1). ft(Et)=[xc−αtζW2,xc+αtζW2]×[yc−βtζH2,yc+βtζH2]f_t(E_t)=\\ [x_c- _t _W2,x_c+ _t _W2 ]× [y_c- _t _H2,y_c+ _t _H2 ] (1) Let |ft|=αtβtζWζH|f_t|= _t _t _W _H be the RoI area in pixels. For symmetric expansion, we consider αt=βt=1+2Et _t= _t=1+2E_t, where EtE_t is the scaling factor that determines the cropping region of the bounding box size, with Emin≤Et≤EmaxE_min≤ E_t≤ E_max. In practice, each frame FtF_t will contain several sub-areas of interest (i.e., the RoIs). Let ℱt=ft,1,…,ft,nF_t=\f_t,1,…,f_t,n\ be the set of such sub-areas in which ft,nf_t,n denotes the n-th sub-area of frame FtF_t and N the set size. Once the N RoIs are defined, they are transmitted through the communication channel. Of particular importance to the transmission time is the RoIs area, which is given by |ft,n|=(1+2Et,n)2ζWζH|f_t,n|=(1+2E_t,n)^2\, _W _H, because it determines the amount of information to be transmitted. Without loss of generality, we consider that each RoI is transmitted inside one communication packet of size St,nS_t,n as given by Eq. 2, where ρ (bits/pixel) captures the codec rate at the chosen quality and Ψframe _frame aggregates headers and per-packet overhead.11 1 If tiling is used, Ψframe _frame can include tile headers; ρ can vary mildly with texture/motion. St,n=ρ|ft,n|⏟content payload+Ψframe⏟headers/overheadS_t,n\;=\; ρ\,|f_t,n|_content payload\;+\; _frame_headers/overhead (2) In real-time the communication between the UAV and the Edge server is affected by packet loss, which in turn triggers retransmissions, impacting the RoIs transmission times. This loss-induced extension of the transmission times must be considered in the target delay constraint [22]. Therefore, we define the expected transmission time per packet Tt,nT_t,n as given by Eq. 3 [26][21], where R (bits/s) is the wireless link transmission rate, minRTT RTT is the round-trip time, and qt,nq_t,n is the per-packet success probability (after PHY/MAC). We also consider a stop-and-wait ARQ retransmissions protocol with a NACK packet of size B bits. Tt,n=(St,nR+minRTT2)⏟first attempt++(1−qt,n)qt,n⏟expected retries⋅(BR+minRTT+St,nR)⏟each retry,T_t,n= ( S_t,nR+ RTT2 )_first attempt+\\ + (1-q_t,n)q_t,n_expected retries· ( BR+ RTT+ S_t,nR )_each retry, (3) I-A Accuracy Constraints Strategy We now construct the constraints for our framework regarding detection accuracy and sub-area frame size, emphasizing the importance of carefully selecting appropriate frame cropping area scales for UAV detection accuracy and how it greatly influences performance. The necessity for careful sub-area frame scale selection arises from two primary factors: first, real-world UAVs come in a wide range of sizes, often unfamiliar to the visual system; and second, the distances between objects and the camera may vary, potentially lacking prior information. We aim to achieve sufficiently high accuracy (t,n)(A_t,n) on the server side when receiving sub-area frame ft,nf_t,n. We consider the server side accuracy t,nA_t,n to be a function of RoI size as shown in (4). Note that ⋅P\·\ is a probability of each transmitted sub-area, namely the likelihood that the server correctly detects an intruding UAV given the received RoI, i.e., correct detection∣ft,nP\correct detection f_t,n\. We use (4) to estimate on the inspecting UAV side the accuracy on the server side and decide on the need to scale the RoI before transmission so that a desired server side accuracy threshold thresholdA_threshold is met. This procedure is shown in (5) in which we scale up the sub-area frame choosing an optimal scaling factor Et,n(k+1)E_t,n^(k+1) iteratively until the threshold is overcome, starting from Et,n(0)=0E_t,n^(0)=0 for k=0k=0. t,n(k)=(|ft,n(k)|)=((1+2Et,n(k))2ζWζH).A_t,n^(k)\;=\;P\! (|f_t,n^(k)| )\;=\;P\! ((1+2E_t,n^(k))^2\, _W\, _H ). (4) t,n(k+1)=(|ft,n(k+1)|),if t,n(k)≤Athreshold,t,n(k),otherwise.A_t,n^(k+1)= casesP\! (|f_t,n^(k+1)| ),&if A_t,n^(k)≤ A_threshold,\\[6.0pt] A_t,n^(k),&otherwise. cases (5) The scaling factor is updated as Et,n(k+1)=VE⋅Et,n(k)E_t,n^(k+1)=V_E· E_t,n^(k) where VEV_E is computed proportionally to the correlation of the group of pixels of the sub-area with respect to its center. Moreover, ⋅P\·\ must be optimal to obtain maximum accuracy and low latency. A retrieval process based on Et,nE_t,n, treated as a ranking or sorting method for different sub-area frames, does not work because it is non-differentiable. In addition, linear optimization cannot be applied, since constant changes in the input distance |ft,n||f_t,n| cause the t,nA_t,n values to be discontinuous [6]. In order to obtain an optimal ⋅P\·\, groups of pixel correlations between regions must be considered, since correlations between center and neighboring pixels are essential. This approach also reduces latency by enabling a one-time prediction of a sub-area of the frame rather than relying on a sequence of actions. The GNN primarily focuses on prediction and determining the optimal decision for a single occurrence. Using the GNN algorithm to identify the area according to pixel correlations results in a more significant decrease in latency compared to linear optimization. This is because linear optimization is based only on Et,nE_t,n, which does not guarantee higher precision in the first transmission of sub-area frames and is vulnerable to selecting inappropriate regions of the frame with low pixel correlations. I-B Problem Formulation The above analysis shows that the number of transmissions of sub-area frames ft,nf_t,n in Tt,nT_t,n is critical to maintaining the delay below the desired threshold of a single full-frame transmission delay. According to the [1], the total transmission time of frames can be expressed as the sum of all single sub-area frame delays, which is given in (6). ∑n=1NTt,n=∑n=1N(St,nR+minRTT2++(1−qt,n)qt,n(BR+minRTT+St,nR)) _n=1^NT_t,n= _n=1^N ( S_t,nR+ RTT2+\\ + (1-q_t,n)q_t,n ( BR+ RTT+ S_t,nR ) ) (6) The optimization problem to minimize the sum of the total delay can be stated as follows. Given the estimated packet sizes St,nS_t,n for each transmission at send rate R and the one-way propagation/processing delay minRTT2 RTT2, the objective is to achieve minimum transmission latency by adapting each cropped sub-area ft,nf_t,n via a variable scaling factor Et,nE_t,n per packet. The design also accounts for the number of sub-area transmissions and leverages an optimal (.)P(.) (pixel-correlation-based precision probability), so that the server-side accuracy t,nA_t,n for each received sub-area frame is high and stable. Formally, OP:argminft,nn=1N∑n=1NTt,nOP: _\f_t,n\_n=1^N\ _n=1^NT_t,n (7) subject to:t,n≥Athreshold,n=1,…,N.subject to: _t,n≥ A_threshold, n=1,…,N. where Tt,n=(St,nR+minRTT2)++1−qt,nqt,n(BR+minRTT+St,nR),St,n=ρ|ft,n|+Ψframe,t,n=(|ft,n|),Et,nk+1=VE⋅Et,nk,Et,n0=0 splitT_t,n&= ( S_t,nR+ RTT2 )+\\ &+ 1-q_t,nq_t,n ( BR+ RTT+ S_t,nR ),\\[0.0pt] S_t,n&=ρ\,|f_t,n|+ _frame,\\[0.0pt] A_t,n&=P\! (|f_t,n| ),\\[0.0pt] E^k+1_t,n&=V_E· E^k_t,n, E^0_t,n=0 split I-C Complexity Problem (OP) induces a constrained Markov decision process (MDP) with continuous action variable Et,nE_t,n and a non-convex, data-driven accuracy function t,n(⋅)A_t,n(·). Exact dynamic programming is intractable. Therefore, we adopt a model-free primal–dual actor–critic method that learns policies minimizing the expected delay while satisfying accuracy constraints. In the simplified case where Et,nE_t,n takes values on a discrete grid of K levels, and both t,nA_t,n and Tt,nT_t,n are monotone in Et,nE_t,n, each sub-area frame can be optimized independently in O(NK)O(NK) by scanning the grid. However, when temporal correlations, joint constraints, and stochastic packet success are considered, the problem becomes a high-dimensional constrained MDP (CMDP), making reinforcement learning methods more appropriate. IV Proposed GCN-Assisted DRL System Model This section presents the model of the GCN-assisted A2C system. The proposed model employs GCN to extract the areas of features that have a strong relationship with the object center, as well as the strong correlation between groups of pixels to facilitate future prediction. While A2C exploits the learning outcomes of GCN to train the action of latency optimization and accuracy constraint satisfaction. In the previous section, we formulated the transmission optimization problem (OP) by defining the action as the RoI scaling factor Et,nE_t,n, which directly adjusts the size of the cropped sub-area frame ft,nf_t,n. While this abstraction provides a tractable CMDP formulation, it does not exploit correlations between pixels inside the bounding box, nor does it account for complex feature distributions that arise under different UAV sizes, lighting conditions, and motion. To address these limitations, we extend the baseline model with a GCN-assisted A2C framework. In this setting, the GCN predicts correlated pixel groups iS_i that summarize feature relationships in the frame, and these groups are mapped into bounding boxes t,nB_t,n centered around correlation-weighted centroids. Each t,nB_t,n corresponds to an RoI that can be expressed as ft,nf_t,n for some effective scaling factor Et,nE_t,n. In other words, the GCN refines the baseline Et,nE_t,n-based action by constraining the A2C policy to choose feature-correlated regions that are both latency-efficient and accuracy-preserving. The following presents the proposed GCN–A2C solution model in detail. IV-A CMDP Formulation and Information Flow At each time step t, the CMDP state is defined as st=(ϕtdet,t,qt,minRTTt,λt)s_t= ( _t^det,\,g_t,\,q_t,\,minRTT_t,\, _t ), where ϕtdet _t^det are detector features (bounding boxes, scores), tg_t is a GCN embedding summarizing pixel-group correlations around (xc,yc)(x_c,y_c), and λt _t is the CMDP multiplier for latency–accuracy constraints.22 2 Not all state variables appear directly in the OP formulation, which is expressed only in terms of the optimization variables ft,nf_t,n, Et,nE_t,n, Tt,nT_t,n, and t,nA_t,n. Instead, the CMDP state aggregates the contextual information needed by the RL policy to generate decisions ft,nf_t,n that solve OP in practice. In the proposed system model, the feature vector ()(V) for GCN obtained from pixel-group sets =ii=1ZS=\S_i\_i=1^Z to form the GCN embedding tg_t. That is, t=g_t=V provides a compact encoding of correlations between disjoint pixel groups, which the A2C agent uses to guide decision-making. The CMDP action corresponds to selecting a bounding box t,nB_t,n from the GCN-predicted correlated pixel group i∗S^*_i. Each bounding box t,nB_t,n defines a sub-area RoI in the original OP formulation: t,n≡ft,nB_t,n≡ f_t,n. Thus, the GCN transforms pixel correlations into bounding-box actions that the A2C policy transmits to the server, balancing latency Tt,nT_t,n and accuracy t,nA_t,n. After transmission, the server returns the observed accuracy (AP or IoU proxy) and measured delay, which update the estimated accuracy sA_s and success probability qtq_t online. IV-B GCN-A2C for Decision Making We use an A2C strategy to optimize latency for solving the OP problem formulated from (2) to (6) [10]. Figure 3 illustrates a framework with three primary modules. The first is the actor module, which takes an action t,n,i\B_t,n,S_i\. Here, the GCN predicts correlated pixel groups iS_i, and the corresponding bounding box t,nB_t,n defines the cropped sub-area. Formally, each t,nB_t,n corresponds to an RoI ft,nf_t,n with scaling factor Et,nE_t,n, i.e., t,n≡ft,nB_t,n≡ f_t,n. Without GCN, the A2C actor would need to search exhaustively over pixel groups, leading to high computation. The pixel-group shape adapts to the variance or distribution around the centroid and has width ζW _W and height ζH _H. The critic module evaluates Tt,n,t,n\T_t,n,A_t,n\, i.e., the transmission delay per sub-area packet and the accuracy (mAP proxy) achieved at the server. The policy is improved by combining A2C training with GCN predictions: the GCN records correlations in pixel groups and provides future predictions, which periodically update the actor to select feature-correlated regions that minimize latency while ensuring t,nA_t,n constraints are met. This guarantees that the policy π(at|st)π(a_t|s_t) adapts to varying UAV sizes and pixel correlations. The size of each pixel group is determined by Θ=KMi = KM_i, where K is the total number of correlated pixels near the object center, and Mi=|i|M_i=|S_i| is the cardinality of the subset used by the GCN to guide actor decisions. Exhaustively evaluating groups of size MiM_i requires (KMi)=K!Mi!(K−Mi)!=O(KMi) KM_i= K!M_i!(K-M_i)!=O(K^M_i), making brute-force search infeasible. Instead, the GCN learns to predict future feature-correlated actions for A2C, reducing complexity while satisfying t,nA_t,n. The proposed system not only selects pixel groups but also captures stronger correlations between the center and neighboring hidden pixels. In the next section, we detail the structure of the GCN model. IV-C Hidden Pixels Relation Exploration This section presents a detailed graphic representation along with A2C of the proposed graph neural network structure for higher accuracy and low latency, shown in Fig. 3. To find the high correlations between the pixels of an image for optimal sub-area frame selection, we need to divide the frame into different partitions. The frame partitioning process is a critical and fundamental stage within any low-level vision system to find the region of interest where pixels have higher correlations with each other. Segmentation refers to the procedure of dividing a frame into distinct areas that do not overlap, with the objective of ensuring that each zone shows correlations and that the separation between areas is abrupt. Different methods for pixel correlations have been published in the past. However, it remains a challenge to identify a specific approach that shows consistency throughout numerous lighting conditions or low-visibility conditions. In addition, CNN performs convolution operations in smaller, more uniform areas and obtains features at the pixel level. However, GCN performs convolution operations in large areas with unevenly correlated pixels and gets features at the aggregated pixel level. The GCN method uses the average of all pixels in a set to give strong edge weights to areas with similar correlations and weak or no edge weights to areas with no correlations [11][10]. Figure 3: The figure illustrates the proposed framework, indicated by several color-coded parts. The left-side black box encloses the proposed model region, which symbolizes the core framework of the GCN-assisted A2C. The blue box shows the actor who selected the action. While the critic’s role in action-value evaluations. The green box is the GCN future state prediction, which regulates actor behavior to optimize latency and minimize errors. IV-C1 State Let =ii=1ZS=\S_i\_i=1^Z represent the set of aggregate pixel groups forming the state, where i=ijj=1Mi,Mi=|i|S_i=\Y_i^j\_j=1^M_i, M_i=|S_i|. Here, iS_i denotes the i-th group of correlated pixels and MiM_i is its cardinality. The pixel groups are disjoint, i.e., i∩j=∅S_i _j= for all i≠ji≠ j. Moreover, the total number of pixels is preserved: ζH×ζW=∑i=1ZMi _H× _W= _i=1^ZM_i. Each group is summarized by its mean feature vector, yielding the state representation, which is given in (8): =[1,2,…,Z]T=[1M1∑j=1M11j,…,1MZ∑j=1MZZj]T,V= [V_1,V_2,…,V_Z ]^T\\ = [ 1M_1 _j=1^M_1Y_1^j,…, 1M_Z _j=1^M_ZY_Z^j ]^T, (8) where ijY_i^j is the j-th pixel feature in group iS_i. Thus, V is a column vector of dimension Z, with each entry being the average feature of a pixel group. This representation captures the correlation structure of the aggregated pixel regions, which serve as the input nodes for the GCN. After processing the initial state, the GCN predicts future correlation patterns, which guide action selection by cropping the corresponding bounding box region. A focal classification loss cls L_cls is used to train the GCN for UAV pixel correlation prediction, which is given in (9): cls=λ1tcrp+λ2tcrn, L_cls= _1 L_tcrp+ _2 L_tcrn, (9) where tcrp L_tcrp measures correlation consistency among pixels inside the UAV bounding box, while tcrn L_tcrn penalizes spurious correlations in background regions outside the UAV. The loss tcrn L_tcrn suppresses background noise near the UAV centroid, allowing the GCN to emphasize UAV-related pixels. Here, λ1 _1 and λ2 _2 are tunable weighting coefficients used to balance the influence of tcrp L_tcrp and tcrn L_tcrn during training. IV-D A2C for TfT_f Optimization with t,nA_t,n Satisfaction IV-D1 Action In the previous section, we proposed a GCN method to capture correlations between pixels by partitioning images into groups of pixels. Using this foundation, we now leverage the correlation data to define the action in the A2C framework, which specifies the region to be transmitted. Let the action be a bounding box t,nB_t,n associated with a correlated pixel group i∗S^*_i predicted by the GCN. The goal is for the GCN to identify highly correlated pixel groups that can be mapped into compact rectangular or square regions. To achieve this, we define a correlation-weighted centroid (xc,yc)(x_c,y_c) based on the coordinates (xΦ,yΦ)(x_ ,y_ ) of pixels Φ∈i∗ ^*_i with weights ℭΦ C_ : xc=∑Φ∈i∗ℭΦ⋅xΦ∑Φ∈i∗ℭΦ,yc=∑Φ∈i∗ℭΦ⋅yΦ∑Φ∈i∗ℭΦ.x_c= _ ^*_i C_ · x_ _ ^*_i C_ , y_c= _ ^*_i C_ · y_ _ ^*_i C_ . (10) In (10) ℭs C_s denotes the correlation weight of pixel s, highlighting its contribution to the centroid. Using the centroid, the bounding box action t,nB_t,n is defined as: t,n:[xc−ζW∗2,yc−ζH∗2,xc+ζW∗2,yc+ζH∗2],B_t,n: [x_c- ζ^*_W2,\;y_c- ζ^*_H2,\;x_c+ ζ^*_W2,\;y_c+ ζ^*_H2 ], (11) In (11) ζW∗ζ^*_W and ζH∗ζ^*_H denote the width and height of the correlated region. These dimensions are adaptive, depending on the variability of the pixel-group distribution around the centroid. This flexibility improves the expressiveness of the bounding box and ensures that correlated regions are captured accurately. IV-D2 Reward The A2C training reward (rtA2C)(r_t^A2C) determined by the totals of sub-area frames transferred to the server within the action on the group of pixel regions as iψ∣i∗,t,n \S^ψ_i ^*_i,B_t,n \, as i∗S^*_i represents the correlated group of GCN-trained pixels. The action t,nB_t,n is taken by the UAV, and the GCN-predicted group of pixels transits from i∗S^*_i to iS_i. However, the reward can only be optimized when t,n≥AthresholdA_t,n\ ≥ A_threshold accuracy is considered for positive detection of the object on the server. It is essential to achieve optimal transmission latency and avoid penalization for constraint violation. It might be possible to put a condition for iψ∣i∗,t,n \S^ψ_i ^*_i,B_t,n \ preserving the feature-correlated region that can be achieved by Lagrangian dual form, as given in (12): ℒ(iψ,i∗,t,n,λ)=min∀i∗∈[1,Z]Tt,n+λ(Athreshold−t,n),L(S^ψ_i,S^*_i,B_t,n,λ)= _∀ i_S^*_i∈[1,Z]T_t,n+λ(A_threshold-A_t,n), (12) where, λ shows how sensitive the objective function is to changes in the value of t,n≥AthresholdA_t,n≥ A_threshold, the accuracy constraints. By using this approach, we are able to ensure that minimizing the objective function will only occur if the accuracy requirements are achieved. Otherwise, OP is penalized and stops optimizing more during t,n<AthresholdA_t,n<A_threshold. The fixed λ creates a lack of convergence and over- and under-penalization constraint violation during latency optimization. To address these issues, we use dual gradient descent to dynamically update the λ as mentioned in (13): λ←λ+η(Athreshold−t,n),λ←λ+η(A_threshold-A_t,n), (13) where η is the learning rate, which is initially set to 0.01 with a weight λ of 1. The η dynamically adjusts λ during constraint violation. So rtA2Ciψ∣i∗,t,nr_t^A2C \S^ψ_i ^*_i,B_t,n \ of the training of A2C is determined by offloaded group of pixel sets to the server and is given in (14) by rtA2Ciψ∣i∗,t,n=min∀i∗∈[1,Z]Tt,n.r_t^A2C \S^ψ_i ^*_i,B_t,n \= _∀ i_S^*_i∈[1,Z]T_t,n. (14) We incorporate the reward into the temporal difference learning (δt)( _t) error for the critic and actor loss as mentioned in (15): δt=rtA2Ciψ∣∗i,t,n+γV∗(Φt+1)−V∗(Φt), _t=r_t^A2C \S^ψ_i ^*_i,B_t,n \+γ V^*( _t+1)-V^*( _t), (15) where, V∗(Φt+1)V^*( _t+1) is the update estimated state of Φt _t that is the old estimated state of V∗(Φt)V^*( _t). The critic loss is evaluated by squaring the (δt)( _t) to ensure how well the V∗(Φ)V^*( ). While the actor loss is based on the advantage function to regulate the policy (πθ(at∣Φt))( _θ(a_t _t)) and map the states (Φt)( _t) to the actions (at)(a_t) as given as −logπθ(at∣Φt)⋅δt- _θ(a_t _t)· _t. −logπθ(at∣Φt)- _θ(a_t _t) takes action under the current policy πθ _θ for the state Φt _t and takes the product of the likelihood of action with δt _t to update the policy using (16): ℒloss=−logπθ(at∣Φt)⋅δt+c⋅(δt)2,L_loss=- _θ(a_t _t)· _t+W_c· ( _t )^2, (16) where cW_c shows the weighted factor for the critic loss. ℒlossL_loss defines that the actor is maximizing the advantage and critic is minimizing the δt _t error with current updates within the constraints defined by A2C reward rtA2Ciψ∣∗i,t,nr_t^A2C \S^ψ_i ^*_i,B_t,n \. IV-D3 Policy The policy πθ(at|Φt) _θ(a_t| _t) represents the A2C actor network that maps the CMDP state Φt _t to a probability distribution over actions ata_t. Each action corresponds to selecting a bounding box t,nB_t,n, which defines the ROI ft,nf_t,n to be transmitted. The policy parameters θ are updated using the actor loss in (16), which leverages the advantage signal δt _t to encourage actions that reduce latency Tt,nT_t,n while maintaining the required accuracy t,nA_t,n. V Experimental Work V-A Implementation of GCN-assisted A2C Model This section presents an overview of the results for onboard detection of intruding UAVs through the proposed GCN-assisted A2C model. The proposed GCN-assisted A2C model is built on a 64-bit Ubuntu 22.04 Linux workstation using Python 3.9 and PyTorch with a GPU of A300. In this study, we used YouTube videos for UAV-to-UAV monitoring. There are a total of 100 clips, all of which are 240 to 1080 resolution videos. These videos feature a variety of backgrounds, such as clouds, buildings, mountains, and sea, as well as fast movement, out-of-focus, and a range of sizes. The UAVs seen in each video come in a range of sizes, from large to small. We selected UAVs with a size range of 300m to 1200m to train and validate our proposed model. Furthermore, the UAVs cruise at speeds between 50 and 100 miles per hour, occasionally stopping altogether. We used all the validation videos from the YouTube stream for model training, testing and validation. Specifically, we train the model on 70 of the videos, using 15 of the remaining for testing and the remaining 15 for validation. The GCN-assisted A2C is trained for 1 iteration per epoch to find the correlation between the different regions in every frame, and the GCN-assisted A2C is trained for 100 epochs to extract the pixel feature-correlated regions to send it to the server. GCN-assisted A2C is analyzed every 5 epochs using a validation function during the training process. This function finds the training loss and the number of iterations at which convergence occurs. The GCN-assisted A2C model with the lowest cost, denoted as the sub-optimum, is then used to assess the test data. The GCN-assisted A2C used multiple layers that are organized into the GCN layers and multi-layer perceptron layers. The GCN layers module consists of three GCN multi-head layers, each containing two GCN layer edge softmax heads. The first GCN multi-head layer utilizes heads that apply a linear transformation f to convert input pixel features into output-correlated pixel features. Additionally, another linear transformation is used to convert input pixel features into output pixel feature-correlated features. The second layer undergoes a transformation where 128 input features are converted to 64 output pixel features, and 128 input pixel features are converted to 1 output pixel feature in a region that is correlated. The third layer of the GCN model performs a similar transformation by changing 256 input layer pixel features into 64 output pixel features and 256 input pixel features into 1 output pixel feature-correlated group of regions. The A2C module has two linear layers, in which the first layer maps 256 input pixel features to 128 output pixel features. For the final prediction, the second layer maps 128 input features to output feature-correlated group regions. It does this by using (10) and (11) for the centroid. The calculation of the policy gradients after multiplying by the benefits is known as policy loss. The Unmanned Aerial Vehicle (UAV) activities undergo training in the Advantage Actor-Critic (A2C) module for a total of 1500 steps, using a discount factor of 0.99. The loss function is calculated by taking the average of the squared differences between the estimated values and the actual returns. The loss calculation assigns a coefficient of 0.5 to the value function. V-B Ablation Study In Fig. 4, we can see how well the proposed GCN-assisted A2C system model and different DRL algorithms work in terms of transmission latency rate during training. We found that the A2C, DDPG, and DQN models mostly do the same thing, which is to minimize transmission latency. However, the synchronous nature of the A2C model leads to higher performance than the deterministic nature of the DDPG and DQN models. The frame area’s importance and the dynamical changes in the UAV’s size due to different movements make A2C more stable than the DDPG and DQN models. In addition, cropping the frame area makes a clear action space, which might be one reason why A2C is generally more useful than DDPG. The frame area cropping creates priority fluctuation that leads A2C to better decision-making. It’s hard for the DDPG and DQN models to make the best decision when there are a lot of different environmental factors and frame area cropping variability problems. However, to adopt and find feature correlations and dependencies between different regions of the frame still reduces the performance of A2C. We proposed a GCN-assisted A2C system model, which ensures and preserves critical contextual features of groups of neighboring pixels in regions where A2C lacks the ability to deal with such dependencies. A2C processes and transmits a single sub-area frame entity and makes it difficult to find the nuanced interplay between different sub-areas of frame parts or sizes of UAVs, variations, or environmental factors. Moreover, GCN assists the A2C to extract informative features of the UAV using aggregation and propagation of features across graph nodes to make better predictions. Similarly, the GCN-assested A2C system model reduces the high dimensionality focus to the specific interdependent area to efficiently handle energy constraints or bandwidth limitations. Without GCN, A2C struggles with scalability, and it leads to high computation, and might be complex architectures needed. In addition, GCN-assisted A2C is more robust to noises or missing pixel feature information to aggregate neighboring nodes feature information to improve predictions and reduce the transmission latency. If a portion of a frame is corrupt or unclear with environmental effects, then GCN leverages the hidden feature pixel information of the surrounding group of pixels, improves the transmission latency, and preserves the prediction performance constraints. Figure 4: The ablation study of different RL algorithms performance using loss using data that have across different sizes of UAVs and dynamic movements with different environmental effects. Moreover, in the ablation study, we used different DRL models (DQN, DDPG, and A2C) and studied required evaluation metric performance, like latency for each video frame transmission, overall AP, and mean IoU. The latency of the GCN-assisted A2C is much lower than that of the other benchmark DRL algorithms. The overall FPS transmission latency of the GCN-assisted A2C is 45 ms, which is much lower than the A2C without GCN, which has an FPS transmission latency of 170 ms. The GCN-assisted A2C achieved optimal latency due to the focus on the feature-correlated group of pixel regions to recommend to the A2C for optimal action. Moreover, Fig. 5 shows the AP and mean IoU of the GCN-assisted A2C and the three variants of the ablation study. The GCN-assisted A2C is the most effective across all the algorithms to transmit the optimal area of the frame that is utilized by the edge server. The GCN-assisted A2C achieved (AP @ 70.72%) and (mean IoU @ 60.30%) to improve (AP @ 62.80%) and (mean IoU @ 30.60%) over A2C. While A2C achieved (AP @ 43.44%) and (mean IoU @ 45.91%), which is higher in ratio than (AP @ 42.20%) and (mean IoU @ 60.50%) over the DDPG algorithm. Similarly, DDPG achieved (AP @ 30.55%) and (mean IoU @ 28.61%), and DQN with a very low score of (AP @ 17.30%) and (mean IoU @ 20.21%). Figure 5: With the proposed GNN-A2C (GCN-assisted A2C) and different DRL algorithms, we can check the average (30FPS) IoU and tracking AP accuracy. V-C State-of-the-art (SOTA) comparisons Fig. 6 shows the statistical performance of different state-of-the-art (SOTA) models, i.e., FlexPatch, EdgeDuet, and other DRL, to visualize the transmission latency in the range of cumulative distributed function (CDF) parameters. We found that the proposed GCN-assisted A2C had the best transmission latency of 50 ms with a standard deviation of 12 ms when compared to other SOTA models. FlexPatch came in second with a transmission latency of 90 ms and a standard deviation of 15 ms. Meanwhile, EdgeDuet achieved a video frame transmission latency of 110 ms, and its standard deviation is 20ms. In contrast, other DRL models achieve a video frame transmission latency of 177 ms, with a standard deviation of 33 ms. We can see from the CDF of the GCN-assisted A2C that the model works better for achieving the best video frame transmission latency across a range of communication factors. Figure 6: The effectiveness of GCN-assisted A2C over SOTA models to optimize the transmission latency. At the same time, we examined how well the GCN-assisted A2C worked regarding transmission delay, AP, and meanIoU accuracy when compared to FlexPatch and EdgeDuet, using different video resolutions as shown in Fig. 7. In Fig. 7(a), we show how accurately we can find suspicious UAVs from start to finish, using AP and meanIoU accuracy. Similarly, in Fig. 7(b), the mean IoU over end-to-end latency is compared. The GCN-assisted A2C model outperforms previous models. For example, FlexPatch AP accuracy performance is 60.10% with meanIoU accuracy results of 48.42% and achieved minimum latency results of 90.10 ms. The FlexPatch adds overhead when scenes change rapidly or unpredictably, and it is highly challenging to select the optimal context-dependent features. EdgeDuet achieved AP accuracy of 42.35% with meanIoU accuracy results of 39.52% and achieved minimum latency results of 110.25ms. This model also uses many high-resolution tiles at the edge server and is unsuitable for real-time or low-bandwidth scenarios due to offloading frame tiles to the edge server. The GCN-assisted A2C model is better at handling quickly changing or unpredictable scenes because it uses groups of pixel areas as nodes and their connections to understand how they depend on each other. The GCN-assisted A2C model reached the best accuracy of 70.72% AP, with meanIoU accuracy results of 360.30%, and improved the transmission delay to 50ms. The GCN-assisted A2C model works well in real-time or low-bandwidth situations because it can handle parts of the frame by grouping together related pixel areas. Fig. 7(c) shows the AP accuracy and meanIoU of the GCN-assisted A2C when transmitting videos of different frame sizes. The GCN-assisted A2C consistently achieves higher AP meanIoU accuracy at the server side. With the decrease in frame resolutions, GCN-assisted A2C accuracy drops upto 50 AP, which is our desired threshold to have a minimum of 50 AP at the server side. (a) (b) (c) Figure 7: Performance of different models under UAV-to-server video sub-area of frame transmission. In (a), the AP and meanIoU accuracy of finding suspicious UAVs from end-to-end are shown. In (b), the meanIoU over end-to-end latency is compared. And in (c), the performance of GCN-assisted A2C is shown over different input video frame resolutions. V-D Evaluation Results We have qualitatively and quantitatively shown the expected trade-off between AP and latency improvement for three different UAV sizes under various circumstances. Each environment has three visual situations, with each subplot representing the AP and transmission latency. The blue bars show latency, whereas the olive-colored bars represent AP. Together, they exhibit both precision and efficiency. Overlaid visuals in each subfigure illustrate corresponding visual inputs related to the environmental condition. This shows how complex the agents’ experiences are. Fig. 8 shows that smaller UAVs, similar backgrounds, and partial cloudiness can affect latency and reduce server-side AP. These unique features have a major effect on the efficiency of transmission in the other DRL models. The proposed GCN-assisted A2C keeps an AP above 50 while ensuring the best transmission speed in all conditions and sizes of UAVs during testing of the algorithms in three different conditions—cloudy, complex, and clear sky. This hypothetical situation motivates the advancement of smarter feature-correlated region prediction algorithms. The results indicate that GCN-assisted A2C consistently does better than the basic models in every situation, achieving a much higher AP with less delay. This benefit is especially evident in cloudy or messy situations, such as cloudy and complex situations, where classic models like DQN and DDPG do not perform well. GCN-assisted A2C, on the other hand, is robust to environmental changes and visual effects, making it more stable and suitable for a wider range of applications. In addition, GCN-assisted A2C continues to outperform its competitors in ideal situations such as clear skies. This demonstrates that it performs well in both challenging and normal circumstances. These findings show that GCN-assisted A2C could be effective for making real-time predictions based on vision when transmission speed and precision are important. Figure 8: We evaluated three different sizes of UAVs—small (S), medium (M), and large (L)—under various conditions, such as clear sky, complex background, and partially cloudy. VI Conclusion This article proposed a GCN-assisted A2C model that uses data from the UAV detection nano YOLO algorithm, focusing on the center of the detected object and the surrounding pixels. The design caters to scenarios in which on-board UAV detection accuracy is less than 50. We designed the detector model to identify suspicious UAVs in no-fly zones and pinpoint their location, utilizing the onboard UAV cameras. Next, we proposed using a GCN-assisted A2C to enhance the significance of certain pixel areas in the images by examining how each area connects to the center of the UAV, creating groups based on these connections, and calculating a total score with A2C. The nano detector model results emphasize that the GCN-assisted A2C model requires transmitting the frames to the server or not. We show that using the GCN-assisted A2C model can minimize the transmission latency and optimize until the AP is more than 50 on the server side. We conducted studies using authentic on-board UAV camera data and with different DRL models for the ablation study and SOTA models. Our GCN-assisted A2C model shows improved transmission latency and AP by using GCN to group related pixels and understand hidden pixel relationships, which helps the A2C make better decisions in different situations like clear skies, complex backgrounds, and partial clouds. Acknowledgments References [1] A. Alhilal, T. Braud, B. Han, and P. Hui (2022) Nebula: reliable low-latency video transmission for mobile cloud gaming. In Proceedings of the ACM Web Conference 2022, W ’22, New York, NY, USA, p. 3407–3417. External Links: ISBN 9781450390965, Link, Document Cited by: §I-B. [2] Y. Dong, L. Song, R. Xie, and W. Zhang (2022) Ultra-low latency, stable, and scalable video transmission for free-viewpoint video services. IEEE Transactions on Broadcasting 68 (3), p. 636–650. External Links: Document Cited by: §I, §I, §I. [3] A. Galanopoulos, J. A. Ayala-Romero, D. J. Leith, and G. Iosifidis (2021) AutoML for video analytics with edge computing. In IEEE INFOCOM 2021 - IEEE Conference on Computer Communications, Vol. , p. 1–10. External Links: Document Cited by: §I. [4] A. Ghosh, S. Iyengar, S. Lee, A. Rathore, and V. N. Padmanabhan (2023) REACT: streaming video analytics on the edge with asynchronous cloud support. In Proceedings of the 8th ACM/IEEE Conference on Internet of Things Design and Implementation, IoTDI ’23, New York, NY, USA, p. 222–235. External Links: ISBN 9798400700378, Link, Document Cited by: §I. [5] J. Han, Y. Ren, A. Brighente, and M. Conti (2024) RANGO: a novel deep learning approach to detect drones disguising from video surveillance systems. ACM Trans. Intell. Syst. Technol. 15 (2). External Links: ISSN 2157-6904, Link, Document Cited by: §I. [6] K. He, Y. Lu, and S. Sclaroff (2018) Local descriptors optimized for average precision. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, Vol. , p. 596–605. External Links: Document Cited by: §I-A. [7] A. Hitchcock and K. Sung (2018) Multi-view augmented reality with a drone. In Proceedings of the 24th ACM Symposium on Virtual Reality Software and Technology, VRST ’18, New York, NY, USA. External Links: ISBN 9781450360869, Link, Document Cited by: §I. [8] M. A. Khan, E. Baccour, Z. Chkirbene, A. Erbad, R. Hamila, M. Hamdi, and M. Gabbouj (2022) A survey on mobile edge computing for video streaming: opportunities and challenges. IEEE Access 10 (), p. 120514–120550. External Links: Document Cited by: §I. [9] N. Khan, A. Ahmad, A. Wakeel, Z. Kaleem, B. Rashid, and W. Khalid (2024) Efficient uavs deployment and resource allocation in uav-relay assisted public safety networks for video transmission. IEEE Access 12 (), p. 4561–4574. External Links: Document Cited by: §I. [10] K. Li, W. Ni, X. Yuan, A. Noor, and A. Jamalipour (2022) Deep-graph-based reinforcement learning for joint cruise control and task offloading for aerial edge internet of things (edgeiot). IEEE Internet of Things Journal 9 (21), p. 21676–21686. External Links: Document Cited by: §IV-B, §IV-C. [11] K. Li, W. Ni, X. Yuan, A. Noor, and A. Jamalipour (2023) Exploring graph neural networks for joint cruise control and task offloading in uav-enabled mobile edge computing. In 2023 IEEE 97th Vehicular Technology Conference (VTC2023-Spring), Vol. , p. 1–6. External Links: Document Cited by: §I, §IV-C. [12] Z. Liu and Y. Jiang (2024) Design and implementation for a uav-based streaming media system. Ad Hoc Networks 156, p. 103443. External Links: ISSN 1570-8705, Document, Link Cited by: §I. [13] A. Noor, K. Li, A. Ammar, A. Koubaa, B. Benjdira, and E. Tovar (2021) A hybrid deep learning model for uavs detection in day and night dual visions. In 2021 IEEE Third International Conference on Cognitive Machine Intelligence (CogMI), Vol. , p. 221–231. External Links: Document Cited by: §I. [14] C. Qu, P. Drefahl, W. Guo, and H. Wang (2024) Autonomous video transmission and air-to-ground coordination in uav-swarm-aided disaster response platform. In Digital Human Modeling and Applications in Health, Safety, Ergonomics and Risk Management, V. G. Duffy (Ed.), Cham, p. 339–355. External Links: ISBN 978-3-031-61060-8 Cited by: §I. [15] K. Rezaee, M. R. Khosravi, and M. S. Anari (2022) Deep-transfer-learning-based abnormal behavior recognition using internet of drones for crowded scenes. IEEE Internet of Things Magazine 5 (2), p. 41–44. External Links: Document Cited by: §I. [16] C. Song, B. Han, X. Ji, Y. Li, and J. Su (2024) AI-driven multipath transmission: empowering uav-based live streaming. IEEE Network 38 (2), p. 202–210. External Links: Document Cited by: §I. [17] F. U. M. Ullah, M. S. Obaidat, A. Ullah, K. Muhammad, M. Hijji, and S. W. Baik (2023) A comprehensive review on vision-based violence detection in surveillance videos. ACM Comput. Surv. 55 (10). External Links: ISSN 0360-0300, Link, Document Cited by: §I. [18] X. Wang, Z. Yang, J. Wu, Y. Zhao, and Z. Zhou (2021) EdgeDuet: tiling small object detection for edge assisted autonomous mobile vision. In IEEE INFOCOM 2021 - IEEE Conference on Computer Communications, Vol. , p. 1–10. External Links: Document Cited by: §I, §I, §I, §I, §I. [19] Y. Wang, J. Xu, and W. Ji (2019) A feature-based video transmission framework for visual iot in fog computing systems. In 2019 ACM/IEEE Symposium on Architectures for Networking and Communications Systems (ANCS), Vol. , p. 1–8. External Links: Document Cited by: §I. [20] D. Wu, L. Wang, M. Liang, Y. Kang, Q. Jiao, Y. Cheng, and J. Li (2024) UAV-assisted real-time video transmission for vehicles: a soft actor–critic drl approach. IEEE Internet of Things Journal 11 (8), p. 14710–14726. External Links: Document Cited by: §I. [21] J. Wu, B. Cheng, M. Wang, and J. Chen (2017) Energy-efficient bandwidth aggregation for delay-constrained video over heterogeneous wireless networks. IEEE Journal on Selected Areas in Communications 35 (1), p. 30–49. External Links: Document Cited by: §I. [22] J. Wu, R. Tan, and M. Wang (2019) Streaming high-definition real-time video to mobile devices with partially reliable transfer. IEEE Transactions on Mobile Computing 18 (2), p. 458–472. External Links: Document Cited by: §I. [23] R. Xu, S. Razavi, and R. Zheng (2023) Edge video analytics: a survey on applications, systems and enabling techniques. IEEE Communications Surveys & Tutorials 25 (4), p. 2951–2982. External Links: Document Cited by: §I. [24] K. Yang, J. Yi, K. Lee, and Y. Lee (2022) FlexPatch: fast and accurate object detection for on-device high-resolution live video analytics. In IEEE INFOCOM 2022 - IEEE Conference on Computer Communications, Vol. , p. 1898–1907. External Links: Document Cited by: §I, §I, §I, §I, §I. [25] A. Yaqoob, Z. Yuan, and G. Muntean (2024) A uav-centric improved soft actor-critic algorithm for qoe-focused aerial video streaming. IEEE Transactions on Vehicular Technology 73 (9), p. 13498–13512. External Links: Document Cited by: §I. [26] P. Yu, F. Chen, J. Wang, P. Chen, J. Cai, and M. Yang (2022) Adaptive anti-packet loss strategy for real-time video streaming. In 2022 IEEE 8th International Conference on Computer and Communications (ICCC), Vol. , p. 2063–2068. External Links: Document Cited by: §I. [27] J. Zhang, X. Huang, J. Xu, Y. Wu, Q. Ma, X. Miao, L. Zhang, P. Chen, and Z. Yang (2022) Edge assisted real-time instance segmentation on mobile devices. In 2022 IEEE 42nd International Conference on Distributed Computing Systems (ICDCS), Vol. , p. 537–547. External Links: Document Cited by: §I, §I, §I.