GLDS-YOLO: An Improved Lightweight Model for Small Object Detection in UAV Aerial Imagery

Abstract

To enhance small object detection in UAV aerial imagery suffering from low resolution and complex backgrounds, this paper proposes GLDS-YOLO, an improved lightweight detection model. The model integrates four core modules: Group Shuffle Attention (GSA) to strengthen small-scale feature perception, Large Separable Kernel Attention (LSKA) to capture global semantic context, DCNv4 to enhance feature adaptability with reduced parameters, and further proposes a novel Small-object-enhanced Multi-scale and Structure Detail Enhancement (SMSDE) module, which enhances edge-detail representation of small objects while maintaining lightweight efficiency. Experiments on VisDrone2019 and DOTA1.0 demonstrate that GLDS-YOLO achieves superior detection performance. On VisDrone2019, it improves mAP@0.5 and mAP@0.5:0.95 by 12.1% and 7%, respectively, compared with YOLOv11n, while maintaining competitive results on DOTA. These results confirm the model’s effectiveness, robustness, and adaptability for complex small object detection tasks in UAV scenarios.

1. Introduction

With the rapid development and widespread deployment of unmanned aerial vehicle (UAV) technology in both civil and industrial domains, aerial imaging has become an essential means of acquiring ground information. Owing to their flexible mobility, high-altitude perspectives, and high-resolution imaging capabilities, UAVs demonstrate notable advantages in scenarios such as disaster rescue, environmental monitoring, agricultural management, and public security [1]. However, in many applications the targets are small, sparsely distributed, and weakly featured; detecting such small objects has therefore become a key challenge in UAV aerial imaging. Small-object detection in UAV imagery presents unique complexities: on the one hand, small objects occupy only a few pixels, exhibit limited feature representation, and are easily overwhelmed by cluttered backgrounds; on the other hand, UAV acquisition is frequently affected by illumination variation, dynamic backgrounds, and viewpoint changes, further increasing the difficulty of detection. Consequently, how to efficiently and accurately detect and recognize small objects in complex scenes has become an important research topic in computer vision.

Current object-detection approaches can be broadly grouped into two categories. The first comprises traditional detectors based on manually designed features [2,3], which offer strong interpretability and modest computational demands but have limited representation capacity and struggle with large-scale data and complex scenes. The second comprises deep learning–based detectors, which possess powerful feature-extraction ability and broad generalization and have become the mainstream research direction. These methods are typically divided into two-stage and one-stage paradigms. Two-stage detectors (e.g., R-CNN, Fast R-CNN and Faster R-CNN [4,5,6]) first generate region proposals and then perform classification and localization, achieving high accuracy but incurring substantial model complexity and computational cost that hinder efficient deployment in resource-constrained UAV scenarios. One-stage detectors (e.g., YOLO [7] and SSD [8]) omit the proposal stage and directly predict categories and locations, offering high speed and efficiency; they have demonstrated clear advantages for small-object detection in UAV imagery.

2. Related Work

In recent years, advances in deep learning have enabled notable progress in small-object detection based on convolutional neural networks (CNNs). Yang et al. [9] introduced a global spatial attention structure to capture global information; although it alleviates the loss of small-object features, it exhibits a relatively high false-positive rate for visually similar targets. To address mismatches between small-object predictions and ground-truth boxes, Wei et al. [10] replaced CIoU with the Focal-EIoU loss. Building upon Mask R-CNN, Zhou et al. [11] proposed a self-attention feature pyramid network (SA-FPN) that enhances information fusion across pyramid levels, improving detection accuracy at the cost of increased model complexity. To overcome the limitations of independent feature maps and fixed receptive fields in the detection head, Liao et al. [12] designed a Dynamic and RepConv Head (DRHead) that adaptively adjusts the receptive field for the input feature map, thereby integrating multi-scale contextual information and improving robustness and accuracy. Jiang et al. [13] incorporated AKConv into YOLOv8 and devised the C2f-BE module to enhance feature-learning capacity. Liang et al. [14] combined a parallel auxiliary multi-scale feature-enhancement module (MFEM) with RetinaNet and constructed a bidirectional feature pyramid, significantly improving small-object detection; however, in scenes with densely distributed small objects, false positives and missed detections remain issues. Li et al. [15] proposed RemDet, which redesigns the YOLOv8 architecture by introducing ChannelC2f, GatedFFN, and CED modules to efficiently improve both accuracy and speed for small-object detection. Lu et al. [16] presented MASF-YOLO, based on the YOLOv11 architecture, achieving a favorable balance between accuracy and efficiency through multi-scale feature aggregation. Wan et al. [17] proposed DAU-YOLO, which integrates receptive-field attention (RFA) and dynamic upsampling (DAU) into the YOLOv11 backbone to enhance the modeling of dense small-object patterns, yielding notable improvements under occlusion and low-illumination conditions. BPD-YOLO [18] integrates dual-phase and pyramid fusion to strengthen tiny-object perception while curbing parameter growth, while LightUAV-YOLO [19] introduces optimized feature enhancement and local attention tailored for UAV scenes with a compact budget. EMFE-YOLO [20] employs efficient multi-scale feature enhancement and prunes redundant heads to improve throughput, and ELNet [21] simplifies the backbone and detection heads for real-time deployment on edge devices. In addition, [22] incorporates intra-group multi-scale fusion attention and adaptive weighted feature fusion into YOLOv8, significantly improving sensitivity to small targets in UAV remote sensing imagery.

