DUST-YOLO: A Deployable UAV Swin Transformer YOLO with Multi-Dimensional Pruning and Mixed-Precision Quantization for End-to-End Video Object Detection

Abstract

Real-time video object detection on unmanned aerial vehicles (UAVs) is essential for urban inspection and autonomous perception, yet its deployment on edge devices is severely constrained by the high computational cost of accurate detectors, the quantization sensitivity of hybrid convolution-attention networks, and the system-level latency of full video processing pipelines. To address these challenges, we present DUST-YOLO, a deployment-oriented algorithm-hardware co-design framework, where structured pruning and mixed-precision quantization-aware training (QAT) are jointly optimized with TensorRT–DeepStream for efficient UAV small-object detection on edge platforms. First, we introduce a multi-dimensional structured pruning strategy that applies asymmetric channel pruning to convolutional and feature-fusion modules while compressing the Swin Transformer prediction heads and bottleneck stacks, thereby reducing parameters and computation with limited impact on multi-scale representation capability. Second, we develop a hardware-aware mixed-precision QAT scheme that maps computation-intensive backbone layers to INT8 while preserving the Transformer-related modules in FP16, improving inference efficiency while mitigating the accuracy loss caused by uniform low-bit quantization. Third, we compile the optimized network with TensorRT and integrate the resulting inference engine into a DeepStream-based asynchronous video pipeline on the edge platform, enabling end-to-end acceleration by reducing decoding, preprocessing, and memory-transfer overheads. Experimental results on the VisDrone2019-DET dataset and the NVIDIA Jetson Orin NX demonstrate that DUST-YOLO achieves 43.7% mAP@0.5 accuracy with an end-to-end latency of 36.3 ms and a throughput of 27.5 FPS. Compared with the state of the art, DUST-YOLO reduces end-to-end latency by 56.9% and improves end-to-end video throughput by $2.31\times$.

1. Introduction

Real-time object detection on unmanned aerial vehicles (UAVs) has become a key enabling technology for low-altitude intelligent applications such as urban inspection, traffic monitoring, security patrol, emergency response, and remote sensing [1,2,3,4,5,6]. In these scenarios, UAVs continuously capture video streams and must perform on-board object recognition and localization under strict constraints on latency, power consumption, payload, and computing resources. Compared with ground-view perception, UAV-based detection is particularly challenging because targets are often small, sparsely distributed, and embedded in cluttered backgrounds with significant scale variation [7,8,9,10]. Therefore, achieving accurate and real-time video object detection on resource-constrained edge devices is of great practical importance for UAV autonomous perception systems.

To improve the accuracy of aerial small-object detection, recent detectors have increasingly adopted multi-scale representations and attention-based mechanisms. Representative examples include TPH-YOLOv5 [11,12,13], which introduces a Transformer Prediction Head (TPH) to enhance global context modeling and improve the representation of small targets. However, although such architectures offer higher detection accuracy, their efficient deployment on embedded edge platforms remains difficult. In particular, three challenges must be addressed. First, Transformer-enhanced detection models introduce substantial parameter redundancy and computational overhead, making them difficult to deploy within the limited compute and memory budgets of UAV edge devices [14]. Existing generic pruning strategies seldom consider the different redundancy patterns of convolutional layers, feature-fusion modules, and self-attention-based heads in hybrid detectors. Aggressive pruning may damage small-object-sensitive multi-scale features, whereas conservative pruning may fail to sufficiently reduce computation and memory access overhead for UAV edge deployment. Second, hybrid networks composed of convolutional and self-attention modules are highly sensitive to low-bit quantization, and conventional uniform quantization often causes severe accuracy degradation and poor operator fusion efficiency [15,16,17]. Third, even when the neural network itself is accelerated, the end-to-end video detection pipeline remains bottlenecked by video decoding, image preprocessing, memory transfers, and heterogeneous task scheduling, which significantly limits practical real-time performance [18].

Significant efforts have been devoted to alleviating these issues. In terms of model architecture, methods such as EL-YOLO [19] and YOLO-UD [20] improve small-object detection by introducing stronger feature fusion, asymptotic feature pyramid structures, or dilated convolutions to capture richer contextual information for small targets [21,22]. While these designs enhance contextual modeling, they typically increase parameter counts, FLOPs, and memory access overhead, which weakens their suitability for embedded deployment [23]. In terms of model lightweighting, many existing compression methods mainly focus on reducing network width, pruning convolutional channels, or simplifying CNN-based backbones. Although these methods can reduce model size to some extent, they are usually designed for homogeneous CNN detectors and do not explicitly distinguish the structural roles of deep convolutional layers, feature-fusion modules, Transformer prediction heads, and bottleneck stacks. Consequently, they may either remove critical features required for UAV small-object detection or leave considerable redundancy in attention-related and deep-feature-extraction modules. Regarding model quantization, existing low-bit deployment methods are also mostly designed for homogeneous convolutional networks and often rely on full-network uniform quantization. Such strategies are less effective for heterogeneous detectors that combine convolutional and self-attention modules, because their differing numerical sensitivities often lead to unacceptable accuracy loss, poor operator fusion, or limited acceleration benefits after deployment [16,17]. At the system level, traditional detection pipelines usually process video decoding, image preprocessing, and memory copy operations on the CPU, resulting in considerable I/O overhead and pipeline stalls that hinder real-time end-to-end performance [18]. Consequently, despite substantial progress in UAV detection algorithms, jointly optimizing model structure, numerical precision, and end-to-end streaming efficiency for UAV edge deployment remains an open challenge.

To overcome these challenges, we propose DUST-YOLO, a deployment-oriented UAV detection framework built upon YOLOv5l for accurate and efficient small-object detection on edge platforms. Unlike existing methods that mainly focus on either accuracy-oriented architectural enhancement, isolated model compression, or pure inference acceleration, the central idea of DUST-YOLO is to jointly optimize the detector across three tightly coupled levels: network structure, quantization strategy, and deployment pipeline. By integrating structured pruning, hardware-aware mixed-precision quantization-aware training, and DeepStream-based end-to-end acceleration on the NVIDIA Jetson Orin NX, the proposed framework achieves a favorable balance among detection accuracy, inference latency, and energy efficiency for real-world UAV video applications. Figure 1 illustrates the overall end-to-end deployment pipeline on the Jetson edge platform. The main contributions of this paper are summarized as follows:

• A multi-dimensional structured pruning strategy for lightweight UAV detection: We design an asymmetric channel pruning scheme for deep convolutional layers and feature-fusion modules to remove redundant channels while preserving the multi-scale feature extraction capability required for aerial small-object detection. In addition, we compress the Swin Transformer prediction heads and reduce the number of bottleneck stacks, substantially decreasing model parameters and computational complexity while incurring only a limited accuracy loss.
• A hardware-aware mixed-precision QAT framework for hybrid CNN–Transformer detectors: We introduce quantization-aware fine-tuning by dynamically inserting fake-quantization nodes during training, enabling the model to adapt to quantization noise before deployment. Furthermore, we map computation-intensive backbone layers to INT8 while retaining Transformer-related modules in FP16, thereby improving inference efficiency on edge hardware while maintaining operator fusion compatibility and detection accuracy.
• An efficient DeepStream-integrated end-to-end deployment system on Jetson Orin NX: We perform TensorRT explicit quantization compilation to precompute weights, fuse operators across layers, and exploit high-throughput INT8 kernels for convolutional computation. The resulting engine is integrated into an asynchronous DeepStream video pipeline that leverages hardware units such as NVDEC and VIC to reduce decoding, preprocessing, and memory-transfer overheads, significantly improving end-to-end throughput and power efficiency.

The remainder of this paper is organized as follows. Section 2 outlines the background and related work. Section 3 provides an overview of the proposed system architecture and its submodules. Section 4 presents the detailed methodology, including the structured pruning strategy, the mixed-precision QAT, and the DeepStream-based embedded multi-object detection system deployment. Section 5 discusses the experimental results, ablation studies, and power consumption analysis. Finally, Section 6 concludes the paper.

2. Related Work

This section is organized into three main subsections. Section 2.1 discusses lightweight optimization and model pruning techniques. Section 2.2 examines current data quantization strategies. Finally, Section 2.3 reviews edge deployment and system acceleration frameworks.

2.1. Lightweight Optimization and Model Pruning

