I have focused my research on small object detection in images captured by UAV drones because these platforms have become remarkably important in fields such as disaster response, traffic monitoring, agricultural analysis, cinematography, and infrastructure inspection. UAV drones offer low operating cost, flexible deployment, and the ability to acquire high-resolution images from low altitudes. However, the visual data produced by UAV drones differs substantially from conventional natural images. The viewing angle is often top-down or oblique, objects are frequently occluded by buildings or vegetation, target distributions are uneven, and the most critical issue is that a large proportion of objects are small. These small objects occupy very few pixels, carry limited appearance information, and are easily confused with background clutter or similar categories. Consequently, detection algorithms that perform well on ordinary images often degrade sharply when applied to UAV drone imagery. I therefore investigate improved detection architectures that specifically address the challenges of small objects in UAV drones.
In my work, I build upon the Cascade R-CNN framework and introduce a series of enhancements. The first contribution is a microscale perception and enhancement-location feature pyramid algorithm. The second contribution is a lightweight detector called FasterDet, which reduces computational cost and memory access while preserving competitive accuracy. Throughout this article, I use the term UAV drones frequently because the unique properties of UAV drone imagery motivate every design decision I make. I also present quantitative and qualitative comparisons on public datasets, together with ablation studies that isolate the effect of each component.
Definition and Difficulties of Small Objects
The detection community has not reached a single universal definition of a small object. Two widely accepted perspectives exist: absolute scale and relative scale. Under the absolute-scale definition, which is commonly adopted from the MS COCO benchmark, a small object is one whose resolution is less than \(32 \times 32\) pixels. Under the relative-scale definition, the ratio between the object bounding box area and the image area determines whether an object is small. For example, some datasets define a small object as one whose bounding box area divided by the image area lies between \(0.08\%\) and \(0.58\%\). Other definitions use the square root of the area ratio or the ratio between bounding box width and image width. In my research, I primarily follow the absolute-scale definition because it directly reflects the limited spatial support available for feature extraction in UAV drones.
Small object detection in UAV drones faces several interconnected difficulties. First, available information is scarce. Because a small object covers only a few pixels, its texture, edges, and color cues are weak. Repeated downsampling in deep networks can further reduce the object to a vanishingly small number of pixels, or even erase it from deeper feature maps. Second, localization accuracy is demanding. A one-pixel shift can produce a large relative error for a small object, and manual annotations themselves may contain non-negligible uncertainty. Third, sample imbalance is severe. Anchor-based detectors generate far more negative samples than positive samples, and this imbalance becomes extreme when most objects are small. Fourth, scale variation is large. In UAV drone imagery, the same category may appear at dramatically different scales depending on altitude, camera angle, and distance. Fifth, dense and occluded regions are common. Objects may overlap heavily, and environmental elements such as trees, buildings, and shadows may obscure them. These factors collectively explain why generic detectors struggle on UAV drones.
Deep Learning Foundations for UAV Drone Detection
Deep learning provides the foundation for modern object detection. A convolutional neural network learns hierarchical representations through stacked convolution layers, nonlinear activation functions, pooling operations, and normalization layers. Early layers capture edges and simple textures, while deeper layers capture semantic patterns. For UAV drones, this hierarchy is both an opportunity and a risk: deeper layers provide semantic robustness, but they may discard the fine-grained information needed for small objects. I therefore pay close attention to how features are extracted and fused across scales.
A residual block is a fundamental building block in deep feature extractors. Its general form can be written as
$$y = F(x, \{W_i\}) + x,$$
where \(x\) is the input feature, \(y\) is the output feature, and \(F(x, \{W_i\})\) is a residual mapping. When the input and output dimensions differ, a projection shortcut is used:
$$y = F(x, \{W_i\}) + W_s x.$$
This design alleviates gradient vanishing and allows very deep networks to be trained effectively. In my baseline, I use a residual network as the feature extractor, but I modify its \(3 \times 3\) convolutions to better handle the scale and shape variation found in UAV drones.
For lightweight design, I adopt ideas from GhostNet and partial convolution. A standard convolution can be expensive in both parameters and memory access. Ghost-style modules first generate a small set of intrinsic feature maps using ordinary convolutions, and then produce additional ghost feature maps through cheap linear operations. This reduces computation while preserving representational capacity. The memory access of a standard depthwise separable convolution on a feature map of size \(h \times w\) with \(C\) channels can be expressed as
$$h \times w \times 2C.$$
By contrast, partial convolution applies convolution to only a fraction of channels, for example \(C_p = \frac{1}{4}C\), while keeping the remaining channels unchanged. Its memory access becomes
$$h \times w \times 2C_p.$$
This simple change reduces redundant computation and memory traffic, which is crucial for deploying detection models on resource-constrained UAV drones.
Cascade R-CNN as a Baseline
Cascade R-CNN extends Faster R-CNN by using a sequence of detection heads with increasing Intersection over Union (IoU) thresholds. The IoU between a predicted box \(B_p\) and a ground-truth box \(B_g\) is defined as
$$\mathrm{IoU} = \frac{|B_p \cap B_g|}{|B_p \cup B_g|}.$$
A detector trained with a low IoU threshold tends to produce noisy boxes, while a detector trained with a very high threshold suffers from too few positive samples. Cascade R-CNN addresses this mismatch by cascading three heads with thresholds such as \(0.5\), \(0.6\), and \(0.7\). Each head refines the output of the previous head, so the quality of proposals improves progressively. This architecture is effective for generic object detection, but it does not by itself solve the small-object problem in UAV drones. I therefore introduce additional modules for feature extraction, feature fusion, data augmentation, and loss balancing.
Microscale Perception and Enhancement-Location Feature Pyramid
My first proposed detector targets the high proportion of small objects, large scale variation, high miss rate, high false detection rate, and sample imbalance in UAV drone imagery. The overall pipeline contains Cropmix data augmentation, an improved backbone with microscale perception, an enhancement-location feature pyramid, and a sample balancing strategy inside the cascade heads.
Cropmix Data Augmentation
I design Cropmix to increase the number of small-object training samples without separately feeding cropped patches into the detector at inference time. The input UAV drone image is divided into four quadrants. Each quadrant is then enlarged back to the original image size, which effectively magnifies local details by a factor of four. This operation allows the network to learn richer textures and finer structures from small objects. During cropping, I discard objects whose truncation ratio is below a threshold; in my experiments I use a conservative threshold so that more partially visible objects are retained. I also randomly recombine the four quadrants before enlargement into a new training image. This recombination changes the spatial distribution of targets and encourages the model to perceive small objects more frequently. Cropmix increases data diversity, improves generalization, and mitigates the scarcity of small-object instances in UAV drones.
Microscale Perception Module
The receptive field of a neuron determines how much contextual information it can access. For small objects, an excessively large receptive field may dilute the target with background, while an excessively small receptive field may fail to capture enough context. I therefore propose a microscale perception (MSP) module that adaptively adjusts the receptive field. The MSP module contains two weighted deformable dilated convolution branches and one adjustable switch branch.
Dilated convolution enlarges the receptive field without increasing the number of parameters. Given an original kernel size \(K\) and dilation rate \(D\), the effective kernel size is
$$K_{\mathrm{new}} = K + (K – 1)(D – 1).$$
When \(D=1\), the operation reduces to ordinary convolution. By using different dilation rates, the module can extract features for objects of different scales within the same category. Because UAV drones often capture the same category at very different scales, this property is valuable.
To better fit irregular shapes and dense arrangements, I further use weighted deformable convolution. For a sampling location \(P_0\), the operation can be written as
$$S_{P_0} = \sum_{P_n \in R} W(P_n) \cdot X(P_0 + P_n + \Delta P_n) \cdot \Delta \omega_n,$$
where \(\Delta P_n\) is a learnable offset and \(\Delta \omega_n\) is a learnable weight for each sampling point. Standard convolution samples on a fixed grid, which is suboptimal for small objects that may be partially occluded or irregularly shaped. Weighted deformable convolution allows the sampling grid to shift and assigns different importance to different locations. This improves feature extraction for small, dense, and shape-varying objects in UAV drones.
The MSP module combines two weighted deformable dilated convolution branches with dilation rates \(1\) and \(3\), respectively. The first branch focuses on smaller scales, while the second branch captures larger scales. A switch branch uses global average pooling and a \(1 \times 1\) convolution to produce a probability value \(R \in [0,1]\). The final output is
$$\mathrm{Conv}_{3 \times 3} = R \cdot \mathrm{WDDC}_1 + (1 – R) \cdot \mathrm{WDDC}_2,$$
where \(\mathrm{WDDC}_1\) and \(\mathrm{WDDC}_2\) are the outputs of the two weighted deformable dilated convolution branches. The network learns to select the appropriate receptive field for different objects. I replace the \(3 \times 3\) convolutions in the backbone with MSP modules, and I use a weight-locking mechanism so that pretrained weights can be reused without full retraining. This design substantially improves feature extraction for small objects in UAV drones.
Enhancement-Location Feature Pyramid
Feature pyramid networks (FPNs) fuse adjacent layers through top-down pathways and lateral connections. Although FPNs are effective for generic multi-scale detection, they are not always ideal for UAV drones because small objects are often assigned to high-resolution low-level feature maps. The semantic gap between non-adjacent layers may cause small-object information to be gradually overwhelmed. Moreover, bottom-up localization information is not fully exploited.
I propose the enhancement-location feature pyramid (E-LFPN). Given multi-level features \([P_2, P_3, P_4, P_5]\), I first resize all levels to the same spatial size as \(P_3\). Max pooling reduces the size of \(P_2\):
$$Y(i,j) = \max_{a=0}^{k-1} \max_{b=0}^{k-1} P_2(i+a, j+b).$$
Bilinear interpolation enlarges \(P_4\) and \(P_5\). For a target coordinate \((x,y)\), the interpolated value is
$$P(x,y) = \frac{1}{(x_2-x_1)(y_2-y_1)} \left[ Q_{11}(x_2-x)(y_2-y) + Q_{21}(x-x_1)(y_2-y) + Q_{12}(x_2-x)(y-y_1) + Q_{22}(x-x_1)(y-y_1) \right].$$
After resizing, I aggregate the features to obtain a balanced semantic representation:
$$P_{\mathrm{avg}} = \frac{1}{N} \sum_{n=1}^{N} P_n.$$
The aggregated feature is then refined using an embedded Gaussian attention-like operation:
$$y = \frac{1}{C(x)} \sum_{m,n} \left( e^{W_\alpha x_m^T} \cdot e^{W_\beta x_n} \right) W_g x_n.$$
This refinement highlights informative regions and suppresses noise. I then resize the refined feature back to each original level and add it to the original feature through a residual connection, producing \([F_2, F_3, F_4, F_5]\). Finally, I add a bottom-up localization branch. \(L_2\) is copied from \(F_2\). Each subsequent level \(L_i\) is obtained by downsampling the previous level with a \(3 \times 3\) convolution of stride 2 and fusing it with \(F_{i+1}\). This bottom-up path strengthens the localization ability for small objects in UAV drones.
Loss Function and Sampling Strategy
Anchor-based detectors suffer from foreground-background imbalance. In UAV drones, this problem is aggravated because most objects are small and the number of background anchors is enormous. I replace the standard cross-entropy classification loss with Focal Loss:
$$\mathrm{FL} = -\alpha_t (1 – P_t)^\gamma \log(P_t),$$
where \(P_t\) is the predicted probability for the target class, \(\alpha_t\) balances positive and negative samples, and \(\gamma\) modulates the contribution of easy samples. When \(\gamma=0\), Focal Loss reduces to ordinary cross-entropy. In my experiments, I use \(\gamma=2\) and \(\alpha=0.25\) unless stated otherwise.
To address the long-tail distribution across categories, I also adopt a class-wise sample extraction control method. During training, I attempt to draw a balanced number of samples from each category. If a category has fewer samples than the average, I select additional positive samples with high confidence from the remaining pool. This strategy improves detection accuracy for rare categories and mitigates inter-class imbalance in UAV drones.
Experiments on VisDrone2019 and UAVDT
I evaluate the proposed method on two public datasets: VisDrone2019 and UAVDT. VisDrone2019 contains 10,209 high-resolution images with more than 380k annotated instances across 10 detection categories. Approximately 89% of the objects are small according to the \(32 \times 32\) definition. UAVDT contains 23,258 training images and 15,069 test images with categories including car, truck, and bus. I use mean Average Precision (mAP), mAP50, and mAP75 as evaluation metrics. All models are trained with SGD for 24 epochs, with an initial learning rate of 0.05, momentum 0.9, and weight decay 0.0001. The input size is \(1200 \times 800\).
| Method | Source | mAP | mAP50 | mAP75 |
|---|---|---|---|---|
| Cascade R-CNN + NWD | arXiv | 0.250 | 0.434 | 0.252 |
| EdgeYOLO | arXiv | 0.264 | 0.448 | 0.262 |
| ClusDet | ICCV | 0.267 | 0.506 | 0.244 |
| QueryDet | CVPR | 0.283 | 0.481 | 0.288 |
| CEASC | CVPR | 0.287 | 0.507 | 0.284 |
| GLSAN | TIP | 0.307 | 0.554 | 0.300 |
| CZDet | CVPR | 0.322 | 0.583 | 0.262 |
| CRENet | ECCVW | 0.334 | 0.543 | 0.335 |
| My first method | — | 0.359 | 0.585 | 0.376 |
On VisDrone2019, my method achieves 0.359 mAP, 0.585 mAP50, and 0.376 mAP75. Compared with the Cascade R-CNN baseline using normalized Gaussian Wasserstein distance, the gains are 0.109, 0.151, and 0.124, respectively. Compared with coarse-to-fine detectors such as ClusDet, GLSAN, CZDet, and CRENet, my method improves mAP by 2.5% to 9.2%, mAP50 by 4.2% to 13.7%, and mAP75 by 4.1% to 13.2%. Compared with EdgeYOLO, QueryDet, and CEASC, the improvements are also substantial. These results confirm that the combination of Cropmix, MSP, E-LFPN, and the sample balancing strategy is effective for small object detection in UAV drones.
| Method | Source | mAP | mAP50 | mAP75 |
|---|---|---|---|---|
| Baseline | CVPR | 0.103 | 0.231 | 0.094 |
| ClusDet | ICCV | 0.137 | 0.265 | 0.125 |
| CEASC | CVPR | 0.171 | 0.309 | 0.178 |
| GLSAN | TIP | 0.197 | 0.305 | 0.217 |
| My first method | — | 0.206 | 0.312 | 0.209 |
On UAVDT, my method improves mAP, mAP50, and mAP75 by 10.3%, 8.1%, and 11.5% over the Cascade R-CNN baseline. It also outperforms ClusDet, CEASC, and GLSAN. These quantitative results demonstrate that the proposed design generalizes across different UAV drone datasets.
| Method | mAP | car | pedestrian | tricycle | motor | people | van | bus | bicycle | awning-tricycle | truck |
|---|---|---|---|---|---|---|---|---|---|---|---|
| RetinaNet | 0.159 | 0.458 | 0.124 | 0.083 | 0.106 | 0.050 | 0.243 | 0.281 | 0.034 | 0.043 | 0.171 |
| FCOS | 0.175 | 0.487 | 0.166 | 0.094 | 0.090 | 0.073 | 0.258 | 0.312 | 0.037 | 0.046 | 0.190 |
| ATSS | 0.204 | 0.513 | 0.183 | 0.141 | 0.161 | 0.060 | 0.296 | 0.319 | 0.078 | 0.073 | 0.212 |
| Faster R-CNN | 0.211 | 0.496 | 0.181 | 0.143 | 0.176 | 0.109 | 0.300 | 0.326 | 0.079 | 0.073 | 0.223 |
| Cascade R-CNN | 0.217 | 0.509 | 0.182 | 0.149 | 0.171 | 0.101 | 0.311 | 0.364 | 0.077 | 0.072 | 0.238 |
| DHRCNN | 0.224 | 0.510 | 0.190 | 0.161 | 0.185 | 0.124 | 0.311 | 0.363 | 0.089 | 0.068 | 0.239 |
| My first method | 0.359 | 0.609 | 0.302 | 0.310 | 0.326 | 0.217 | 0.448 | 0.573 | 0.223 | 0.188 | 0.399 |
The per-category results show that my method consistently improves small-object categories such as pedestrian, people, motor, and bicycle, while also maintaining strong performance on larger categories such as car, bus, and truck. This balance is important for practical UAV drone applications, where both small and large objects may appear simultaneously.
Ablation Studies for the First Method
| Component | Baseline | +SBS | +Cropmix | +MSP | +E-LFPN | +SBS+Cropmix | +SBS+Cropmix+MSP | All |
|---|---|---|---|---|---|---|---|---|
| SBS | √ | √ | √ | √ | √ | √ | √ | |
| Cropmix | √ | √ | √ | √ | √ | √ | ||
| MSP | √ | √ | √ | |||||
| E-LFPN | √ | √ | ||||||
| mAP | 0.217 | 0.227 | 0.236 | 0.244 | 0.280 | 0.326 | 0.334 | 0.359 |
Each component contributes positively. Cropmix produces the largest single gain, which confirms that changing the object distribution and increasing small-object samples is highly effective for UAV drones. When SBS and Cropmix are combined, adding MSP or E-LFPN further improves mAP. Using all components yields 0.359 mAP, a gain of 0.142 over the baseline.
| Stage usage | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Stages 1–4 | 0.240 | 0.422 | 0.240 |
| Stages 2–4 | 0.244 | 0.429 | 0.246 |
| Stages 3–4 | 0.229 | 0.407 | 0.225 |
| Stages 2–4 without WDDC | 0.234 | 0.411 | 0.233 |
For MSP, replacing \(3 \times 3\) convolutions in stages 2–4 gives the best result. Using all four stages does not help further because stage 1 is frozen during training, so the switch parameter cannot be learned effectively. Removing weighted deformable convolution reduces mAP to 0.234, which demonstrates the importance of shape-adaptive sampling for dense and irregular small objects in UAV drones.
| Component | mAP | mAP50 | mAP75 |
|---|---|---|---|
| E-LFPN | 0.236 | 0.411 | 0.240 |
| FPN | 0.217 | 0.377 | 0.220 |
| Without location branch | 0.233 | 0.407 | 0.234 |
| Without enhancement branch | 0.231 | 0.403 | 0.233 |
For E-LFPN, removing either the enhancement branch or the localization branch degrades performance, and removing both reduces the model to the original FPN. The full E-LFPN improves mAP by 1.9% over FPN, confirming that both balanced semantic aggregation and bottom-up localization are useful for small objects in UAV drones.
| Augmentation | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Crop | 0.272 | 0.447 | 0.283 |
| Mix | 0.239 | 0.406 | 0.243 |
| Cutmix | 0.263 | 0.422 | 0.281 |
| Cropmix | 0.280 | 0.459 | 0.292 |
Cropmix achieves the best result among the augmentation strategies. Cropping and enlarging back to the original size provides the largest gain, while recombination further improves robustness to object distribution changes. Compared with Cutmix, Cropmix is better suited to dense small objects in UAV drones.
| Method | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Cascade R-CNN | 0.217 | 0.377 | 0.220 |
| Cascade R-CNN + SBS | 0.224 | 0.386 | 0.227 |
| Cropmix | 0.280 | 0.459 | 0.292 |
| Cropmix + SBS | 0.300 | 0.484 | 0.320 |
| MSP | 0.244 | 0.429 | 0.246 |
| MSP + SBS | 0.254 | 0.438 | 0.256 |
| E-LFPN | 0.236 | 0.410 | 0.240 |
| E-LFPN + SBS | 0.252 | 0.434 | 0.257 |
The sample balancing strategy improves every module. It is especially effective when combined with Cropmix, where mAP rises from 0.280 to 0.300. This confirms that Focal Loss and class-wise sample extraction help the model focus on difficult and rare samples, which are common in UAV drone datasets.
| Model | GFLOPs | Params |
|---|---|---|
| Cascade R-CNN | 224.85 | 68.95M |
| My first method | 174.31 | 87.63M |
The first method reduces GFLOPs but increases parameters. This trade-off motivates the lightweight design in the second method.
Visual Analysis of the First Method
I visualize backbone features extracted by MSP and compare them with the baseline backbone. The MSP features show clearer object textures and better separation of individual objects in dense regions. This indicates that microscale perception helps the network focus on small objects rather than background clutter. I also visualize E-LFPN features. Compared with the original FPN, E-LFPN preserves more target details in lower-level feature maps, suppresses background noise in higher-level maps, and produces stronger responses on small objects. These observations support the quantitative gains on VisDrone2019 and UAVDT.
FasterDet: A Lightweight Detector for UAV Drones
Although the first method improves accuracy, it increases computation and parameter count, which is problematic for deployment on UAV drones with limited onboard resources. I therefore design FasterDet, a lightweight detector that maintains competitive accuracy while improving speed and reducing model size. FasterDet uses Cropmix, a Faster GhostNet backbone, a progressive feature pyramid, and VariFocal Loss with a sample balancing strategy.
Faster GhostNet
Faster GhostNet is built from Faster Ghost modules and Faster Ghost bottlenecks. A Faster Ghost module first applies a small set of \(1 \times 1\) convolutions to generate intrinsic feature maps. It then applies partial convolution to a fraction of channels, followed by point-wise convolutions with batch normalization and ReLU, to produce ghost feature maps. The final output concatenates the intrinsic and ghost features. Compared with depthwise separable convolution, partial convolution reduces memory access from
$$h \times w \times 2C$$
to
$$h \times w \times 2C_p,$$
where \(C_p = \frac{1}{4}C\). This reduces redundant computation and memory traffic.
The Faster Ghost bottleneck has two variants. The stride-1 variant contains two Faster Ghost modules in series and a residual connection. The stride-2 variant inserts a stride-2 partial convolution between the two Faster Ghost modules to halve the spatial resolution. Stacking these bottlenecks yields a lightweight backbone that outputs feature maps with channel dimensions \([24, 40, 80, 160]\). This backbone is well suited to UAV drones because it reduces parameters and latency while retaining sufficient representational power for small objects.
Progressive Feature Pyramid
The progressive feature pyramid, also called CascadeFusionFPN, fuses non-adjacent levels gradually to reduce semantic gaps and prevent information loss during multi-level propagation. It uses Space-to-Depth (S2D) for parameter-free downsampling. Given a feature map of height \(h\), width \(w\), and channels \(c\), S2D rearranges spatial blocks into the channel dimension, producing an output of size \(h/N \times w/N \times cN\). This operation avoids losing information through pooling and introduces no extra parameters.
I denote the backbone features as \([C_1, C_2, C_3, C_4]\). For each new level, I resize all existing features to the target size using S2D downsampling or bilinear upsampling, followed by a \(1 \times 1\) convolution to align channel dimensions. Features are fused using fast normalized fusion:
$$C_{\mathrm{new}} = \frac{\omega_i \cdot C_i + \omega_{i-1} \cdot C_{i-1}}{\omega_i + \omega_{i-1} + \alpha},$$
where \(\omega_i\) and \(\omega_{i-1}\) are learnable weights constrained to be positive, and \(\alpha = 0.0001\) is a small constant for numerical stability. This fusion is faster than softmax-based attention on GPU and avoids the information loss of simple concatenation or summation. The progressive fusion produces \([F_1, F_2, F_3, F_4]\). Because non-adjacent layers are brought closer step by step, small-object features are better preserved in UAV drones.
VariFocal Loss
VariFocal Loss adjusts the contribution of positive and negative samples more flexibly than Focal Loss. Its formulation is
$$\mathrm{VariFL} =
\begin{cases}
-n \left( n \log(m) + (1-n) \log(1-m) \right), & n > 0, \\
-\alpha m^\gamma \log(1-m), & n = 0,
\end{cases}$$
where \(m\) is the predicted class score and \(n\) is the IoU between the predicted box and the ground truth for positive samples. For positive samples, \(n\) weights the loss so that high-quality samples contribute more. For negative samples, the loss follows the Focal Loss principle and down-weights easy negatives. This reduces missed detections, especially for small and dense objects in UAV drones. In my experiments, I use \(\gamma=2\) and \(\alpha=0.75\).
Experimental Results for FasterDet
| Model | FPS (img/s) | GFLOPs | Params (M) |
|---|---|---|---|
| Cascade R-CNN | 9.5 | 224.85 | 68.95 |
| My first method | 2.2 | 174.31 | 87.63 |
| FasterDet | 5.4 | 202.87 | 71.43 |
FasterDet improves speed from 2.2 to 5.4 img/s compared with the first method, while reducing parameters from 87.63M to 71.43M. The GFLOPs increase slightly compared with the first method but remain lower than the original Cascade R-CNN baseline. This balance is important for real-time or near-real-time UAV drone applications.
| Method | Source | mAP | mAP50 | mAP75 |
|---|---|---|---|---|
| Cascade R-CNN + NWD | arXiv | 0.250 | 0.434 | 0.252 |
| EdgeYOLO | arXiv | 0.264 | 0.448 | 0.262 |
| ClusDet | ICCV | 0.267 | 0.506 | 0.244 |
| QueryDet | CVPR | 0.283 | 0.481 | 0.288 |
| CEASC | CVPR | 0.287 | 0.507 | 0.284 |
| GLSAN | TIP | 0.307 | 0.554 | 0.300 |
| CZDet | CVPR | 0.322 | 0.583 | 0.262 |
| CRENet | ECCVW | 0.334 | 0.543 | 0.335 |
| FasterDet | — | 0.347 | 0.562 | 0.351 |
| My first method | — | 0.359 | 0.585 | 0.376 |
FasterDet achieves 0.347 mAP, 0.562 mAP50, and 0.351 mAP75. The accuracy is slightly lower than the first method, but it remains competitive with state-of-the-art detectors. It ranks second in mAP50 and outperforms several advanced methods in mAP and mAP75. This demonstrates that the lightweight design does not sacrifice too much accuracy for UAV drones.
Ablation Studies for FasterDet
| Component | Baseline | +Faster GhostNet | +CascadeFusionFPN | +VariFocal Loss | +Faster GhostNet+CascadeFusionFPN | All |
|---|---|---|---|---|---|---|
| Faster GhostNet | √ | √ | √ | |||
| CascadeFusionFPN | √ | √ | √ | |||
| VariFocal Loss | √ | √ | ||||
| mAP | 0.280 | 0.305 | 0.314 | 0.329 | 0.335 | 0.347 |
Each component improves mAP individually. Faster GhostNet improves mAP while reducing parameters. CascadeFusionFPN improves multi-scale fusion and preserves small-object information. VariFocal Loss improves the balance between positive and negative samples and reduces missed detections. The combination of all three yields the best result.
| Backbone | FPS (img/s) | GFLOPs | Params (M) |
|---|---|---|---|
| ResNet50 + MSP | 3.0 | 150.52 | 83.82 |
| Faster GhostNet | 6.4 | 173.31 | 63.86 |
Faster GhostNet nearly doubles the frame rate compared with ResNet50 + MSP, while reducing parameters by nearly 24%. This makes it much more suitable for UAV drones with limited hardware resources.
| Fusion method | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Concat | 0.342 | 0.558 | 0.343 |
| Sum | 0.338 | 0.551 | 0.336 |
| Fast normalized fusion | 0.347 | 0.562 | 0.351 |
Fast normalized fusion outperforms simple concatenation and summation. It assigns learnable weights to different levels, which better preserves useful information for small objects in UAV drones.
Visual Analysis of FasterDet
I visualize features from the original FPN, E-LFPN, and CascadeFusionFPN. The original FPN loses a large amount of object information as the level increases, which is harmful for small objects. E-LFPN preserves more target information and suppresses background noise. CascadeFusionFPN further improves the clarity of individual objects in dense regions. In crowded areas, CascadeFusionFPN produces more separated and cleaner object responses than E-LFPN. This supports the use of progressive fusion for lightweight detection in UAV drones.
Comparison and Practical Implications
The two methods I propose address complementary needs. The first method prioritizes accuracy and uses microscale perception, enhancement-location feature pyramid, Cropmix, and sample balancing to achieve strong performance on small objects in UAV drones. The second method prioritizes efficiency and uses Faster GhostNet, progressive feature fusion, and VariFocal Loss to reduce parameters and improve speed. In practical UAV drone deployment, the choice depends on the hardware budget and latency requirements. When accuracy is the primary concern, the first method is preferable. When onboard computation is limited, FasterDet provides a better trade-off.
| Method | Key modules | Main advantage | Suitable scenario |
|---|---|---|---|
| My first method | MSP, E-LFPN, Cropmix, Focal Loss + sampling | High accuracy for small objects | Offline or high-performance UAV drones |
| FasterDet | Faster GhostNet, CascadeFusionFPN, VariFocal Loss | High speed and low parameters | Real-time or edge UAV drones |
Across both methods, I consistently observe that data augmentation, feature fusion, and loss balancing are essential for small object detection in UAV drones. Cropmix changes the training distribution so that small objects are seen more often. MSP and Faster GhostNet improve feature extraction under scale and shape variation. E-LFPN and CascadeFusionFPN preserve small-object information across layers. Focal Loss and VariFocal Loss reduce the dominance of easy negatives and improve learning from difficult and rare samples. Together, these components form a coherent framework for UAV drone imagery.
Future Work
Although my methods improve accuracy and efficiency, several directions remain open. First, inference speed and model size can still be reduced. Future work could explore more aggressive pruning, quantization, neural architecture search, and hardware-aware optimization for UAV drones. Second, robustness under extreme conditions such as strong glare, fog, rain, and low light needs further study. Data augmentation and domain adaptation may help. Third, annotation quality and cost remain challenging. Weakly supervised, semi-supervised, and self-supervised learning could reduce reliance on large manually labeled datasets. Fourth, multi-modal sensing, such as combining RGB with thermal or depth information, may further improve small-object detection in UAV drones. Fifth, temporal information from video could be exploited to track small objects and reduce missed detections. These directions are promising for making UAV drone detection more reliable in real-world missions.
Conclusion
I have presented a comprehensive study of small object detection in UAV drone imagery. I first analyzed the unique difficulties of UAV drones, including high small-object proportion, large scale variation, occlusion, dense distribution, and sample imbalance. I then proposed a high-accuracy method based on microscale perception and an enhancement-location feature pyramid, combined with Cropmix data augmentation and a sample balancing strategy. I also proposed FasterDet, a lightweight detector based on Faster GhostNet, progressive feature pyramid fusion, and VariFocal Loss. Extensive experiments on VisDrone2019 and UAVDT demonstrate that both methods are effective. The first method achieves strong accuracy, while FasterDet achieves a better balance between speed and accuracy. These results provide new perspectives for optimizing small object detection in UAV drones and support the practical deployment of detection algorithms on aerial platforms.