Beyond algorithmic advances, electromagnetic interference (EMI/IEMI) can corrupt or interrupt UAV imaging—e.g., by disturbing CMOS/CCD camera pipelines (readout timing and data integrity), which degrades captured frames and downstream perception [23,24,25].

Research Gaps

• Existing UAV small-object detectors often lack lightweight designs, making them unsuitable for real-time deployment on aerial platforms.
• Prior studies typically focus on either global semantic context or local detail features, but effective integration of both remains underexplored.
• Robustness under practical UAV conditions, such as electromagnetic interference, image degradation, and onboard hardware constraints, is rarely investigated.
• Detail-preserving modules have received limited attention, and existing approaches often increase parameters significantly, conflicting with lightweight requirements.

Contributions

• We propose GLDS-YOLO, a lightweight detection model tailored for UAV small-object detection, integrating four complementary modules: GSA, LSKA-SPPF, DCNv4, and SMSDE.
• We design SMSDE, a novel lightweight edge-detail enhancement module that reduces parameters by nearly one-third compared with MSDE while maintaining detection accuracy.
• We conduct extensive experiments on VisDrone2019 and DOTA1.0, demonstrating consistent improvements over state-of-the-art baselines.
• We provide comprehensive ablation studies, including module-wise contributions and a direct comparison between MSDE and SMSDE.
• We discuss UAV deployment considerations, highlighting both the potential applications and the current limitations of our approach.

The rest of this paper is organized as follows. Section 3 introduces the architecture of GLDS-YOLO and its core modules. Section 4 presents the experimental settings, results, and ablation studies. Section 5 concludes the paper by summarizing the main findings, limitations, and future directions.

3. Method

Building on the above improvements, we present the overall architecture of GLDS-YOLO and the cooperation among its components. Figure 1 illustrates the end-to-end pipeline: GSA [26,27,28,29] in the backbone enhances the perception of low-scale targets; SPPF-LSKA [30] embedded in the feature pyramid strengthens global semantics and multi-scale fusion; DCNv4 [31] is introduced into the neck to maintain lightweight design while improving robustness and a lightweight SMSDE [32,33,34,35] is placed before the detection head to recover edge details and reduce false positives.

These four modules were deliberately chosen for their complementary mechanisms to address the main challenges of UAV small-object detection. Specifically, GSA improves fine-grained perception of weak local features, LSKA-SPPF provides global semantic context to alleviate cluttered backgrounds, DCNv4 enhances adaptability to irregular target shapes and orientations, and SMSDE restores edge details while maintaining lightweight efficiency. Together, they form a mechanism-driven design that directly targets the problems of insufficient feature representation, limited global context, and blurred boundaries in UAV imagery.

The following subsections detail each module and its integration into the overall framework, followed by visualizations and ablations in Section 4.

3.1. Small-Object Perception Module

In UAV imagery, small objects often appear with weak visual responses, fuzzy boundaries, and limited texture, making them easily overwhelmed by background clutter. To address these challenges, we introduce a lightweight attention mechanism—Group Shuffle Attention (GSA)—into the YOLOv11n backbone to enhance the sensitivity to fine-grained object features while maintaining low computational cost. The overall architecture of the GSA module is shown in Figure 2.

“Group1” denotes the grouped feature channels used for partitioned processing to reduce computation, and “B1” refers to the predicted boundary features that assist in enhancing edge precision in the segmentation output.