Modern research has focused on reducing the redundancy of object detection models for edge deployment. Architectures like EL-YOLO and YOLO-UD have introduced feature pyramid optimizations and contextual information aggregation [24] to balance efficiency and accuracy. General lightweight models such as YOLO-LIGHT [25] and LSOD-YOLO emphasize limited edge computing scenarios [26]. To further categorize these efforts, lightweighting techniques generally bifurcate into unstructured and structured pruning. While unstructured pruning achieves high sparsity and significantly reduces theoretical parameter counts, it often relies on specialized sparse matrix multiplication libraries. This limits its practical deployment efficiency on standard embedded GPUs. Structured pruning, on the other hand, directly trims the physical dimensions of convolution kernels and feature maps, yielding immediate latency reductions.

However, a significant limitation of existing pruning techniques is that they often apply uniform compression across all network layers, which can disproportionately weaken the fine-grained responses of small objects. Furthermore, many structured pruning methods fail to account for hardware-level alignment, such as modulo-32 constraints, leading to memory fragmentation and sub-optimal CUDA parallel execution on platforms like the NVIDIA Jetson. Additionally, with the recent integration of Vision Transformers (ViTs) into aerial detection architectures, traditional CNN-centric pruning metrics struggle to accurately evaluate the redundancy within multi-head self-attention (MHA) modules. These unresolved gaps highlight the urgent need for a more comprehensive compression method. This directly motivates our multi-dimensional structured pruning strategy, which jointly optimizes convolutional channels and Transformer bottleneck depths while maintaining strict hardware modulo alignment to achieve actual on-device acceleration.

2.2. Quantization Strategies and Transformer Sensitivity

Quantization is a standard technique to reduce storage and memory access overhead by converting floating-point weights to integers. While Post-Training Quantization (PTQ) is widely used due to its simplicity, it frequently suffers from accuracy degradation in complex scenarios. QAT has emerged as a more robust alternative, allowing the model to adapt to quantization noise during fine-tuning. In recent years, mixed-precision quantization has gained traction as a superior alternative to uniform INT8 quantization. By selectively maintaining highly sensitive layers in higher precision (e.g., FP16) while mapping computationally intensive convolutional backbones to the INT8 domain, mixed-precision schemes aim to achieve an optimal balance between execution latency and mean Average Precision (mAP).

Despite these advancements, quantizing models with self-attention mechanisms, such as EDGS-YOLOv8 [27], remains highly challenging. Transformer modules are highly sensitive to activation ranges, especially within Softmax and LayerNorm operations. Forcible INT8 truncation in these paths often leads to gradient distortion and disrupts native MHA fusion in the inference engine. Recent studies on quantized Transformers reveal that extreme distribution outliers in activation functions are the primary culprits for precision degradation. If Q/DQ (Quantize/Dequantize) nodes are inserted blindly without hardware-aware boundary definitions, the low-level compiler will be forced to fragment continuous computational flows into isolated small kernels, potentially increasing rather than decreasing latency. Therefore, existing hardware-agnostic quantization methods fail to achieve optimal deployment for hybrid architectures. This limitation necessitates our hardware-aware mixed-precision QAT approach, which strategically isolates highly sensitive Transformer blocks in FP16 while heavily quantizing convolutional backbones to INT8 to protect MHA fusion integrity.

2.3. Edge Deployment and Acceleration

System-level optimization is crucial for achieving real-time performance in airborne vision tasks. Beyond model-specific inference, the total latency includes video decoding, image preprocessing, and post-processing. A common pitfall in current UAV object detection research is the isolated evaluation of pure model inference time, which deeply neglects the severe systemic overhead introduced by the surrounding video pipeline. High-resolution drone streams require intensive operations such as scaling, color space conversion, and memory allocation.

Traditional deployment methods often rely on native inference frameworks that encounter I/O bottlenecks and high CPU-GPU communication overhead during memory copying. While standalone execution environments like ONNX Runtime or basic TensorRT APIs provide robust tensor mathematical acceleration, they typically still require the host CPU to manage stream buffering, format conversions, and layout transformations. While frameworks like NVIDIA DeepStream have been explored for real-time video analysis [28,29], deep integration between the model architecture and the streaming media pipeline is often overlooked. Without hardware-software co-design—such as heterogeneous computing decoupling and tensor batching—the full potential of the Jetson’s unified memory architecture remains underutilized [30,31,32]. To break through these system-level bottlenecks, it is imperative to move beyond pure algorithm optimization. This drives our deep integration with the DeepStream framework, which seamlessly maps decoding and inference tasks to dedicated heterogeneous IP blocks (such as NVDEC and VIC) to establish a zero-copy memory paradigm, thereby fully unleashing the real-time processing potential of airborne edge intelligence.

To provide a comprehensive overview and highlight the motivation of our approach,

Table 1. Concise comparison of related works for edge deployment of UAV-view object detection.

Research Direction	Representative Works/Tools	Key Observation
Lightweight Optimization	[19,20,24,25,26]	Improve detection efficiency, but the accuracy–complexity trade-off remains challenging.
Quantization Strategies	[27]	Low-bit deployment is effective, but Transformer-related modules remain quantization-sensitive.
Deployment Frameworks	ONNX/TensorRT/DeepStream [28,29,30,31,32]	Accelerate inference or video processing, but end-to-end pipeline overhead is still important.
DUST-YOLO	Proposed	Combines structured pruning, mixed-precision QAT, TensorRT, and DeepStream for edge deployment.

summarizes the representative related works discussed above. By comparing these existing methods from the perspectives of algorithmic optimization, precision quantization, and system deployment, we identify the critical gaps that currently hinder end-to-end UAV edge intelligence. These limitations directly motivate the holistic, algorithm-hardware co-design framework proposed in this study.

3. System Overview

This section is organized into two main subsections. Section 3.1 describes the network architecture of DUST-YOLO and explains the complete inference flow from UAV video frames to multi-scale detection outputs. Section 3.2 presents the overall system framework, including the algorithmic compression, hardware compilation, and DeepStream-based deployment layers that jointly support edge-oriented UAV object detection.

3.1. Network Architecture of DUST-YOLO

UAV-view object detection requires a strong multi-scale representation because targets in aerial scenes are often small, sparsely distributed, partially occluded, and affected by large viewpoint and scale variations. For this reason, DUST-YOLO starts from a YOLOv5l-based high-capacity detector as an accuracy-oriented backbone rather than as an uncompressed model for direct edge deployment. The purpose of selecting this stronger baseline is to preserve sufficient feature extraction capability for complex UAV scenes. The subsequent pruning, mixed-precision QAT, TensorRT compilation, and DeepStream deployment stages are then used to convert this high-capacity detector into an edge-compatible detection framework.

At the architectural level, DUST-YOLO introduces a dedicated extra-small (xsmall) detection head to construct a four-scale prediction structure for xsmall, small, medium, and large objects. In addition, conventional C3 modules in the Neck are replaced with C3STR blocks that incorporate Swin Transformer window attention. The xsmall prediction branch helps retain high-resolution spatial details for tiny targets, while the C3STR blocks enhance local-window contextual modeling after multi-scale feature fusion. Although Transformer-related modules may introduce additional matrix multiplication and memory-access overhead, they are explicitly considered in the proposed compression and mixed-precision deployment flow. Therefore, C3STR is used as a representation-enhancement module under deployment-aware constraints rather than as an unconstrained complexity-increasing component. The specific network architecture of DUST-YOLO is illustrated in Figure 2.

The overall inference flow can be described as follows. The raw UAV video stream is first decoded and preprocessed into a standardized RGB tensor. This tensor is then fed into the Backbone, where stacked Conv and C3 modules progressively extract hierarchical spatial and semantic features. The SPPF module at the deepest stage further enlarges the receptive field and strengthens high-level semantic aggregation. These multi-resolution feature maps provide the basis for detecting objects with different apparent sizes in UAV scenes.

The extracted features are subsequently transmitted to the Neck for bidirectional multi-scale feature fusion. In the top-down path, high-level semantic features are upsampled and concatenated with shallower features to recover fine-grained spatial information. In the bottom-up path, the fused features are further aggregated to enhance semantic consistency across scales. After feature concatenation, C3STR blocks refine the fused representations through window-based attention, which helps distinguish small targets from cluttered backgrounds while maintaining the multi-scale detection structure.

Finally, the enriched feature maps are sent to the TPH-style prediction module. Four detection branches are used to predict xsmall, small, medium, and large objects, respectively. Each branch produces dense prediction tensors containing bounding-box coordinates, objectness scores, and class probabilities. The raw predictions from all branches are decoded and filtered by confidence thresholding and Non-Maximum Suppression (NMS), producing the final UAV-view object detection results.

3.2. System Module Design