The GSA module is composed of five sequential components: (1) channel normalization, (2) feature grouping, (3) Hadamard Product Attention (HPA) for group-wise enhancement, (4) group-wise shuffle for inter-group interaction, and (5) depthwise separable convolution for final feature integration.

First, the input feature map $X\in R(B\times C\times H\times W)$ is normalized using Layer Normalization:

$$X^{\prime }=LayerNorm\left(X\right)$$

(1)

The normalized features are then equally divided into four groups along the channel dimension:

$$X^{\prime }=\left\{X_1,X_2,X_3,X_4\right\},X_i\in R^{B\times {\displaystyle \frac{C}{4}}\times H\times W},i\in \left\{\mathrm{1,2},\mathrm{3,4}\right\}$$

(2)

For each feature group, the GSA module incorporates a Hadamard Product Attention (HPA) mechanism to enhance feature representation. Within the HPA structure, a learnable global memory tensor $S_i\in R^{(1\times {\displaystyle \frac{C}{4}}\times K\times K)}$ is introduced, which serves as a shared global context prior. This memory is upsampled via interpolation to match the spatial resolution of the input features $H\times W$.

$$Resize\left(S_i\right)\in R^{\left(1\times {\displaystyle \frac{C}{4}}\times H\times W\right)}$$

(3)

Subsequently, the memory features are integrated into the grouped features via element-wise multiplication (Hadamard product):

$$X_i^{\prime }=X_i⨀Con{v}_i\left(Resize\left(S_i\right)\right),i\in \left\{\mathrm{1,2},\mathrm{3,4}\right\}$$

(4)

$⨀$ means element-wise multiplication, $Con{v}_i$ means group-wise convolution operation is applied within each feature group to further refine local representations. By introducing global contextual cues through the HPA mechanism, the discriminative capacity of grouped features is significantly enhanced, especially in capturing fine-grained details and improving local-global feature alignment.

To alleviate the information isolation introduced by group-wise processing and to promote inter-group feature interaction, the GSA module adopts a deterministic group shuffle operation. By reordering the grouped feature channels in a fixed pattern, this operation facilitates cross-group information exchange and enhances global feature integration.

$$X^{″}=shuffle\left(X_1^{\prime },X_2^{\prime },X_3^{\prime },X_4^{\prime }\right)$$

(5)

The shuffle operation effectively disrupts the independence between feature groups, facilitating global information fusion. Subsequently, the reordered features are integrated using depthwise separable convolution. Specifically, the depthwise convolution processes each channel independently, thereby reducing computational complexity, while the pointwise (1 × 1) convolution aggregates cross-channel information. The final output feature map is computed as follows:

$$F_{out}=Con{v}_{Depthwise}\left(X^{″}\right)+Con{v}_{Pointwise}\left(X^{″}\right)$$

(6)

The GSA module maps input features to optimized outputs through grouped attention and lightweight convolutional design. It reduces parameters and computation while preserving feature expressiveness. This structure effectively enhances boundary modeling and fine-grained detail capture, making it well-suited for UAV-based small object detection and real-time edge deployment.

3.2. Large-Kernel Attention for Multi-Scale Fusion Module

The proposed SPPF-LSKA module is specifically designed to enhance both local detail modeling and long-range contextual perception, which are critical for accurate detection of small objects in UAV imagery. As illustrated in Figure 3 and Figure 4, this module integrates the fast Spatial Pyramid Pooling (SPPF) structure with the Large Separable Kernel Attention (LSKA) mechanism. The combined design allows efficient multi-scale feature extraction and receptive field expansion, significantly improving the network’s sensitivity to small targets while maintaining low computational overhead.

The SPPF component constructs multi-scale feature responses using hierarchical max-pooling. Let the input feature be $F\in R\left(C\times H\times W\right)$, where $C$ denotes the number of channels and $H$, $W$ are the height and width, respectively. Three sequential max-pooling operations are applied to generate feature maps $F_1,F_2,F_3$, which are concatenated with the original feature map along the channel dimension:

$$F_{concat}=Concat\left(F,F_1,F_2,F_3\right)$$

(7)

The pooling kernel size and padding are chosen so that the spatial resolution of all features is preserved, enabling precise alignment. This multi-scale aggregation not only enriches the representation capacity but also injects global contextual cues that benefit small object recognition.