Although the above architecture improves the representation of small and multi-scale targets, the high-capacity backbone and the attention-enhanced C3STR blocks also introduce considerable computation and memory-access overhead. Moreover, practical UAV video analytics involves not only neural-network inference but also video decoding, image preprocessing, data transfer, and post-processing. A native inference pipeline that treats these stages independently can easily suffer from CPU-side decoding overhead, repeated memory copies, and inefficient heterogeneous scheduling. Therefore, DUST-YOLO is designed as an algorithm–hardware co-design framework rather than a standalone network modification.

As illustrated in Figure 3, the proposed system is organized into three closely connected layers, ranging from model-level compression to edge-side video-stream deployment:

• The first module: Algorithmic Compression Layer. This layer performs deployment-oriented model lightweighting on the server side through multi-dimensional structured pruning and mixed-precision QAT. The pruning strategy is customized for the heterogeneous structure of DUST-YOLO: redundant channels in convolutional layers and feature-fusion modules are removed, bottleneck stacks in deep C3 modules are simplified, and Transformer-related branches in C3STR blocks are compressed under scale-aware constraints. The pruning process further incorporates Jetson-oriented channel alignment and preserves the coupling among the embedding dimension, the number of attention heads, and the per-head dimension in Transformer-related modules. After accuracy recovery through fine-tuning, QAT is applied to make the model adapt to quantization noise before edge-side compilation.
• The second module: Hardware Compilation Layer. This layer converts the optimized model from the ONNX intermediate format into a hardware-specific TensorRT inference engine. During compilation, convolution-dominated paths are mapped to INT8 execution where appropriate, while Transformer-related attention subgraphs are preserved in higher precision to reduce quantization sensitivity and maintain operator-fusion compatibility. This precision allocation follows the numerical sensitivity of heterogeneous CNN–Transformer modules and the fusion behavior of TensorRT. TensorRT further performs graph optimization and operator fusion to reduce fragmented kernel execution and unnecessary memory access on the Jetson platform.
• The third module: System Deployment Layer. This layer integrates the compiled TensorRT engine into an end-to-end DeepStream video analytics pipeline. The input UAV video stream is decoded by dedicated hardware units, such as NVDEC, while resizing, color-space conversion, stream batching, inference, and post-processing are handled by DeepStream plugins. This asynchronous heterogeneous pipeline reduces non-inference overheads during neural network execution, including decoding, preprocessing, memory transfer, and post-processing. By coordinating decoding, preprocessing, inference, and output rendering in this pipeline, the system reduces CPU–GPU communication overhead and better utilizes the heterogeneous computing resources of the edge platform.

4. Methodology

This section is organized into three main subsections to detail the proposed algorithm-hardware co-design framework. Section 4.1 discusses the multidimensional structured pruning strategy, explaining how feature channels, attention parameters, and network depth are jointly compressed to reduce algorithmic redundancy. Section 4.2 presents the hardware-aware mixed-precision QAT approach. Section 4.3 details the comprehensive system deployment framework based on NVIDIA DeepStream.

4.1. Structured Pruning and Model Compression Strategy

To deploy the high-accuracy DUST-YOLO model on resource-constrained edge computing devices, the primary challenge lies in its large parameter size (45.46 M) and extremely high computational complexity (62.79 GFLOPs). To break through the computation bottleneck, this paper proposes a multidimensional structured feature compression strategy based on sensitivity analysis [6]. This strategy jointly considers three key dimensions—feature channels, attention mechanisms, and network depth—to perform deep reconstruction and redundancy pruning on the model. While preserving the model’s multi-scale feature extraction capability to the greatest extent possible, it achieves a highly hardware-friendly lightweight network design.

4.1.1. Asymmetric Channel Pruning and Hardware Alignment for Convolutional Layers

In general, feature redundancy in the model exhibits clear hierarchical differences. Specifically, shallow layers are mainly responsible for extracting fundamental spatial features such as edges and textures, and aggressive pruning of these layers would lead to a significant drop in detection accuracy. Therefore, our method adopts an asymmetric pruning mechanism and places the optimization emphasis on deep convolutional layers and feature pyramid modules. In implementation, we employ a dependency graph algorithm and introduce the L1 norm as the criterion for evaluating the importance of convolution kernels. Suppose that the weight matrix of the c-th convolution kernel in the l-th layer is denoted by $W_c^{\left(l\right)}\in {\mathbb{R}}^{N\times K\times K}$. Its importance score is defined as the sum of the absolute values of its weights:

$$I_c={\displaystyle \sum _{n=1}^N}{\displaystyle \sum _{i=1}^K}{\displaystyle \sum _{j=1}^K}\left|W_{c,n,i,j}^{\left(l\right)}\right|$$

(1)

Accordingly, redundant channels whose scores fall below an explicit dynamic threshold $\tau >0$ are removed, making it possible to distinguish the redundancy levels of convolutional layers with different depths and computational costs and thus determine the pruning value of each layer. Meanwhile, in order to maximize CUDA core parallel efficiency on the Jetson platform and avoid memory-access latency caused by memory fragmentation, the objective of structured pruning is modeled as a constrained optimization problem. Here, let $\mathcal{L}$ be the composite loss function (incorporating bounding box regression and classification loss), x denote the input image tensor, and y represent the ground-truth bounding box labels:

$$\underset{W}{\min }\mathcal{L}(f(x;W),y)\mathrm{s}.\mathrm{t}.\sum _c\mathbb{I}(I_c\ge \tau )\le C_{target}$$

(2)

where $C_{target}$ denotes the target number of channels after pruning and satisfies $C_{target}\equiv 0\left(\mathrm{mod}32\right)$. This modulo-32 alignment constraint strictly guarantees that the pruned feature maps can perfectly match the vectorized storage and computation specifications of the underlying hardware.

4.1.2. Pruning and Parameter Compression of Transformer Modules

The C3STR module introduced in DUST-YOLO significantly enhances the global receptive field, but the built-in Swin Transformer structure also introduces extremely dense matrix multiplication overhead. To address this issue, we perform in-depth simplification on both the Self-Attention and MLP submodules. Figure 4 illustrates the structure of the C3STR module.  

To make the configuration of the C3STR module explicit, we further specify the hyperparameters of the paired Swin Transformer layers used in each C3STR block. Each C3STR block contains two consecutive SwinTransformerLayer modules. The first layer adopts regular window-based multi-head self-attention (W-MSA) with a window size of 8 and a shift size of 0, while the second layer adopts shifted-window multi-head self-attention (SW-MSA) with the same window size of 8 and a shift size of 4. This paired W-MSA/SW-MSA design enables local window modeling and cross-window information interaction without introducing the quadratic cost of global self-attention. For an input resolution of $640\times 640$ the four C3STR branches correspond to P2, P3, P4, and P5 feature maps. The number of attention heads is set according to $H=D/32$, where D denotes the embedding dimension inside the C3STR block. Therefore, the per-head dimension is fixed at 32 for all branches, which keeps the attention scaling factor stable before and after pruning. The scale-wise Swin Transformer configuration is summarized in

Table 2. Scale-wise Swin Transformer configuration in C3STR modules.

Branch	Feature Size	D	Heads	W-MSA	SW-MSA
P2/xsmall	$160\times 160$	64	2	$M=8,s=0$	$M=8,s=4$
P3/small	$80\times 80$	128	4
P4/medium	$40\times 40$	256	8
P5/large	$20\times 20$	512	16

.

In the architectural design of the Transformer block, the feature dimensions are subject to strict coupling relationships. Let $D_{old}$ and $D_{new}$ denote the embedding dimensions before and after pruning, respectively. Furthermore, let $C_{skip}$ be the shortcut-connection dimension and $\gamma$ be the expansion ratio of the feed-forward network (FFN). To guarantee the continuity of multi-branch feature concatenation and MHA computation, the internal concatenation dimension $C_{concat}$, hidden-layer dimension $D_{MLP}$, and number of attention heads H must satisfy the following constraints:

$$C_{concat}=D_{new}+C_{skip},D_{MLP}=\gamma ·D_{new},d={\displaystyle \frac{D_{new}}{H_{new}}}={\displaystyle \frac{D_{old}}{H_{old}}}=32$$

(3)

First, at the global optimization level, the expansion ratio $\gamma$ in all scale detection heads is uniformly reduced from the constant 4 to 2, effectively eliminating the over-parameterized redundancy of nonlinear mappings in the FFN. Second, for the deep detection branches that dominate large-scale targets and possess wide receptive fields (the P4/P5 scales), this strategy significantly scales down the embedding dimension D by 75%; whereas for the shallow branches corresponding to tiny-object spatial features (the P2/P3 scales), either an unchanged or a mild 50% dimensionality reduction strategy is adopted to avoid accuracy loss caused by reduced resolution.

While reducing the number of parameters, this operation satisfies the constraints of the above equations, ensuring that the scaling factor $\sqrt{d}$ remains constant in the attention calculation:

$$\mathrm{Attention}(Q,K,V)=\mathrm{Softmax}\left({\displaystyle \frac{Q{K}^{\top }}{\sqrt{d}}}\right)V$$

(4)

By maintaining this factor, we effectively prevent shifts in the attention distribution that might otherwise be caused by the pruning process.

In the Transformer’s FFN, the standard computational process can be represented as

$$FFN\left(x\right)=\mathrm{Activation}(x{W}_1+b_1)W_2+b_2$$

(5)

where $W_1\in {\mathbb{R}}^{D\times \gamma D}$ and $W_2\in {\mathbb{R}}^{\gamma D\times D}$. Consequently, the joint compression of $\gamma$ and D results in the parameter count of each FFN being markedly reduced from $2\left(4D_{old}^2\right)$ to $2\left(2D_{new}^2\right)$, which significantly removes the redundancy within the fully connected layers.

4.1.3. Depth Simplification of Feature Cascades

Beyond the compression of channel width and attention dimensionality, we observed that the excessive stacking of bottleneck layers within deep C3 modules constitutes a major source of forward-propagation latency. While deep hierarchical structures are traditionally favored for capturing complex semantic information, they introduce significant computational overhead and memory access frequency on edge devices with limited bandwidth, such as the NVIDIA Jetson. In the specific context of UAV aerial imagery, where small objects dominate the scene, we found that over-abstracting features through extremely deep cascades often yields diminishing returns in detection accuracy and can even lead to the loss of fine-grained spatial cues necessary for precise localization.

To address this, we implement a depth-level pruning strategy that systematically reduces the number of bottleneck stacks in specific backbone feature-extraction stages from 9 to 6. Since this simplification is performed internally within the C3 blocks, it maintains the integrity of input and output channel dimensions, allowing the pruned modules to be seamlessly reintegrated into the DUST-YOLO architecture without disrupting the multi-scale fusion logic of the feature pyramid. By removing these redundant layers, we effectively shorten the physical path of feature transmission and reduce the cumulative I/O overhead. This structural optimization ensures that the network depth is strictly aligned with the hardware-level execution profile, further unleashing the real-time processing potential of the edge platform.

4.1.4. Progressive Pruning Schedule and Target Sparsity

We summarize the three-stage progressive pruning schedule in

Table 3. Progressive structured pruning configuration of DUST-YOLO.

Stage	Pruned Component	Before Pruning	After Pruning	Target Sparsity
Stage I	Selected deep Conv/C3/SPPF modules	256/512/1024 channels	128/256/512 channels	50% channel pruning
Stage I	C3STR branch P4	output 512, $D=256$, $H=8$	output 256, $D=128$, $H=4$	50% channel/embedding pruning
Stage I	C3STR branch P5	output 1024, $D=512$, $H=16$	output 512, $D=256$, $H=8$	50% channel/embedding pruning
Stage II	C3STR branch P4 embedding path	$D=128$, $H=4$	$D=64$, $H=2$	50% additional embedding pruning
Stage II	C3STR branch P5 embedding path	$D=256$, $H=8$	$D=128$, $H=4$	50% additional embedding pruning
Stage III	C3STR branch P3 embedding path	$D=128$, $H=4$	$D=64$, $H=2$	50% embedding pruning
Stage III	FFN in C3STR branches P2–P5	expansion ratio $\gamma =4$	expansion ratio $\gamma =2$	50% hidden-dimension pruning
Stage III	Deep C3 bottleneck stack	9 bottleneck blocks	6 bottleneck blocks	33.3% depth pruning

. The table reports the target structure and target sparsity ratio of each pruned module group.

During C3STR embedding pruning, the embedding dimension and the number of attention heads are reduced synchronously, so that the per-head dimension remains fixed at 32. This preserves the attention scaling factor while reducing the computational cost of Transformer-related branches. The complete compression process consists of three pruning–fine-tuning rounds.

By jointly applying the above pruning strategies to channel width, attention parameters, and bottleneck depth, we successfully perform a hardware-friendly slimming and reconstruction of DUST-YOLO. The optimized lightweight architecture reduces the total number of parameters by approximately 48% and lowers the forward computational cost by roughly 26%. After multiple rounds of pruning and fine-tuning, the final pruned model fully recovers its detection capabilities, even showing a slight accuracy improvement over the pretrained baseline. This provides an efficient model foundation for the subsequent reduction of weight bit width through QAT and for TensorRT-based hardware-accelerated deployment.

4.2. Mixed-Precision QAT and Edge-Side Mixed-Precision Quantized Deployment

Although structured pruning substantially reduces the theoretical computational complexity of the object detection model, relying solely on floating-point computation (FP32/FP16) is still insufficient to fully unleash the potential of the underlying hardware Tensor Cores on edge devices with constrained computing power and memory bandwidth, such as the NVIDIA Jetson Orin NX. Quantizing the model to 8-bit integers (INT8) is a key approach to breaking through the memory-access bottleneck. However, in heterogeneous networks containing self-attention mechanisms, conventional full-network uniform quantization often leads to accuracy degradation and failure of operator fusion. To address this issue, this paper proposes a hardware-aware mixed-precision QAT training architecture, combined with TensorRT explicit quantization engine compilation on the edge side, thereby achieving efficient deployment from the perspective of algorithm–hardware co-design.

4.2.1. QAT and Attention Fusion Protection

During the fine-tuning stage, QAT dynamically injects fake quantization nodes into the computational graph. This mechanism enables the network weights to adaptively absorb quantization noise. It requires training data and the insertion of fake quantization layers during the training stage, so that a model containing Q/DQ nodes can be obtained through training. During edge-side quantized deployment, quantization is then carried out according to these Q/DQ nodes. After the QAT process is completed, the fake quantization layers contain the quantization scales used to quantize the weights and activations for model inference, and therefore usually achieve higher accuracy than PTQ [5,9].

In this work, we adopt a symmetric uniform quantization scheme. For an arbitrary floating-point tensor X, its quantization scaling factor s, the INT8 quantized tensor $X_q$, and the dequantized approximation follow the mathematical mappings:

$$s={\displaystyle \frac{\max \left(\right|X\left|\right)}{127}},X_q=\mathrm{Clip}\left(\mathrm{Round}\left({\displaystyle \frac{X}{s}}\right),-127,127\right),X\approx X_q·s$$

(6)

However, because the Transformer module involves intensive nonlinear normalization operations (such as Softmax and LayerNorm), it is highly sensitive to the dynamic range of activation values. In the self-attention mechanism, the attention computation (as previously defined in Equation (4)) is particularly vulnerable to discretized precision. If INT8 truncation is forcibly applied to the matrices within this mechanism, the discretized inner-product space will cause severe distortion of the gradients of the exponential terms. Moreover, in the TensorRT inference engine on the Jetson platform, the bottleneck of the MHA subgraph lies in memory scheduling rather than arithmetic throughput. If Q/DQ nodes are inserted into these highly sensitive paths, the low-level compiler will be forced to interrupt the native MHA fusion strategy, fragmenting the continuous computational flow into a large number of isolated small kernels. This significantly increases the frequency of memory read/write operations, causing the latency after quantization to increase rather than decrease.

Based on this underlying physical mechanism, this paper implements a mixed-precision QAT strategy. We explicitly define the quantization boundaries by locking the Transformer core subgraphs in the detection head to floating-point precision, while mapping only the computationally intensive backbone network and conventional convolutional layers into the INT8 domain. This not only significantly accelerates the convolution operators but also guarantees the complete fusion of the Transformer subgraphs. A schematic of the precision selection for different network modules and the insertion logic of fake quantization nodes is shown in Figure 5.

4.2.2. TensorRT Explicit Quantization Compilation and Continuous-Domain Optimization

After QAT training is completed and a computational graph containing explicit Q/DQ nodes is exported, extreme acceleration on the edge side relies on TensorRT’s low-level explicit-quantization compilation. Unlike conventional PTQ methods that rely on implicit calibration, the explicit compilation mechanism strictly follows the Q/DQ topological boundaries in the computational graph, fusing floating-point operators and reconstructing them within the INT8 domain. Layers for which Q/DQ nodes are not inserted during training are executed in FP16 precision by default.