After multi-scale fusion, the LSKA component computes spatial attention on the concatenated feature map. LSKA leverages large-kernel decomposition to approximate a $K\times K$ convolution by factorizing it into horizontal and vertical depthwise 1-D convolutions, reducing computational complexity while expanding the receptive field. Given the input $F_{concat}$, LSKA first applies horizontal and vertical convolutions:

$$F_h=Con{v}_{1\times k}\left(F_{concat}\right),F_v=Con{v}_{k\times 1}\left(F_h\right)$$

(8)

It then incorporates dilated convolutions to capture broader spatial dependencies and long-range semantic context:

$$F_{dh}=Con{v}_{1\times k}^{dilated}\left(F_v\right),F_{dv}=Con{v}_{k\times 1}^{dilated}\left(F_{dh}\right)$$

(9)

A final pointwise convolution generates the spatial attention weights $A$, which are used to reweight the input features through element-wise multiplication:

$$F_{out}=F_{concat}\odot A$$

(10)

This kernel decomposition strategy reduces the computational complexity from $O\left(k^2\right)$ to $O\left(2k\right)$, while the incorporation of dilated convolutions further enlarges the receptive field without incurring significant increases in parameters or computational cost. Consequently, the module preserves the representational advantages of large-kernel modeling while achieving substantially improved efficiency.

3.3. Deformable Convolution v4 Module

In conventional convolutional neural networks (CNNs), the sampling locations of convolution kernels are fixed in a regular grid, which limits their ability to model objects with varying shapes, scales, and orientations. This constraint is particularly detrimental in UAV-based small object detection, where targets often exhibit irregular boundaries and diverse spatial distributions.

To address this limitation, we integrate the Deformable Convolution v4 (DCNv4) module into the neck of the YOLOv11n architecture, aiming to enhance spatial adaptability and representation robustness. The basic structure of the DCNv4 module is illustrated in Figure 5.

The core mechanism of DCNv4 allows the convolution kernel to dynamically adjust its sampling positions according to the geometry of the input features, enabling more flexible and accurate capture of object shapes and spatial layouts.

The basic deformable convolution operation can be formulated as

$$y\left(p_0\right)=\sum _{K=1}^K{w}_k\ast x\left(p_o+p_k+{∆}_{pk}\right)$$

(11)

where $y\left(p_0\right)$ denotes the output feature value at position $p_0$, $x\left(p_o+p_k+{∆}_{pk}\right)$ represents the input feature at the dynamically sampled position, $K$ is the number of kernel sampling points, $p_k$ are the predefined offsets, ${∆}_{pk}$ are the learnable offsets predicted by the network, and $w_k$ denotes the dynamically computed convolution weights.

This formulation enables adaptive adjustment of sampling positions based on the target’s geometric structure, significantly improving spatial representation capabilities.

Although earlier versions of DCN improved small object detection performance, they suffered from computational inefficiencies and slow inference, particularly on high-resolution feature maps. DCNv4 introduces two key enhancements over DCNv3:

• Dynamic Weight Enhancement—The traditional softmax normalization is removed, allowing the convolution weights $w_k$ to take values in $(-\infty ,+\infty )$ This broader dynamic range improves the expressiveness of the convolution operation.
• Memory Access and Thread Allocation Optimization—DCNv4 reduces redundant memory operations by optimizing access patterns for deformable sampling and introduces an adaptive thread allocation strategy. The number of threads $T$ for parallel computation is determined as

  $$T={\displaystyle \frac{m·G·C}{d_{stride}}}$$

  (12)

  where $m$ is the product of batch size and the number of query points, G is the number of groups, $C$ is the number of channels, and $d_{stride}$ is the stride. This design improves GPU utilization, reduces idle cycles, and increases throughput.

Meanwhile, both the sampling locations and the convolution weights in DCNv4 are dynamically learned through a neural network, enabling the module to better adapt to complex target shapes and feature distributions. The learning process for the offsets can be expressed as

$${∆}_{p_k}=h\left(x\right),m_k=g\left(x\right)$$

(13)

where $h\left(x\right)$ and $g\left(x\right)$ denote the prediction functions for the offsets and the convolution weights, respectively.

These improvements allow DCNv4 to flexibly adapt to the actual morphology and spatial distribution of small objects, delivering significant performance gains in small object detection tasks.

3.4. Small-Object-Enhanced Multi-Scale and Structure Detail Enhancement Module

To address the challenges of blurred edges, insufficient fine-grained details, and high computational cost in UAV-based small object detection, we propose a lightweight edge-aware enhancement module, termed the Small-object-enhanced Multi-scale and Structure Detail Enhancement (SMSDE). As shown in Figure 6, the SMSDE consists of four sequential components: input feature compression, multi-scale edge enhancement, structure-aware feature fusion, and efficient upsampling.

Let $F_m$ denote the intermediate decoder feature and $F_d$ is upsampled detail feature © represents channel concatenation AP denotes average pooling $F_x^e$ is the feature extracted from the x-th layer, $F_x^{ee}$ is the edge-enhanced output of the x-th layer, $\ominus$ denotes element—wise subtraction for edge extraction, and $⨁$ denotes element—wise addition for edge fusion.

(1)

Lightweight input feature compression

To reduce the computational burden of high-resolution feature maps, the SMSDE module first applies a channel compression strategy to the input feature map $I$. By introducing a channel compression factor $\gamma$, the dimensionality is reduced to obtain the low-dimensional initial feature $F_{in}$, formulated as

$$F_{in}=Con{v}_{1\times 1}\left(I,\gamma \right)$$

(14)

where the value of $\gamma$ effectively controls the number of channels, thereby substantially reducing model parameters and computational cost while preserving the effective extraction of critical low-level features.

(2)

Multi-scale Edge Detail Enhancement

To effectively capture and reinforce edge details of small objects, the SMSDE module incorporates a multi-scale edge enhancement mechanism. The input feature map is first processed by average pooling (AP) operations at multiple scales, followed by a residual subtraction strategy to highlight edge responses. Convolutional operations are then applied to produce multi-scale edge-enhanced features $F_{edge}$:

$$F_{edge}=\sum _{i=1}^n{\omega }_i·[Con{v}_{1\times 1}\left(F_i-AP\left(F_i\right)\right)+F_i-AP\left(F_i\right)]$$

(15)

where $F_i$ denotes the pooled feature at the i-th scale ${\omega }_i$ is a learnable adaptive scale weight that satisfies as 1 This design significantly improves the sensitivity to weak edge features and enhances fine-grained detail characterization.

(3)

Feature Fusion and Residual Optimization Strategy

To avoid redundancy from direct feature concatenation SMSDE adopts a two-step fusion and residual connection method. First, the backbone feature $F_{main}$ is concatenated with the enhanced edge feature $F_{edge}$ along the channel dimension followed by $3\times 3$ and $1\times 1$ convolutions to produce the fused feature $F_{fuse}$:

$$F_{fuse}=Con{v}_{1\times 1}\left(Con{v}_{3\times 3}\left(F_{main}\oplus F_{edge}\right)\right)$$

(16)

A residual connection is then applied to stabilize the information flow and enhance fusion effectiveness, producing the final fused feature $F_{out}$:

$$F_{out}=F_{fuse}+\lambda ·F_{main}$$

(17)

where $\lambda$ is a residual balancing coefficient controlling fusion strength.

(4)

Efficient Feature Upsampling Strategy

In the edge reconstruction stage, SMSDE combines bilinear interpolation with lightweight convolution to balance spatial detail recovery and computational efficiency. The high-resolution output feature $F_{up}$ is as follows:

$$F_{up}=\alpha \cdot Bilinear\left(F_{out}\right)+\left(1-\alpha \right)·Con{v}_{3\times 3}\left(F_{out}\right)$$

(18)

where $\alpha$ is a learnable fusion coefficient that adaptively balances the benefits of interpolation and convolution, enabling optimal detail restoration with minimal computational cost.

Through the coordinated design of these four substructures, the SMSDE module enhances detection accuracy and edge structure representation for small objects while reducing parameter count and improving robustness in complex UAV scenarios. Compared with the original MSDE structure, SMSDE adopts a simplified design that reduces redundant operations in edge-detail fusion. This modification decreases the parameter count by nearly one-third while preserving detection accuracy. A detailed comparison with MSDE is reported in Section 4.3.

4. Experimental Results

4.1. Datasets and Experimental Setup

This study evaluates the proposed GLDS-YOLO model on two representative public small object detection datasets: VisDrone2019 [36] and DOTA [37]. VisDrone2019, collected by the AISKYEYE team at Tianjin University, contains 10,209 images captured by various UAV platforms under diverse geographic, lighting, and weather conditions. It is split into 6471 training images, 548 validation images, and 3190 testing images, with annotations for 10 object categories and approximately 2.6 million instances. The dataset presents challenges such as small object sizes, occlusion, overlapping objects, and complex backgrounds.