During the engine construction stage, the compiler first performs constant folding and graph pruning, precomputing and absorbing nodes that do not participate in dynamic computation. For example, the Q node of a weight tensor is merged into the weight itself, ensuring that during actual inference, the FP32 weight no longer requires dynamic conversion, thereby reducing runtime VRAM access overhead. The compiler statically precomputes the convolution-layer weights together with the input/output scaling factors ($s_w,s_x,s_y$) and fuses the bias term b. The originally complex floating-point convolution is mathematically mapped at the hardware level into high-throughput INT8 integer multiply-accumulate instructions targeting the Jetson Orin Tensor Cores, expressed as

$$Y_q=\mathrm{SAT}8\left(\mathrm{Round}\left({\displaystyle \frac{s_w·s_x}{s_y}}(W_q\ast X_q)+{\displaystyle \frac{b}{s_y}}\right)\right)$$

(7)

where ∗ denotes the convolution operation, and $\mathrm{SAT}8(·)$ denotes the 8-bit saturation truncation function. Notably, the coefficient ${\displaystyle \frac{s_w·s_x}{s_y}}$ is precomputed as a constant, eliminating expensive floating-point math during forward propagation. Furthermore, TensorRT performs cross-layer operator fusion, equivalently merging fragmented operators (e.g., Conv + BN + SiLU) into a single large kernel. This optimization minimizes the storage of intermediate feature maps in the GPU memory, significantly reducing I/O latency. For the Jetson Ampere architecture, the compiler executes a tactic search to select the fastest execution path. As illustrated in Figure 6, ordinary convolution layers are fused in the INT8 domain, while the Swin Transformer block operators are preserved in the FP16 domain to maintain MHA fusion integrity.

To further minimize latency, our method addresses the overhead of layout transformation nodes (Reformat/Transpose/Shuffle). The engine-building process is abstracted as a cost minimization problem:

$$\min \tau \left(G\right)=\sum _{v\in V}{\tau }_{\mathrm{kernel}}\left(v\right)+\sum _{e\in E_b}{\tau }_{\mathrm{reformat}}\left(e\right)$$

(8)

where $E_b$ denotes the set of edges crossing precision or layout boundaries. Guided by this principle, we strategically shift quantization nodes upstream of the Concat operation into the INT8 domain. This forces the Concat operation to execute directly within the INT8 cache domain, enabling zero-copy memory concatenation and avoiding unnecessary Reformat operations triggered by precision conversion at quantization boundaries.

In summary, by introducing a sensitivity-driven mixed-precision QAT strategy alongside hardware-level TensorRT explicit compilation technology, this section establishes a highly efficient deployment pipeline from the algorithm level down to the Jetson hardware edge. This strategy allocates precision asymmetrically based on the distinct characteristics of Transformer and convolution operators. While safeguarding the integrity of MHA fusion in the self-attention mechanism, it maximizes the length of the computational path executed in INT8 precision, significantly enhancing edge-side deployment speed with negligible accuracy degradation (less than 1.5%).

4.3. DeepStream-Based Multi-Object Detection System Deployment

Although model-level optimizations like pruning and mixed-precision QAT significantly reduce the computational intensity of DUST-YOLO, achieving peak real-time performance in aerial scenarios requires minimizing the systemic overhead introduced by video I/O and heterogeneous data scheduling. Traditional inference pipelines often suffer from CPU bottlenecks during decoding and memory copy latencies between the host and the accelerator. To address these system-level constraints, this section presents a high-throughput deployment framework based on DeepStream, which establishes a zero-copy memory paradigm and leverages hardware-specific acceleration units to achieve efficient end-to-end video analytics.

4.3.1. System Architecture Design

To construct an end-to-end, high-throughput UAV video analytics system, we utilized the DeepStream tool to integrate the optimized DUST-YOLO model into a highly efficient streaming media processing pipeline. DeepStream is not solely an inference engine but a heterogeneous computing platform based on the GStreamer framework, capable of achieving full-pipeline hardware acceleration from video capture, decoding, and preprocessing to inference and post-processing.

The overall system architecture, constructed on the Jetson end-to-end aerial computing platform, is illustrated in Figure 7. This architecture encompasses the complete data flow from front-end capture to application output.  

In the core processing pipeline, the high-resolution video stream captured by the UAV is first ingested through a video source plugin. Subsequently, it undergoes hardware-accelerated tensor batch preprocessing via stream multiplexing and batching plugins such as nvstreammux. The processed tensors are then fed into the core inference plugin, nvinfer, to execute highly efficient DUST-YOLO object detection inference. The system subsequently cascades the nvtracker and nvdsosd plugins to accomplish object trajectory tracking and bounding box rendering. Finally, the data is transmitted through an output node to the application layer for statistics, counting, and alarm decision-making, forming a complete AI-enabled smart surveillance paradigm.

The core advantage of this end-to-end architecture lies in its deep use of the Jetson’s unified physical memory architecture. This hardware-software co-design substantially reduces the scheduling overhead and bus communication latency of the host CPU. It achieves seamless heterogeneous decoupling of computational tasks and hardware resources, thereby practically guaranteeing the real-time performance of object detection tasks on the airborne platform under constrained power and computing conditions.

4.3.2. Hardware Acceleration and Parallel Mechanisms

The acceleration effect of DeepStream on DUST-YOLO primarily stems from system-level optimizations across the following three dimensions:

• Heterogeneous Computing Decoupling: As shown in Figure 8, the front-end encoded video is decoded into raw frames using the dedicated hardware decoder (NVDEC). Subsequently, the Video Image Compositor (VIC) performs scaling and color-space conversion in VRAM, outputting RGB tensors for inference. By offloading these compute-intensive preprocessing tasks to specific hardware units, data flow remains strictly resident in the VRAM, entirely circumventing the memory copy overhead typical of traditional architectures.

• Tensor Batching: To process high-resolution UAV streams, the system utilizes the nvstreammux plugin to aggregate discrete frames into a four-dimensional inference tensor (Figure 9). This batching strategy maximizes the occupancy of GPU parallel compute units. By reducing the CUDA Kernel launch frequency from N to 1, system-level scheduling latency is significantly mitigated, guaranteeing real-time inference under high throughput.

• Highly Concurrent Pipeline: Leveraging an asynchronous pipeline architecture, the system achieves four-stage parallelism (decoding, preprocessing, inference, and post-processing). Specifically, the implementation of CUDA Streams enables the overlapping execution of the current frame’s inference with the previous frame’s post-processing. This design effectively masks I/O wait times, maximizing overall system throughput.

5. Experimental Results

5.1. Experimental Settings