DOTA (Dataset for Object Detection in Aerial Images) contains 21,046 high-resolution aerial images covering 15 object categories, including aircraft, vehicles, and ships. It is split into training and validation sets with a 3:1 ratio. The dataset’s high annotation quality, diversity, and extensive small object coverage make it ideal for evaluating detection algorithms’ generalization ability in complex multi-scene scenarios.

The experiments were conducted on a Windows 11 system with Python 3.10.15, PyTorch 2.4.0, and CUDA 12.6. Training, validation, and inference were performed on an NVIDIA RTX 6000 GPU (24 GB). The optimizer was stochastic gradient descent (SGD) with momentum 0.937 and weight decay 5 × 10⁻⁴, and a cosine learning rate scheduler with 3 warmup epochs was applied. Automatic mixed precision (AMP) was disabled, and Exponential Moving Average (EMA) was enabled for stability. Data augmentation included Mosaic (1.0), random horizontal flipping (0.5), and HSV color jitter (h = 0.015, s = 0.7, v = 0.4). Focal-EIoU was used for bounding-box regression and binary cross-entropy (BCE) for classification and objectness. Evaluation followed the COCO mAP protocol (mAP@0.5 and mAP@0.5:0.95), with VisDrone2019 results additionally verified using the official server. The key training parameters are summarized in

Table 1. Training hyperparameters of GLDS-YOLO.

Parameter	Value
Epochs	200
Batch size	16
Image size	640 × 640
learning rate	0.01
Optimizer	SGD

.

4.2. Training Process and Convergence Analysis

The convergence behavior of GLDS-YOLO was evaluated by training the model for 200 epochs on the VisDrone2019 dataset (Figure 7). The training and validation loss curves exhibit similar downward trends and converge smoothly without overfitting, indicating good generalization ability. Precision, Recall, and mAP metrics increase steadily and stabilize in the later training stages, which is consistent with the performance reported in the following ablation and comparison experiments.

The evaluation metrics used in this study include Precision (P), Recall (R), and Mean Average Precision (mAP) at two thresholds: mAP@0.5 and mAP@0.5:0.95.

Precision and Recall are computed based on the confusion matrix parameters—True Positives (TP), False Positives (FP), and False Negatives (FN) defined as follows:

• TP: The number of correctly detected targets.
• FP: The number of incorrectly detected targets.
• FN: The number of missed targets.

Precision (P) and Recall (R) are calculated as

$$P={\displaystyle \frac{TP}{TP+FP}},R={\displaystyle \frac{TP}{TP+FN}}$$

(19)

The Average Precision (AP) is obtained by integrating the Precision–Recall (PR) curve, as shown in Equation:

$$AP={\int }_0^{1}P\left(R\right)dR$$

(20)

The Mean Average Precision (mAP) is the mean of the AP values over all classes, defined as

$$mAP={\displaystyle \frac{1}{N}}\sum _{i=1}^{N}A{P}_i$$

(21)

where N denotes the number of object categories in the dataset. Specifically,

• mAP@0.5 represents the average detection precision when the Intersection over Union (IoU) threshold is fixed at 0.5;
• mAP@0.5:0.95 is calculated by averaging AP values over IoU thresholds ranging from 0.5 to 0.95 with a step size of 0.05.

4.3. Ablation Studies

Ablation experiments were conducted to quantify the contributions of each proposed module (GSA, LSKA-SPPF, DCNv4, and SMSDE) to overall performance (

Table 2. Ablation results of GLDS-YOLO on the VisDrone2019 dataset.

Module	P	R	mAP@0.5	mAP@0.5:0.95	Para (M)
YOLOv11n	0.427	0.318	0.315	0.182	2.5
YOLOv11n + GSA	0.452	0.401	0.366	0.206	2.9
YOLOv11n + GSA + LSKA	0.476	0.409	0.394	0.217	3.2
YOLOv11n + GSA + LSKA + DCNv4	0.503	0.417	0.411	0.235	3.5
YOLOv11n + LSKA + DCNv4 + SMSDE	0.521	0.468	0.421	0.238	3.7
YOLOv11n + GSA + LSKA + DCNv4 + SMSDE	0.557	0.421	0.436	0.252	3.9
YOLOv11n + GSA + LSKA + DCNv4 + MSDE	0.546	0.420	0.434	0.251	5.8

). Starting from the baseline YOLOv11n, modules were incrementally added, and results were evaluated on the VisDrone2019 dataset. The results demonstrate that each module individually improves detection accuracy, while their combination achieves the best performance. Furthermore, since SMSDE is redesigned from the original MSDE, we also provide a direct comparison between the two modules under identical settings. This additional comparison demonstrates that SMSDE maintains accuracy while significantly reducing the parameter count, confirming its effectiveness as a lightweight improvement.