• Hardware and Software Environments: The experimental evaluation of the proposed framework was conducted across two distinct environments to simulate both high-performance training and resource-constrained edge deployment. The server-side operations, encompassing model training, structured pruning, fine-tuning, and QAT, were performed on a workstation equipped with an AMD Ryzen 9 9950X CPU (Advanced Micro Devices, Inc., Santa Clara, CA, USA) and an NVIDIA GeForce RTX 4090 D GPU (NVIDIA Corporation, Santa Clara, CA, USA; 24 GB VRAM), running on Ubuntu 22.04.5 LTS (Canonical Ltd., London, UK) with CUDA 12.4 (NVIDIA Corporation, Santa Clara, CA, USA), Python 3.8.18 (Python Software Foundation, Wilmington, DE, USA), and PyTorch 2.4.1 (Meta Platforms, Inc., Menlo Park, CA, USA). For edge-side deployment and inference benchmarking, we utilized the NVIDIA Jetson Orin NX 16GB platform (NVIDIA Corporation, Santa Clara, CA, USA), which features an 8-core Arm Cortex-A78AE CPU (Arm Ltd., Cambridge, UK) and an Ampere-architecture GPU. This edge platform operated under a software environment comprising CUDA 12.6 (NVIDIA Corporation, Santa Clara, CA, USA), Python 3.10.18 (Python Software Foundation, Wilmington, DE, USA), PyTorch 2.6.0 (Meta Platforms, Inc., Menlo Park, CA, USA), TensorRT 10.3.0 (NVIDIA Corporation, Santa Clara, CA, USA), and NVIDIA DeepStream SDK 7.1 (NVIDIA Corporation, Santa Clara, CA, USA).
• Dataset Justification: To validate the effectiveness of the DUST-YOLO in UAV vision, the VisDrone2019-DET dataset and the UAVDT dataset were employed for training and precision assessment [33,34]. The VisDrone dataset is characterized as a standard and challenging benchmark, containing 10 object categories: Pedestrian, Motor, Van, Person, Truck, Car, Bus, Awning, Bicycle, and Tricycle. These images include various angles and heights, captured both during the day and at night, in different resolutions. The VisDrone2019-DET dataset is divided into three parts, consisting of 6471 training images, 548 validation images, and 1610 test images. The UAVDT dataset is collected by UAVs across a range of complex environments. It comprises images recorded in different cities, under varying scenes and altitudes, with annotations for Cars, Trucks, and Buses, containing 10 h of raw video data with approximately 80,000 video frames. For our experiments, considering the high inter-frame redundancy in the original UAVDT videos, where object locations change only slightly between adjacent frames, we uniformly subsampled all sequences at a 1/4 frame rate by extracting one frame every four frames. The resulting UAVDT subset was then partitioned into a training set and a validation set at an approximate 6:4 ratio, finally yielding 6046 training images and 4155 validation images.
• Training Details: All models, including the proposed DUST-YOLO and the selected comparative baselines, were implemented and trained under identical configurations to ensure a fair comparison. Specifically, all algorithms used a standardized input resolution of $640\times 640$ pixels and were optimized using the Adam optimizer for 300 epochs with a batch size of 4. All models were evaluated under the Jetson Orin NX platform, and inference protocol, and were converted to ONNX format and compiled into TensorRT inference engines to ensure consistent edge-side evaluation conditions.
• Pruning and Fine-Tuning Details: The structured pruning process was performed in three progressive stages, and each pruning stage was followed by an independent fine-tuning process. The best checkpoint obtained after each fine-tuning stage was retained, and the best checkpoints from the first two stages were used as the initialization for the subsequent pruning stages. For all three post-pruning fine-tuning stages, the pruned model was fine-tuned on the VisDrone training set for 160 epochs with an input resolution of $640\times 640$ and a batch size of 16. Adam was used as the optimizer. The initial learning rate during fine-tuning was set to 0.1 times the initial learning rate used in baseline training and was decayed using a one-cycle cosine learning-rate schedule. The regularization settings followed the baseline hyperparameter configuration: weight decay was applied only to ordinary weight parameters, while BatchNorm parameters and bias terms were excluded from weight decay. Label smoothing was set to 0.0. Exponential moving average (EMA) was enabled, and the checkpoint with the best validation fitness was retained after each fine-tuning stage.
• Practical UAV-View Edge Evaluation Context and Metrics: To reflect practical UAV-view video analytics on edge platforms, the deployment evaluation was conducted on continuous aerial video streams rather than isolated static images. The Jetson Orin NX was locked in MAXN mode for stable benchmarking. Detection accuracy was evaluated on the VisDrone2019-DET validation set using mAP@0.5 and mAP@0.5:0.95. For efficiency evaluation, pure inference latency was measured using the native TensorRT C++ API to isolate model-level acceleration, while end-to-end latency and throughput were measured over the complete video detection pipeline, including video decoding, preprocessing, inference, and post-processing. The end-to-end test used a 211-s UAV-view aerial video at 30 FPS, totaling more than 6300 frames. All tests were conducted after warm-up and repeated five times, with the average end to end latency results reported. For the comparative baselines in

  Table 4. Performance comparison on Jetson Orin NX. Bold values indicate the best performance.

  Model	Resolution(pixels)	mAP@0.5 (%)	mAP@0.5:0.95 (%)	Inference Time (ms)	End-to-End Latency (ms)	End-to-End FPS	Speedup Ratio
  YOLOv8s [35]	$640\times 640$	38.6	23.1	33.7	94.3	10.6	$1.00\times$
  YOLOv9s [36]	$640\times 640$	39.5	23.5	26.0	87.7	11.4	$1.08\times$
  YOLOv10s [37]	$640\times 640$	38.2	22.9	26.8	86.4	11.6	$1.09\times$
  YOLOv11s [38]	$640\times 640$	38.2	22.7	21.8	84.1	11.9	$1.12\times$
  YOLOv12s [39]	$640\times 640$	38.2	22.8	27.5	86.2	11.6	$1.09\times$
  YOLOv5l [11]	$640\times 640$	40.6	24.0	40.4	104.8	9.5	$0.90\times$
  YOLOv8l [35]	$640\times 640$	43.0	26.5	52.6	113.7	8.8	$0.83\times$
  YOLOv10l [37]	$640\times 640$	42.3	25.8	50.8	108.4	9.2	$0.87\times$
  FE-YOLO [40]	$640\times 640$	34.9	-	37.3	96.9	10.3	$0.97\times$
  YOLO-UD-s [20]	$640\times 640$	45.5	-	24.6	84.2	11.9	$1.12\times$
  DUST-YOLO (Ours)	$640\times 640$	43.7	25.9	18.9	36.3	27.5	$\mathbf{2}.\mathbf{60}\times$

  , the end-to-end metrics were measured using the conventional TensorRT-based video detection pipeline, while the final DUST-YOLO system was evaluated with the proposed TensorRT–DeepStream asynchronous pipeline under the same end-to-end measurement scope.

5.2. Comparative Experiments

To evaluate the performance of various methods, we tested the deployed models on the Jetson platform across accuracy metrics (mAP@0.5 and mAP@0.5:0.95) on the VisDrone2019 validation set, as well as speed metrics (TensorRT pure inference time, end-to-end video detection latency, and end-to-end video detection frame rate). Our optimally compressed model achieved an mAP@0.5 of 43.7% and an mAP@0.5:0.95 of 25.9%, with a pure inference latency of 18.9 ms, an end-to-end video detection latency of 36.3 ms, and an end-to-end video detection frame rate of 27.5 FPS. The comparison results between our approach and other object detection works are summarized in Table 4.

In recent years, the YOLO object detection family has undergone rapid architectural evolution [41,42], continuously pushing the boundaries of speed and accuracy. Typically, from the classical YOLOv5 to the subsequent generations of YOLO algorithms (such as YOLOv8, YOLOv9, YOLOv10, YOLOv11, and YOLOv12), pre-trained weights are offered in various architectural scales (e.g., nano, small, medium, large, and extra large). Among them, small-scale models often serve as representatives of high-speed detectors, while larger variants usually provide stronger detection accuracy at the cost of increased inference latency.

Compared with recent s-tier YOLO variants, DUST-YOLO achieves a clear accuracy advantage while maintaining faster inference. Specifically, its mAP@0.5 is at least 4.2% higher than that of the s-tier baselines, and its mAP@0.5:0.95 is at least 2.4% higher than the best s-tier result in Table 4. At the same time, DUST-YOLO reduces pure inference time to 18.9 ms, which is lower than all evaluated s-tier models. For example, compared with YOLOv11s, the fastest s-tier baseline in pure inference time, DUST-YOLO reduces inference latency by 13.3% while improving mAP@0.5 by 5.5%.

The comparison with larger YOLO variants further demonstrates the deployment advantage of the proposed framework. Although L-tier models generally improve detection accuracy compared with their S-tier counterparts, they introduce substantially higher inference latency and end-to-end latency on the Jetson platform. For example, YOLOv8l achieves 43.0% mAP@0.5 and 26.5% mAP@0.5:0.95, but its pure inference time and end-to-end latency reach 52.6 ms and 113.7 ms, respectively. In contrast, our DUST-YOLO achieves comparable accuracy, with 43.7% mAP@0.5 and 25.9% mAP@0.5:0.95, while reducing pure inference latency to 18.9 ms and end-to-end latency to 36.3 ms. Compared with YOLOv5l, YOLOv8l, and YOLOv10l, DUST-YOLO improves end-to-end FPS by approximately 2.9–3.1 times, indicating that the proposed deployment framework can provide near-large-model accuracy while achieving significantly higher edge-side throughput.

When evaluated against recent improved YOLO architectures, such as FE-YOLO (mAP@0.5 = 34.9%, inference time = 37.3 ms), our model delivers an 8.8% absolute increase in mAP@0.5 while reducing inference time to 50.7% of FE-YOLO. Furthermore, Table 4 shows that while YOLO-UD-s achieves a higher mAP@0.5 (45.5% vs. 43.7%), DUST-YOLO achieves a 23.2% reduction in pure inference time and a 2.31× improvement in end-to-end FPS. Therefore, although our primary focus is not to push the absolute upper bound of detection accuracy, these results indicate that DUST-YOLO achieves a more deployment-oriented accuracy-speed trade-off on the Jetson edge platform.