In addition to the overall ablation results presented in Table 2, we further report detailed per-scale and per-class performance to better evaluate the effectiveness of the proposed modules.

Table 3. Per-scale results on the VisDrone2019 dataset.

Module	APs	APm	APl	ARs	ARm	ARl
YOLOv11n	0.106	0.271	0.344	0.201	0.447	0.499
Ours	0.194	0.349	0.387	0.295	0.518	0.514

presents results across different object scales (APs, APm, APl and ARs, ARm, ARl), while

Table 4. Per-class AP@0.5 results on the VisDrone2019 dataset.

Model	Pedestrian	People	Car	Van	Truck	Tricycle	Awning-Tricycle	Bus	Motor
YOLOv11n	33.9	26.6	75.2	37.7	26.5	18.6	11.6	43.4	34.7
Ours	51.3	41.7	85.1	50.9	37.9	29.0	17.7	59.6	49.9

summarizes per-class AP values on the VisDrone2019 dataset. These supplementary results demonstrate that GLDS-YOLO achieves particularly notable improvements for small objects, while maintaining competitive performance on medium and large targets.

Overall, the per-scale and per-class results confirm that GLDS-YOLO delivers consistent gains across all categories and scales, with particularly notable improvements on small objects, which are the most challenging in UAV scenarios.

4.4. Comparison with State-of-the-Art Methods

To comprehensively evaluate the detection performance and deployment efficiency of the proposed GLDS-YOLO in small object detection tasks, we conducted systematic comparisons under identical datasets, training parameters, and hardware settings. The comparison includes mainstream small-object detection models such as the YOLO series (YOLOv5S, YOLOv6, YOLOv7-tiny, YOLOv8n), structure-enhanced models (GBS-YOLOv5S, MDH-YOLOv8, PS-YOLOM, YOLOv10, YOLOv10S), end-to-end architectures (RT-DETR), recent lightweight improved models (MASF-YOLO, RemDet series), and the YOLOv11 baseline series (YOLOv11n). Most YOLO-based models were re-trained under the same environment, datasets, and hyperparameter settings as described in Section 4.1, ensuring consistent experimental conditions. The results of the other methods were directly extracted from their original publications [38,39,40,41,42].

All models were evaluated on the VisDrone2019 dataset, and five core metrics were reported: Precision (P), Recall (R), mAP@0.5, mAP@0.5:0.95, and model size (

Table 5. Performance Comparison of Different Algorithms on the VisDrone2019 Dataset.

Module	P/%	R/%	mAP@0.5/%	mAP@0.5:0.95/%	Model Size/MB
GBS-YOLOv5S	49.7	36.8	35.3	20.1	14.5
YOLOv5S	47.3	35.1	34.8	19.1	13.4
YOLOv6	45.2	32.4	30.8	17.8	9.94
YOLOv7-tiny	42.0	30.7	32.8	16.7	12.3
YOLOv8n	50.6	33.2	33.3	19.3	6.3
MDH-YOLOv8	54.9	34.1	37.5	22.7	6.0
YOLOv10	52.8	36.0	31.7	23.3	9.2
RT-DETR	58.7	41.6	45.3	27.5	40
PS-YOLO-M	50.2	38.9	37.6	22.3	7.9
YOLOv10-S	50.5	38.3	39.1	23.5	9.8
MASF-YOLO-n	56.3	40.7	43.2	28.2	13.2
RemDet-Tiny	57.9	39.7	37.1	21.8	12.8
RemDet-M	62.7	37	46.1	28.2	93.2
YOLOv11n	50.3	41.7	31.5	18.2	5.4
GLDS-YOLO	55.7	42.1	43.6	25.2	7.2

). These metrics collectively reflect detection accuracy, robustness, and computational efficiency, enabling a fair and comprehensive performance comparison.