By leveraging DeepStream to accelerate end-to-end video object detection, our system demonstrates a substantial throughput advantage. The end-to-end latency is reduced to 36.3 ms, significantly outperforming all evaluated algorithms. This lead in system-level latency is further amplified: our processing time is only 37.5% of FE-YOLO’s (96.9 ms) and 43.1% of YOLO-UD-s’s (84.2 ms). In terms of end-to-end FPS, our work achieves 27.5 frames per s. Compared to the end-to-end performance of other YOLO series and lightweight object detection works, which typically operate below 12 FPS in our Jetson evaluation, our method achieves a substantially higher frame rate. This validates that the proposed pipeline optimizes the complete real-time detection workflow, from video capture, decoding, and preprocessing to inference and post-processing.

In summary, on the VisDrone2019 validation set and the Jetson Orin NX platform, the proposed algorithm and deployment framework successfully combine high-accuracy detection with algorithmic lightweighting and embedded hardware acceleration. While maintaining competitive precision metrics, the pure model inference latency is reduced to 18.9 ms, the system-level end-to-end latency is controlled at 36.3 ms, and the end-to-end frame rate reaches 27.5 FPS, achieving a favorable trade-off among accuracy, inference speed, and overall system throughput.

5.3. Ablation Study

To dissect the contribution of each component, an ablation study was performed. For clarity in the subsequent analyses and within

Table 5. Ablation study of optimization methods on Jetson Orin NX. Bold values indicate the best performance.

Method	FP16 Quant.	INT8 (QAT)	Structured Pruning	DS Pipeline	mAP@0.5 (%)	mAP @0.5:0.95 (%)	Inference Time (ms)	End-to-End FPS	Speedup Ratio
Baseline					44.9	27.2	62.7	8.4	$1.00\times$
Opt. 1	✓				44.9	27.2	28.9	11.5	$1.37\times$
Opt. 3			✓		45.1	27.3	48.4	9.3	$1.11\times$
Opt. 4				✓	44.9	27.2	62.7	13.0	$1.55\times$
Opt. 1+3	✓		✓		45.1	27.3	23.7	12.2	$1.45\times$
Opt. 1+2	✓	✓			43.6	25.9	23.3	12.2	$1.45\times$
Opt. 1+2+3	✓	✓	✓		43.7	25.9	18.9	14.1	$1.68\times$
Opt. 1+4	✓			✓	44.9	27.2	28.9	23.2	$2.76\times$
Opt. 3+4			✓	✓	45.1	27.3	48.4	15.1	$1.80\times$
Opt. 1+3+4	✓		✓	✓	45.1	27.3	23.7	24.6	$2.93\times$
Opt. 1+2+4	✓	✓		✓	43.6	25.9	23.3	26.1	$3.11\times$
Ours (Opt. 1+2+3+4)	✓	✓	✓	✓	43.7	25.9	18.9	27.5	$\mathbf{3}.\mathbf{27}\times$

, the fundamental optimization techniques are denoted by specific abbreviations. Specifically, Opt. 1 denotes the application of FP16 quantization to maximize the utilization of hardware Tensor Cores; Opt. 2 indicates the implementation of QAT to map compute-intensive layers to INT8 precision; Opt. 3 represents the proposed scale-aware structured pruning strategy; and Opt. 4 denotes the DeepStream-based asynchronous video pipeline. These techniques were evaluated both independently and synergistically to quantify their impacts on inference latency, model accuracy, and overall system throughput. In Table 5, the baseline refers to the original DUST-YOLO network architecture introduced in the System Overview before applying any deployment-oriented optimization.

Comparing the baseline model with Opt. 3, introducing the proposed scale-aware structured pruning while maintaining FP32 precision significantly reduced the single-frame inference latency from 62.7 ms to 48.4 ms. Paradoxically, the pruned model’s mAP@0.5 and mAP@0.5:0.95 improved to 45.1% and 27.3%, respectively. This phenomenon is attributed to the iterative “pruning–finetuning–repruning–refinetuning” strategy adopted in this study. By cyclically stripping redundant feature dimensions from deep networks and immediately restoring precision, this process not only reduced computational load but also served as a strong regularizer, effectively suppressing the model’s overfitting tendencies in the complex context of UAV inspections.

To elucidate the source of this latency reduction, we quantified the parameter and computational cost reductions brought by the proposed pruning strategy. The network’s total parameter count decreased from 45.46 M to 23.66 M, and the computational load dropped from 62.79 GFLOPs to 43.56 GFLOPs. Notably, the most significant compression occurred within the four C3STR modules. As illustrated in Figure 10, the pruning intensity is scale-aware across different detection branches. For the P2 xsmall-object branch, a conservative pruning strategy is adopted, reducing the parameter count and FLOPs by 22.0% and 21.8%, respectively. For the P3 small-object branch, a moderate compression ratio is applied, leading to reductions of 63.7% in parameters and 63.6% in FLOPs. In contrast, the P4 medium-object branch is compressed more aggressively, with parameter and FLOP reductions of 89.9% and 89.8%, respectively. The P5 large-object branch undergoes the strongest compression, reducing parameters and FLOPs by 92.1% and 92.3%, respectively. This scale-aware pruning design preserves more capacity in high-resolution branches for small-object representation while removing greater redundancy from deeper branches with stronger semantic abstraction.

To fully exploit the underlying compute capability of Tensor Cores, Opt. 1 enabled FP16 quantization, decreasing latency to 28.9 ms with zero precision loss. Building upon this, Opt. 1+2 introduced QAT and edge-side mixed-precision deployment, mapping compute-intensive convolutional layers to the INT8 domain. Experiments show this strategy further compressed latency to 23.3 ms with negligible accuracy degradation (only a 1.3% drop compared to the baseline), yielding a 1.45× end-to-end framerate speedup.

As the optimal algorithmic lightweighting solution in this study, Opt. 1+2+3 integrated multidimensional pruning with mixed-precision QAT, achieving the lowest inference latency of 18.9 ms on the Jetson platform and an end-to-end speedup ratio of 1.68. This scheme realized the optimal balance between algorithmic complexity and hardware execution efficiency while maintaining high accuracy.

The Opt. 4-related comparisons in Table 5 further quantify the system-level effect of the DeepStream pipeline. When only Opt. 4 is applied to the baseline detector, the mAP values and pure inference time remain unchanged, while the end-to-end FPS increases from 8.4 to 13.0. This is because the DeepStream pipeline mainly improves the complete video-processing workflow by reducing non-inference overheads, including video decoding, preprocessing, memory transfer, and post-processing. Similar improvements are observed when DeepStream is combined with different model-level optimizations: Opt. 1 improves from 11.5 FPS to 23.2 FPS, Opt. 3 improves from 9.3 FPS to 15.1 FPS, and Opt. 1+2 improves from 12.2 FPS to 26.1 FPS. Building upon the model-level optimized configuration discussed above, integrating the DeepStream pipeline further increases the end-to-end FPS from 14.1 to 27.5. These results indicate that the final acceleration comes from two complementary sources: model-level computation reduction through FP16 quantization, mixed-precision QAT, and structured pruning, as well as system-level reduction of non-inference overheads in the complete UAV video detection pipeline.

Beyond exceptional throughput, the paramount advantage of the proposed DUST-YOLO framework lies in its profound energy efficiency for battery-constrained UAVs. To quantitatively validate this, we rigorously measured power consumption using the Jetson’s built-in tegrastats utility at a sampling rate of 1 Hz.

The total energy consumption was calculated using the trapezoidal integration method. Specifically, for each discrete sampling step, we calculated the time interval $dt$ between two consecutive samples and took the average power $(P_{prev}+P_{curr})/2$. Multiplying these yields the energy for that time segment, and accumulating these segments over the entire testing process provides the integral area under the power-time curve:

$$E_{total}=\sum {\displaystyle \frac{P_{prev}+P_{curr}}{2}}\times dt$$

(9)

By synergizing extreme algorithmic compression with the DeepStream asynchronous architecture, our end-to-end aerial computing platform fundamentally reshapes the system’s energy profile. While maximizing hardware utilization slightly elevates the average power plateau, the drastically shortened active duration (a 69.7% reduction in total execution time) effectively negates this increase. Consequently, our fully optimized framework achieves a staggering 68.5% reduction in cumulative total energy consumption compared to deploying the baseline model on a traditional synchronous pipeline. It is crucial to note that this reduction reflects the total system energy yield per task, rather than just per-frame algorithmic efficiency, as processing fewer frames per unit time in an unoptimized pipeline results in prolonged system activation and severe energy waste.

The energy-efficiency advantages are further substantiated by the power-consumption trajectories. As illustrated in Figure 11, the power curve of the DeepStream-accelerated scheme (Figure 11a) exhibits superior steady-state characteristics with standard deviation bounds indicating stable power variance, compared to the native TensorRT approach (Figure 11b). The curve concludes with a sharp, step-like descent upon task completion. Given the integral methodology defined above, the significantly reduced area under the curve quantitatively verifies the minimization of energy dissipation. This demonstrates that the proposed algorithm-hardware co-design establishes a high-throughput, low-latency computational paradigm, providing a reliable, endurance-optimized deployment strategy for UAV platforms.

5.4. Deployment-Oriented Robustness and Failure Analysis

5.4.1. Scale-Wise Accuracy Preservation

This section further evaluates whether the final optimized DUST-YOLO preserves its detection capability after lightweight deployment optimization, especially for small objects that dominate UAV-view scenes. Instead of only relying on the aggregate mAP@0.5 metric reported by the YOLO/Ultralytics evaluation protocol, we provide a more fine-grained scale-wise accuracy analysis to examine the influence of structured pruning and mixed-precision QAT on objects of different sizes.

To this end, we further report COCO-style AP metrics computed using the official pycocotools COCO API, including AP, AP50, AP75, APs, APm, and APl. It should be noted that these COCO-style AP values are not directly identical to the mAP values reported by the Ultralytics built-in evaluator in the previous experiments; due to differences in implementation details and evaluation protocols, the AP50 values obtained using pycocotools are typically slightly lower. Here, AP denotes the mean average precision averaged over IoU thresholds from 0.50 to 0.95, while APs, APm, and APl indicate the detection performance for small, medium, and large objects, respectively. These metrics are particularly useful for analyzing whether the proposed compression and quantization process causes disproportionate degradation on small targets.

As shown in

Table 6. Scale-wise accuracy preservation on the VisDrone2019-DET validation set under the COCO-style evaluation protocol before and after lightweight deployment optimization.

Model	AP (%)	AP50 (%)	AP75 (%)	APs (%)	APm (%)	APl (%)
Baseline	25.7	42.8	26.5	16.2	36.9	43.8
DUST-YOLO (Ours)	24.4	41.5	24.7	15.3	35.0	43.1

, after lightweight deployment optimization, DUST-YOLO achieves 24.4% AP, 41.5% AP50, and 24.7% AP75 under the COCO-style evaluation protocol. Compared with the uncompressed baseline, the decreases are 1.3%, 1.3%, and 1.8%, respectively. For scale-wise detection, APs decrease from 16.2% to 15.3%, while APm and APl decrease by 1.9% and 0.7%, respectively. These results indicate that the proposed lightweight optimization keeps the accuracy degradation within a limited range across different object scales, especially for small objects that are critical in UAV-view object detection.

5.4.2. Cross-Dataset Generalization Performance

To further evaluate whether the lightweight optimized model preserves its generalization ability beyond VisDrone2019, we conducted an additional cross-dataset evaluation on the subsampled UAVDT validation subset described in Section 5.1. Since UAVDT differs from VisDrone2019 in scene distribution, flight altitude, object categories, and video acquisition conditions, this experiment provides a complementary assessment of DUST-YOLO under dataset shift.

As shown in

Table 7. Cross-dataset generalization performance on the subsampled UAVDT validation subset under the YOLO/Ultralytics evaluation protocol.

Model	mAP@0.5 (%)	mAP@0.5:0.95 (%)
Baseline	33.5	18.5
DUST-YOLO (Ours)	32.7	19.2

, under the YOLO/Ultralytics evaluation protocol, DUST-YOLO obtains 32.7% mAP@0.5 and 19.2% mAP@0.5:0.95 on the subsampled UAVDT validation subset. Compared with the uncompressed baseline, mAP@0.5 decreases slightly from 33.5% to 32.7%, while mAP@0.5:0.95 increases from 18.5% to 19.2%. This indicates that after structured pruning and mixed-precision quantization, the model does not suffer a substantial accuracy drop on the subsampled UAVDT validation subset and still maintains comparable detection performance under the main evaluation metrics used in this paper.

The COCO-style results in

Table 8. Cross-dataset generalization performance on the subsampled UAVDT validation subset under the COCO-style evaluation protocol.

Model	AP (%)	AP50 (%)	AP75 (%)	APs (%)	APm (%)	APl (%)
Baseline	16.4	32.2	14.6	12.4	25.7	20.4
DUST-YOLO (Ours)	17.3	31.6	17.2	11.8	28.5	19.0

further provide a scale-wise view of the cross-dataset performance. DUST-YOLO achieves 17.3% AP, 31.6% AP50, and 17.2% AP75, compared with 16.4%, 32.2%, and 14.6% for the baseline, respectively. For scale-wise metrics, APs change from 12.4% to 11.8%, APm changes from 25.7% to 28.5%, and APl changes from 20.4% to 19.0%. These results show that the lightweight optimized model preserves the overall detection capability across different object scales. In particular, the APs value, which is highly sensitive in challenging UAV-view object detection, is only slightly affected, which is consistent with the scale-wise results reported in Table 6.

Overall, the subsampled UAVDT results demonstrate that DUST-YOLO maintains stable cross-dataset generalization after lightweight deployment optimization. The comparable performance on the subsampled UAVDT validation subset indicates that the proposed optimization strategy does not noticeably compromise detection robustness while enabling the deployment efficiency improvements reported in the previous sections.

5.4.3. Visual Robustness and Failure Case Analysis

Figure 12 provides a visual robustness and failure-case analysis under challenging UAV-view scenarios. The three rows show the original images, the detection results of the baseline model, and those of our final lightweight optimized model, respectively. The three columns correspond to different challenges: (a) dense small and truncated objects, (b) low-light-induced blur, and (c) low light, motion blur, and occlusion.

In Figure 12a, most regions contain dense small objects. The baseline and our model show no obvious difference in the overall detection quality. Notably, our model successfully detects a truncated vehicle at the bottom of the image that is missed by the baseline, suggesting that the lightweight optimization does not significantly weaken dense small-object detection and can still retain responses to partially visible objects.

In Figure 12b, many objects are blurred due to low illumination. For example, the car in the upper-right region is correctly detected by both models. However, our model fails to detect the pedestrian on the right sidewalk, indicating that extremely small pedestrians under low-light and low-contrast conditions remain challenging.

In Figure 12c, both models correctly detect most vehicles affected by low illumination and motion blur. More robustly, our model avoids the false detection caused by vehicle reflections on the glass facade of the left-side building, whereas the baseline incorrectly detects the reflection as a real vehicle. Nevertheless, our model misses the occluded car in the lower-left corner, and both models mistakenly detect the upper sidewalk area as a truck.

Overall, the visual results show that the proposed lightweight optimization does not noticeably degrade detection quality in difficult UAV-view scenes. All comparisons are conducted at the same $640\times 640$ input resolution as the quantitative experiments. Increasing the input resolution may alleviate some failure cases by providing richer spatial details, but it would also slow down inference and thus be less suitable for efficient deployment on low-power Jetson edge platforms.

6. Conclusions

This paper presents an end-to-end framework to enable real-time, high-accuracy object detection on resource-constrained UAV edge devices. First, multidimensional structured pruning on the DUST-YOLO model reduces the number of parameters by 48% and the computational cost by 26% while preserving multi-scale feature extraction. Second, a mixed-precision QAT and TensorRT deployment strategy overcomes memory-access bottlenecks, optimally balancing algorithmic complexity and hardware efficiency. Finally, integrating the optimized model into the DeepStream framework enables full system-level hardware acceleration through tensor batching and heterogeneous computing decoupling. Experimental results on the Jetson Orin NX platform demonstrate significant improvements. The proposed framework reduces pure inference latency to 18.9 ms (a 70% reduction) and boosts the end-to-end video detection rate to 27.5 FPS (over 3 times the baseline). Furthermore, energy consumption is substantially reduced to 31.5% of the baseline, all with negligible accuracy loss (maintaining 43.7% mAP@0.5 on VisDrone2019). Ultimately, this method achieves an optimal balance of accuracy, speed, and power efficiency, providing a highly practical edge-computing solution for the emerging low-altitude economy and intelligent UAV inspections.

In future work, we will further evaluate DUST-YOLO on additional UAV datasets and real flight videos to verify its generalizability under broader environmental conditions. We also plan to investigate automated pruning-ratio search and finer-grained mixed-precision quantization strategies. Moreover, integrating the current detector with online multi-object tracking will be explored to achieve more complete UAV video understanding.