As shown in Table 5, GLDS-YOLO attains mAP@0.5 and mAP@0.5:0.95 of 43.6% and 25.2%, respectively. Relative to RT-DETR (45.3%/27.5%), GLDS-YOLO provides comparable accuracy with a markedly smaller model size (7.2 MB vs. 40 MB; ≈18%). Among models ≤10 MB, it ranks first on both metrics. Compared with MDH-YOLOv8, GLDS-YOLO improves mAP@0.5 by 6.1 pp, precision by 0.8 pp, and recall by 8.0 pp, with a modest size increase (+1.2 MB). Relative to the YOLOv11n baseline, gains are +12.1 pp (mAP@0.5) and +7.0 pp (mAP@0.5:0.95) at +1.8 MB. These results indicate a favorable accuracy–efficiency trade-off within the lightweight regime.

Overall, by integrating GSA, LSKA-SPPF, DCNv4, and SMSDE modules, GLDS-YOLO achieves superior accuracy–efficiency trade-offs. Notably, even in lightweight configurations, its performance approaches or surpasses that of larger models, highlighting its strong applicability to real-time UAV-based small object detection scenarios.

To further verify the generalization capability of the proposed model under different data distributions, we conducted additional evaluations on the DOTA-v1.0 dataset, comparing it with several mainstream detection models. The results are shown in

Table 6. Experimental Results of Different Models on the DOTA-v1.0 Dataset.

Module	mAP50/%	mAP50:95/%
YOLOv8n	60.4	38.1
TPH-YOLO	69.1	44.7
Drone-DETR	67.9	45.2
Oriented R-CNN	75.8	—
GRA	77.6	—
GLDS-YOLO	74.5	49.7

.

As shown in Table 6, GLDS-YOLO achieves 74.5% mAP@0.5 and 49.7% mAP@0.5:0.95 on DOTA-v1.0, outperforming TPH-YOLO, Drone-DETR, and YOLOv8n, and reaching accuracy levels comparable to GRA maintaining high efficiency.

4.5. Visualization Analysis

To further validate the effectiveness of the proposed GLDS-YOLO in real-world small object detection scenarios, representative test images were randomly selected from the VisDrone2019 dataset for visual comparison. These include challenging cases with dense targets, low illumination, and severe occlusion. Detection results are compared with the baseline YOLOv11n, as shown in Figure 8, Figure 9 and Figure 10.

In dense pedestrian scenes (Figure 8), YOLOv11n exhibits notable missed detections, particularly at image edges and in occluded regions. In contrast, GLDS-YOLO successfully detects a greater number of densely distributed pedestrians, improving recall for small targets. This demonstrates the advantages of the GSA and SMSDE modules in enhancing local detail and edge feature representation.

Under low-light night time conditions (Figure 9), where poor illumination and partial occlusions between objects typically degrade detection accuracy, YOLOv11n produces more false negatives and false positives. The proposed GLDS-YOLO accurately identifies multiple small targets (e.g., vehicles) and maintains high responsiveness in low-texture regions, indicating improved adaptability to low-light environments and robustness to occlusion.

The attention heatmaps (Figure 10) further visualize the models’ focus on different regions of the input images. GLDS-YOLO shows more concentrated responses in small-object-dense areas, effectively highlighting semantically relevant regions. This provides additional evidence that the integrated attention mechanism improves both interpretability and detection accuracy.

5. Conclusions

This paper presented GLDS-YOLO, a lightweight detector tailored for UAV-based small object detection. By integrating GSA, LSKA-SPPF, DCNv4, and the optimized SMSDE module, the model enhances perception, context modeling, spatial adaptability, and edge detail representation. Experiments on VisDrone2019 and DOTA demonstrated consistent gains over YOLOv11n and other baselines, particularly for small objects, while maintaining a compact model size suitable for real deployment.

Nevertheless, limitations remain. In complex scenarios with dense occlusion and overlapping objects, missed detections still occur. In addition, current evaluations focus mainly on accuracy and parameter count, whereas broader aspects of deployment efficiency—such as inference latency, memory footprint, and energy consumption—have not yet been systematically examined.

Future work will therefore focus on the following: (1) investigating model robustness under electromagnetic disturbances and image degradations (e.g., noise, blur); (2) extending lightweight evaluation to multiple dimensions, including latency, memory usage, and energy efficiency; and (3) validating real-time performance on embedded GPUs and edge accelerators. These efforts will provide a more comprehensive assessment of deployment efficiency and further enhance the practicality of GLDS-YOLO for UAV applications.