I begin this study from a practical observation: the UAV drone has become a remarkably flexible platform for acquiring high-resolution imagery from low and medium altitudes, and it is now widely used in disaster response, traffic monitoring, agricultural inspection, power-line surveillance, cinematography, and many other tasks. Compared with satellites and manned aircraft, a UAV drone can be deployed quickly, costs less to operate, and can enter dangerous or remote regions without putting human pilots at risk. In my work, I focus on the fact that these advantages come with a very specific computer-vision problem: images captured by a UAV drone are usually top-down or oblique, contain wide viewing angles, include many occluded and densely packed instances, and, most importantly, are dominated by small objects. This combination makes generic detection models perform far below their performance on natural images.
I approach the task as a cascade-based detection problem. The baseline I use is Cascade RCNN, because its multi-stage head design gradually improves localization quality by raising the intersection-over-union threshold from one stage to the next. However, I find that a plain Cascade RCNN still struggles with the high proportion of small instances, large scale variation, class imbalance, and long-tail category distribution that appear in UAV drone imagery. Therefore, I design a first method based on microscale perception and an enhancement-location feature pyramid, and then I design a second, lighter method called FasterDet to improve speed and reduce parameter cost while preserving competitive accuracy. Throughout this article, I use first-person notation to describe my motivations, designs, experiments, and conclusions.
Problem setting. In my experiments, a UAV drone image can contain thousands of instances. Many of them occupy fewer than \(32 \times 32\) pixels, which is the common absolute definition of a small object. Others are larger vehicles or pedestrians, so the same image may contain objects whose scales differ by more than an order of magnitude. I observe missed detections in distant regions, false detections in cluttered backgrounds, and unstable classification between visually similar categories such as bicycle and motorcycle or van and car. These failures are not isolated; they are caused by the combined effect of limited appearance information, spatial occlusion, class imbalance, and the downsampling operations inside deep networks.
Small-object definitions. I summarize the two common ways to define a small object in Table 1. The absolute definition is easier to apply across datasets, while the relative definition is useful when the image size itself varies strongly. In my UAV drone work, I mainly follow the absolute \(32 \times 32\) convention, but I also monitor relative area ratios because UAV drone images often have very high resolution.
| Definition type | Typical criterion | Interpretation for UAV drone imagery |
|---|---|---|
| Absolute scale | Object resolution smaller than \(32 \times 32\) pixels | Most pedestrian, bicycle, motorcycle, and distant car instances in UAV drone images fall into this range. |
| Relative scale | Object area divided by image area within a very small interval, often \(0.08\%\) to \(0.58\%\) | Useful when the UAV drone image is extremely large and the object occupies only a tiny fraction of the frame. |
| Width-height ratio | Object width or height divided by image width or height below a threshold such as \(0.1\) | Helpful for dense traffic and crowd scenes captured from a high altitude. |
Why UAV drone small-object detection is difficult. I identify four central difficulties. First, small objects provide very little appearance information. After repeated convolution and pooling, their features can become indistinguishable from background noise. Second, localization is sensitive: a shift of a few pixels can change the intersection-over-union dramatically, which harms both training and inference. Third, the foreground-background distribution is highly imbalanced because most anchor boxes or region proposals correspond to background. Fourth, the category distribution often follows a long-tail pattern: a few classes such as car appear extremely often, while classes such as awning tricycle appear rarely. These problems are amplified in UAV drone imagery because of top-down viewpoints, dense clustering, and large-scale variation.
I also note that a UAV drone image is not simply a smaller version of a natural image. In natural images, an object may be partially hidden by another object, but in UAV drone images, objects are often partially hidden by trees, roofs, shadows, and street infrastructure. In natural images, a person or car can occupy a large portion of the frame, while in UAV drone images, the same category may be only a few pixels wide. Therefore, I treat the design of the feature extractor, the neck, the loss function, and the sampling strategy as tightly coupled decisions rather than independent modifications.
Deep learning foundations. I use convolutional neural networks as the basic representation learner. A convolution layer applies a set of learnable filters to an input tensor, producing feature maps that encode local patterns. A residual block allows a network to learn an identity mapping through a shortcut connection. I write the basic residual form as
$$y = F(x,\{W_i\}) + x,$$
and when the input and output dimensions differ, I use a projection shortcut:
$$y = F(x,\{W_i\}) + W_s x.$$
I also rely on batch normalization and ReLU activation because they stabilize training and improve gradient flow. For detection, I compare one-stage and two-stage paradigms. My baseline belongs to the two-stage family, but I also compare against one-stage detectors in my experiments because they are often faster and can be attractive for UAV drone deployment.
| Paradigm | Representative behavior | Strength | Weakness for UAV drone small objects |
|---|---|---|---|
| Two-stage | Generate region proposals, then classify and regress each region | Strong localization and high-quality refinement | Heavier computation and slower inference |
| One-stage | Predict categories and boxes directly on dense feature maps | Fast and simple end-to-end inference | Small objects may be overwhelmed by background anchors |
| Cascade two-stage | Use multiple heads with increasing IoU thresholds | Progressive localization and better sample quality | Still depends on backbone and neck quality |
Loss functions. I use several loss formulations in my analysis. For binary classification, the cross-entropy loss is
$$CE = -\frac{1}{n}\sum_{i=1}^{n}\left[y_i\log a_i + (1-y_i)\log(1-a_i)\right].$$
For multi-class classification, I use
$$CE = -\frac{1}{N}\sum_{i=1}^{N}\sum_{c=1}^{C} y_{i,c}\log a_{i,c}.$$
For bounding-box regression, I compare mean squared error and mean absolute error:
$$MSE = \frac{1}{N}\sum_{i=1}^{N}(y_i-a_i)^2,$$
$$MAE = \frac{1}{N}\sum_{i=1}^{N}|y_i-a_i|.$$
However, I find that plain cross-entropy is not enough for UAV drone small-object detection because easy background samples dominate the gradient. Therefore, I introduce focal loss and later VariFocal loss. The focal loss is
$$FL = -\alpha_t(1-P_t)^\gamma \log(P_t),$$
where \(P_t\) is the predicted probability of the target class, \(\alpha_t\) balances positive and negative samples, and \(\gamma\) controls the emphasis on hard examples. I use this loss to reduce the contribution of easy negatives and to make the detector concentrate on ambiguous small objects.
Data augmentation. I use data augmentation as a low-cost way to change the object-size distribution without changing the network architecture. Traditional operations such as rotation, translation, scaling, flipping, and color jitter are useful, but they do not fundamentally solve the shortage of small-object training samples. I therefore design a Cropmix strategy. I split an input UAV drone image into four quadrants, enlarge each quadrant back to the original image size, and randomly recombine the enlarged quadrants. When an object is truncated, I keep it if the truncation ratio is below a threshold; otherwise I discard it. This procedure increases the number of small instances, exposes the model to more truncated objects, and makes the training distribution more favorable to small-object learning.
Baseline cascade design. I choose Cascade RCNN because a single detector trained with a fixed IoU threshold often performs poorly when the input proposal quality changes between training and inference. Cascade RCNN uses multiple heads with thresholds such as \(0.5\), \(0.6\), and \(0.7\). Each head receives the refined boxes from the previous head, so the localization quality improves progressively. I summarize the baseline stages in Table 3.
| Stage | Input | IoU threshold | Role |
|---|---|---|---|
| Head 1 | Proposals from the region proposal network | 0.5 | Initial classification and coarse box refinement |
| Head 2 | Refined boxes from Head 1 | 0.6 | Improved localization and reduced false positives |
| Head 3 | Refined boxes from Head 2 | 0.7 | High-quality final detection output |
I define the intersection-over-union between a predicted box \(B_p\) and a ground-truth box \(B_g\) as
$$IoU = \frac{|B_p \cap B_g|}{|B_p \cup B_g|}.$$
I use this quantity to assign positive and negative samples, to measure localization quality, and to control the cascade thresholds. In my UAV drone experiments, I observe that cascade refinement helps, but it does not by itself solve the small-object problem. The backbone must extract more discriminative features, and the neck must preserve small-object information across scales.
My first proposed method: microscale perception and enhancement-location feature pyramid. I design a method with four coordinated parts. The first part is Cropmix data augmentation. The second part is a microscale perception module, which I abbreviate as MSP. The third part is an enhancement-location feature pyramid, which I abbreviate as E-LFPN. The fourth part is a sample-balance training strategy that combines focal loss with category-aware sample extraction. I summarize the modules in Table 4.
| Module | Purpose | Main mechanism |
|---|---|---|
| Cropmix | Increase small-object samples and change training distribution | Quadrant split, enlargement, random recombination |
| MSP | Adapt receptive field to object scale and shape | Two weighted deformable dilated convolution branches plus a learnable switch |
| E-LFPN | Preserve and enhance multi-scale small-object features | Feature aggregation, refinement, residual enhancement, and bottom-up localization |
| Sample balance | Reduce hard-easy and inter-class imbalance | Focal loss plus category-aware sample extraction |
Microscale perception. I design MSP because standard \(3 \times 3\) convolution has a fixed receptive field, while a UAV drone image contains objects of many scales and shapes. Dilated convolution enlarges the receptive field without increasing the number of parameters. For a kernel size \(K\) and dilation rate \(D\), the effective kernel size is
$$K_{new} = K + (K-1)(D-1).$$
I use two branches with different dilation rates. One branch has \(D=1\), which behaves like a standard weighted deformable convolution and focuses on smaller instances. The other has \(D=3\), which provides a wider receptive field and captures larger instances or surrounding context. Both branches use weighted deformable convolution. I write the weighted deformable convolution as
$$Sample_{P_0} = \sum_{P_n \in R} W(P_n) X(P_0 + P_n + \Delta P_n)\Delta \omega_n,$$
where \(\Delta P_n\) is a learnable offset and \(\Delta \omega_n\) is a learnable weight for each sampled location. The offsets allow the sampling grid to adapt to object shape, while the weights reduce the impact of noisy background locations. The third branch is a learnable switch. It uses global average pooling, a \(1 \times 1\) convolution, and a probability-like gate \(R\) to combine the two convolution branches:
$$Conv_{3\times 3} = R \cdot WDDC + (1-R)\cdot WDDC.$$
I replace the original \(3 \times 3\) convolutions in the backbone with MSP modules. In my implementation, the best configuration uses MSP from Stage 2 to Stage 4 of ResNet-50. I keep the first stage frozen, because its features are too low-level and because the switch parameter cannot be well learned when the stage is frozen. I also use a weight-locking mechanism so that I can reuse pretrained weights without retraining the whole backbone from scratch.
Enhancement-location feature pyramid. I design E-LFPN because a standard feature pyramid network fuses adjacent levels but may still lose small-object information. In a UAV drone image, small objects are often assigned to high-resolution low-level feature maps, while semantic information is concentrated in low-resolution high-level maps. A naive top-down fusion can let high-level semantics dominate and can suppress the weak responses of small objects. My E-LFPN has three parts: an enhancement branch, a location branch, and the original pyramid levels. I first align the levels \(P_2,P_3,P_4,P_5\) to the same spatial size. I use max pooling to reduce \(P_2\), and bilinear interpolation to enlarge \(P_4\) and \(P_5\). The max-pooling operation is
$$Y(i,j) = \max_{a=0}^{k-1}\max_{b=0}^{k-1} P_2(i+a,j+b).$$
Bilinear interpolation for a target location \((x,y)\) 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 alignment, I aggregate the levels to obtain balanced semantic information:
$$P_{avg} = \frac{1}{N}\sum_{n=1}^{N} P_n.$$
I then refine the aggregated feature with a non-local-style attention operation. For an input \(x\), the refined output \(y\) is
$$y = \frac{1}{C(x)}\sum\left(e^{W_\alpha x_m^T}e^{W_\beta x_n}\right)W_g x_n,$$
where \(m\) is the output position, \(n\) indexes all positions used for interaction, \(C(x)\) is a normalization factor, and \(W_\alpha\), \(W_\beta\), and \(W_g\) are learnable weights. This refinement highlights informative regions and suppresses background noise. I then resize the refined features back to the original pyramid sizes and add them to the original levels through residual connections. This step preserves the original small-object information while enhancing it. Finally, I add a bottom-up location branch: I copy \(F_2\) to \(L_2\), then repeatedly downsample with a \(3 \times 3\) convolution of stride 2, fuse with the next level, and continue up to \(L_5\). The bottom-up path allows low-level localization cues to flow upward, which improves the localization of tiny objects.
Sample balance. I use focal loss to handle hard-easy imbalance and a category-aware sample extraction method to handle the long-tail distribution. In my training procedure, I attempt to draw a balanced number of samples per category. If a category has fewer instances than the average, I select additional high-confidence positive samples from the remaining pool. This strategy reduces the dominance of frequent classes such as car and gives rare classes such as awning tricycle a better chance to contribute to the gradient. I present the loss and sampling combination in Table 5.
| Problem | Standard approach | My approach | Expected effect |
|---|---|---|---|
| Easy negative dominance | Cross-entropy | Focal loss with \(\gamma=2\), \(\alpha=0.25\) | Focus on hard examples |
| Long-tail class distribution | Random sampling | Category-aware sample extraction | More balanced gradient across classes |
| Low-quality small objects | Uniform positive weighting | Confidence-ranked positive selection | Better rare-class recall |
Datasets and metrics. I evaluate my methods on two public UAV drone datasets: VisDrone2019 and UAVDT. VisDrone2019 contains more than 380,000 annotated instances across ten evaluated categories, with roughly 89% of instances belonging to the small-object range. UAVDT contains video frames converted into 23,258 training images and 15,069 test images, with categories car, truck, and bus. I use mean average precision and its variants. For a category \(c\), average precision is
$$AP_c = \int_0^1 P_c(R_c)\,dR_c,$$
and mean average precision is
$$mAP = \frac{1}{C}\sum_{c=1}^{C} AP_c.$$
I report \(mAP\), \(mAP_{50}\), and \(mAP_{75}\). I also report frames per second, floating-point operations, and parameter count. I summarize the dataset properties in Table 6.
| Dataset | Images | Resolution range | Main categories | Small-object prevalence |
|---|---|---|---|---|
| VisDrone2019 | 10,209 images with 6,471 training and 548 validation images | About \(950\times640\) to \(1920\times1080\) | Car, pedestrian, bicycle, motor, van, bus, truck, tricycle, awning tricycle, people | Approximately 89% of instances are small |
| UAVDT | 23,258 training and 15,069 test images | \(1080\times540\) | Car, truck, bus | Large scale variation and dense traffic scenes |
Training configuration. I implement my models with PyTorch and MMDetection. I use ImageNet pretrained weights, SGD with momentum \(0.9\), weight decay \(0.0001\), and a \(2\times\) training schedule of 24 epochs. I set the initial learning rate to \(0.05\), decay it by a factor of 10 at epochs 16 and 22, and use mixed precision FP16 to reduce GPU memory. I train on two NVIDIA GeForce GTX 1080Ti GPUs and set the input size to \(1200\times800\). Unless I state otherwise, all comparative models use the same settings.
Quantitative results on VisDrone2019. I compare my first method with several one-stage and two-stage detectors. The results in Table 7 show that my method reaches \(0.359\) mAP, \(0.585\) mAP50, and \(0.376\) mAP75. Compared with the baseline Cascade RCNN with normalized Gaussian Wasserstein distance, my method improves mAP by \(0.109\), mAP50 by \(0.151\), and mAP75 by \(0.124\). Compared with clustered or zoom-in detectors, my method improves mAP by \(2.5\%\) to \(9.2\%\). These gains come from better feature extraction, better multi-scale fusion, more small-object training samples, and better sample balancing.
| Method | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Cascade RCNN + NWD | 0.250 | 0.434 | 0.252 |
| EdgeYOLO | 0.264 | 0.448 | 0.262 |
| ClusDet | 0.267 | 0.506 | 0.244 |
| QueryDet | 0.283 | 0.481 | 0.288 |
| CEASC | 0.287 | 0.507 | 0.284 |
| GLSAN | 0.307 | 0.554 | 0.300 |
| CZDet | 0.322 | 0.583 | 0.262 |
| CRENet | 0.334 | 0.543 | 0.335 |
| My first method | 0.359 | 0.585 | 0.376 |
Quantitative results on UAVDT. I also evaluate on UAVDT. As shown in Table 8, my method reaches \(0.206\) mAP, \(0.312\) mAP50, and \(0.209\) mAP75. Compared with the baseline Cascade RCNN, this is an improvement of \(0.103\) mAP, \(0.081\) mAP50, and \(0.115\) mAP75. This dataset is smaller in category diversity but contains many small vehicles and dense traffic, so the improvement confirms that my modules generalize beyond VisDrone2019.
| Method | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Baseline Cascade RCNN | 0.103 | 0.231 | 0.094 |
| ClusDet | 0.137 | 0.265 | 0.125 |
| CEASC | 0.171 | 0.309 | 0.178 |
| GLSAN | 0.197 | 0.305 | 0.217 |
| My first method | 0.206 | 0.312 | 0.209 |
Per-category behavior. I analyze per-category results because average metrics can hide failures on rare classes. Table 9 shows that my first method improves small and rare categories such as pedestrian, people, motor, bicycle, and awning tricycle, while also maintaining strong performance on larger categories such as car, bus, and truck. For example, compared with a strong double-head detector, my method improves pedestrian, people, motor, and bicycle by \(0.112\), \(0.093\), \(0.141\), and \(0.134\) mAP respectively. This supports my claim that balancing sample extraction and enhancing small-object features helps both rare and frequent categories.
| 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 RCNN | 0.211 | 0.496 | 0.181 | 0.143 | 0.176 | 0.109 | 0.300 | 0.326 | 0.079 | 0.073 | 0.223 |
| Cascade RCNN | 0.217 | 0.509 | 0.182 | 0.149 | 0.171 | 0.101 | 0.311 | 0.364 | 0.077 | 0.072 | 0.238 |
| Double-Head RCNN | 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 |
Qualitative comparison. I compare my first method with the baseline on multiple UAV drone scenes. In high-altitude vertical views, the baseline often misses tiny riders and distant pedestrians, while my method detects more of them. In street scenes with scattered objects, my method reduces missed detections by roughly \(10.2\%\) to \(34\%\) in my observed examples. In dense scenes with large scale variation, my method detects significantly more objects and reduces the miss rate by about \(40\%\) relative to the baseline. In crowded scenes, my method also detects more targets and reduces the miss rate by around \(20\%\). These observations support the quantitative results.
Ablation of my first method. I perform an ablation study to isolate the contribution of each component. Table 10 shows that the baseline reaches \(0.217\) mAP. Using only the sample-balance strategy raises mAP to \(0.227\). Using only E-LFPN raises it to \(0.236\). Using only MSP raises it to \(0.244\). Using only Cropmix raises it to \(0.280\). When I combine all components, mAP reaches \(0.359\), an improvement of \(0.142\) over the baseline. This indicates that the components are complementary rather than redundant.
| SBS | Cropmix | MSP | E-LFPN | mAP |
|---|---|---|---|---|
| 0.217 | ||||
| √ | 0.227 | |||
| √ | 0.236 | |||
| √ | 0.244 | |||
| √ | 0.280 | |||
| √ | √ | √ | 0.326 | |
| √ | √ | √ | 0.334 | |
| √ | √ | √ | √ | 0.359 |
MSP stage placement. I also study where to place MSP in the backbone. Table 11 shows that using MSP in Stages 2 to 4 gives the best result. Using it in all four stages does not help much because Stage 1 is frozen, so the switch parameter cannot be learned effectively. Removing the weighted deformable convolution also lowers mAP, which confirms that adaptive sampling is important for dense and irregular small objects.
| Configuration | mAP | mAP50 | mAP75 |
|---|---|---|---|
| MSP in Stages 1 to 4 | 0.240 | 0.422 | 0.240 |
| MSP in Stages 2 to 4 | 0.244 | 0.429 | 0.246 |
| MSP in Stages 3 to 4 | 0.229 | 0.407 | 0.225 |
| MSP in Stages 2 to 4 without weighted deformable convolution | 0.234 | 0.411 | 0.233 |
E-LFPN branch ablation. Table 12 shows the effect of the enhancement and location branches. The full E-LFPN reaches \(0.236\) mAP. Removing the location branch gives \(0.233\), while removing the enhancement branch gives \(0.231\). Replacing E-LFPN with the original FPN gives \(0.217\). This means both branches contribute, and the enhancement branch is especially important for preserving small-object responses across scales.
| Configuration | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Full E-LFPN | 0.236 | 0.411 | 0.240 |
| Original 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 |
Cropmix ablation. I compare Cropmix with simpler augmentation choices. Table 13 shows that quadrant cropping and enlargement gives the largest single gain, reaching \(0.272\) mAP. Random recombination gives a smaller additional gain but helps maintain the small-object distribution. Cropmix reaches \(0.280\) mAP and outperforms CutMix, which reaches \(0.263\). I conclude that Cropmix is better suited to UAV drone small-object detection because it increases the effective scale of small instances and preserves dense-object structure better than a generic mixing operation.
| Augmentation | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Crop and enlarge | 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 |
Sample-balance effect. Table 14 compares each module with and without my sample-balance strategy. The baseline improves from \(0.217\) to \(0.224\). Cropmix improves from \(0.280\) to \(0.300\). MSP improves from \(0.244\) to \(0.254\). E-LFPN improves from \(0.236\) to \(0.252\). These results show that focal loss and category-aware extraction are not only useful by themselves but also amplify the benefits of the other modules.
| Method | mAP without SBS | mAP with SBS | mAP50 with SBS | mAP75 with SBS |
|---|---|---|---|---|
| Cascade RCNN | 0.217 | 0.224 | 0.386 | 0.227 |
| Cropmix | 0.280 | 0.300 | 0.484 | 0.320 |
| MSP | 0.244 | 0.254 | 0.438 | 0.256 |
| E-LFPN | 0.236 | 0.252 | 0.434 | 0.257 |
Computational cost of my first method. I compare the computational cost of the baseline and my first method in Table 15. My first method reduces GFLOPs from \(224.85\) to \(174.31\), but increases parameters from \(68.95\)M to \(87.63\)M. The accuracy gain is large, so I consider the parameter increase acceptable for an accuracy-oriented detector. However, this cost motivates my second method, FasterDet, which targets UAV drone deployment where speed and memory are critical.
| Model | GFLOPs | Params |
|---|---|---|
| Cascade RCNN | 224.85 | 68.95M |
| My first method | 174.31 | 87.63M |
Feature visualization of my first method. I visualize backbone features from MSP and the baseline. The MSP features have clearer textures in dense regions and better align with individual objects. I also visualize E-LFPN and the original FPN. E-LFPN produces lower-level feature maps that are more concentrated on object regions and higher-level maps that retain more small-object information. It also reduces background noise from buildings and vegetation. These visualizations support my design choices.
My second proposed method: FasterDet. Although my first method is accurate, I find that it is not fast enough for real-time UAV drone operation. A UAV drone often uses low-power processors or edge devices, so the detector must be lightweight. I therefore design FasterDet. The main changes are a lighter backbone called Faster GhostNet, a progressive feature pyramid called CascadeFusionFPN, and a VariFocal loss. I summarize the design goals in Table 16.
| Goal | Mechanism | Expected effect |
|---|---|---|
| Reduce parameters | Faster GhostNet with partial convolution | Lower memory and storage cost |
| Reduce redundant computation | Partial convolution in Ghost modules and bottlenecks | Lower memory access and faster inference |
| Preserve small-object features | Progressive feature pyramid with fast normalized fusion | Narrow semantic gaps between non-adjacent levels |
| Reduce missed detections | VariFocal loss | Better positive-sample contribution and fewer missed small objects |
Faster GhostNet. I start from GhostNet because it generates features cheaply. In a standard Ghost module, a small set of convolutions produces intrinsic feature maps, and cheap linear operations produce ghost feature maps. I write the intrinsic generation as
$$Y = X * f,$$
and the ghost generation as
$$y_{i,j} = \Phi_{i,j}(y_i),\quad i=1,\dots,m,\; j=1,\dots,s.$$
However, I find that the original depthwise separable convolution inside GhostNet still causes redundant computation and memory access. I replace it with partial convolution. For a feature map of size \(h \times w\) and \(C\) channels, a standard operation may require memory access proportional to
$$h \times w \times 2C.$$
Partial convolution only processes a subset of channels, for example \(C_p = C/4\), so the memory access becomes
$$h \times w \times 2C_p.$$
This reduces memory traffic and computation while keeping the remaining channels as feature carriers for later point-wise convolution. I build Faster Ghost modules and two types of Faster Ghost bottlenecks. The stride-1 bottleneck deepens the network and uses a residual connection. The stride-2 bottleneck downsamples the feature map and also uses a residual branch to align dimensions. Stacking these blocks produces Faster GhostNet, which outputs four feature levels with channel counts \([24,40,80,160]\).
Progressive feature pyramid. I design CascadeFusionFPN because conventional FPN and my first E-LFPN can still lose information when fusing non-adjacent levels. Instead of fusing all levels at once, I fuse them progressively. I use Space-to-Depth to downsample without losing information. For an input tensor of height \(h\), width \(w\), and channels \(c\), Space-to-Depth rearranges spatial blocks into the channel dimension, producing height \(h/N\), width \(w/N\), and channels \(c/N\). I use bilinear interpolation for upsampling. I then fuse features with fast normalized fusion:
$$C_{new} = \frac{\omega_i C_i + \omega_{i-1} C_{i-1}}{\omega_i + \omega_{i-1} + \alpha},$$
where \(\omega_i\) and \(\omega_{i-1}\) are learnable weights, and \(\alpha=0.0001\) prevents numerical instability. I use ReLU and batch normalization to keep the weights positive. This fusion is faster than softmax-based attention on GPU and avoids the sharp semantic gap between non-adjacent levels.
VariFocal loss. I replace focal loss with VariFocal loss in FasterDet. VariFocal loss treats positive and negative samples differently. For a positive sample, it uses the IoU-like target \(n\) to weight the loss so that high-quality positives contribute more. For a negative sample, it follows the focal-style down-weighting. I write it as
$$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. In my experiments, I use \(\gamma=2\) and \(\alpha=0.75\). This loss reduces the contribution of negative samples and gives larger loss contribution to high-quality positive samples, which lowers the missed detection rate for small objects.
Speed and parameter comparison. Table 17 compares the baseline, my first method, and FasterDet. My first method reaches high accuracy but runs at only \(2.2\) images per second. FasterDet reaches \(5.4\) images per second, uses \(202.87\) GFLOPs, and has \(71.43\)M parameters. This is a much better trade-off for UAV drone deployment. Compared with my first method, FasterDet reduces parameters by \(16.2\)M and substantially improves speed.
| Model | FPS (img/s) | GFLOPs | Params |
|---|---|---|---|
| Cascade RCNN | 9.5 | 224.85 | 68.95M |
| My first method | 2.2 | 174.31 | 87.63M |
| FasterDet | 5.4 | 202.87 | 71.43M |
Accuracy of FasterDet. Table 18 shows the detection accuracy of FasterDet and other methods. FasterDet reaches \(0.347\) mAP, \(0.562\) mAP50, and \(0.351\) mAP75. This is slightly lower than my first method, which reaches \(0.359\) mAP, \(0.585\) mAP50, and \(0.376\) mAP75, but FasterDet still outperforms most compared methods. In particular, it is faster and smaller, which matters for UAV drone edge deployment.
| Method | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Cascade RCNN + NWD | 0.250 | 0.434 | 0.252 |
| EdgeYOLO | 0.264 | 0.448 | 0.262 |
| ClusDet | 0.267 | 0.506 | 0.244 |
| QueryDet | 0.283 | 0.481 | 0.288 |
| CEASC | 0.287 | 0.507 | 0.284 |
| GLSAN | 0.307 | 0.554 | 0.300 |
| CZDet | 0.322 | 0.583 | 0.262 |
| CRENet | 0.334 | 0.543 | 0.335 |
| FasterDet | 0.347 | 0.562 | 0.351 |
| My first method | 0.359 | 0.585 | 0.376 |
Ablation of FasterDet. I conduct an ablation study for FasterDet. Table 19 shows that the baseline with Cropmix reaches \(0.280\) mAP. Adding Faster GhostNet raises it to \(0.305\). Adding CascadeFusionFPN raises it to \(0.314\). Adding VariFocal loss raises it to \(0.329\). Combining Faster GhostNet and CascadeFusionFPN gives \(0.335\). Combining all three gives \(0.347\). This confirms that the lighter backbone, progressive fusion, and VariFocal loss all contribute to the final performance.
| Faster GhostNet | CascadeFusionFPN | VariFocal Loss | mAP |
|---|---|---|---|
| 0.280 | |||
| √ | 0.305 | ||
| √ | 0.314 | ||
| √ | 0.329 | ||
| √ | √ | 0.335 | |
| √ | √ | √ | 0.347 |
Backbone comparison. Table 20 compares my previous backbone with Faster GhostNet. The previous backbone runs at \(3.0\) images per second, uses \(150.52\) GFLOPs, and has \(83.82\)M parameters. Faster GhostNet runs at \(6.4\) images per second, uses \(173.31\) GFLOPs, and has \(63.86\)M parameters. The parameter reduction is about \(24\%\), and the speed is more than doubled. This shows that Faster GhostNet is a better match for UAV drone scenarios.
| Backbone | FPS (img/s) | GFLOPs | Params |
|---|---|---|---|
| ResNet-50 + MSP | 3.0 | 150.52 | 83.82M |
| Faster GhostNet | 6.4 | 173.31 | 63.86M |
Feature fusion comparison. I compare fast normalized fusion with concatenation and summation. Table 21 shows that fast normalized fusion reaches \(0.347\) mAP, while concatenation reaches \(0.342\) and summation reaches \(0.338\). The weighted fusion is better because it can adaptively combine features from different levels instead of treating them equally.
| Fusion method | mAP | mAP50 | mAP75 |
|---|---|---|---|
| Concatenation | 0.342 | 0.558 | 0.343 |
| Summation | 0.338 | 0.551 | 0.336 |
| Fast normalized fusion | 0.347 | 0.562 | 0.351 |
Qualitative results of FasterDet. I compare FasterDet with recent detectors on dense, high-altitude, and nighttime UAV drone scenes. In dense crowd regions, FasterDet detects more people and riders. In the yellow-box regions of my qualitative comparisons, it correctly identifies both rider and bicycle, while other methods detect only one of the two. In blue-box regions, it detects occluded vehicles that other methods miss. In high-altitude wide-angle images, it detects tiny vehicles that other detectors fail to find. In nighttime dense scenes, it avoids duplicate detections and category confusion. These observations indicate that FasterDet is not only faster but also robust in difficult UAV drone scenes.
Feature visualization of FasterDet. I visualize the progressive feature pyramid and compare it with the original FPN and my first E-LFPN. The original FPN loses object information quickly as the level increases. My first E-LFPN preserves more information and reduces background noise. The progressive pyramid in FasterDet also preserves information and reduces noise, and it produces clearer object textures in dense regions. In the upper-right dense vehicle area, E-LFPN features are somewhat mixed, while progressive features keep individual vehicles more separated. This supports my claim that progressive fusion reduces the semantic gap between non-adjacent levels.
Overall interpretation. I interpret my results as follows. For UAV drone small-object detection, architecture alone is not enough. The model must also see training samples that reflect the small-object distribution, must adapt its receptive field to scale and shape, must preserve weak features across pyramid levels, and must avoid letting easy negatives dominate the loss. My first method addresses these issues with Cropmix, MSP, E-LFPN, focal loss, and category-aware sampling. My second method addresses deployment constraints with Faster GhostNet, progressive fusion, and VariFocal loss. Together, they form a coherent path from high-accuracy UAV drone detection to lightweight UAV drone detection.
Summary of formulas used in my design. I collect the key formulas in Table 22 for clarity. This table is not a replacement for the full equations above; it is a compact reference that I use when reasoning about the architecture.
| Formula | Role |
|---|---|
| \(IoU = \frac{|B_p \cap B_g|}{|B_p \cup B_g|}\) | Measuring localization quality and assigning samples |
| \(K_{new} = K + (K-1)(D-1)\) | Computing the effective dilated kernel size |
| \(Sample_{P_0} = \sum W(P_n)X(P_0+P_n+\Delta P_n)\Delta \omega_n\) | Weighted deformable convolution in MSP |
| \(Conv_{3\times3} = R \cdot WDDC + (1-R)\cdot WDDC\) | Learnable switch between two receptive-field branches |
| \(P_{avg} = \frac{1}{N}\sum P_n\) | Balanced semantic aggregation in E-LFPN |
| \(FL = -\alpha_t(1-P_t)^\gamma \log(P_t)\) | Hard-example emphasis in my first method |
| \(h w 2C\) and \(h w 2C_p\) | Memory-access comparison for partial convolution |
| \(C_{new} = \frac{\omega_i C_i + \omega_{i-1} C_{i-1}}{\omega_i + \omega_{i-1} + \alpha}\) | Fast normalized fusion in the progressive pyramid |
| \(VariFL = \begin{cases} -n(n\log(m)+(1-n)\log(1-m)), & n>0 \\ -\alpha m^\gamma \log(1-m), & n=0 \end{cases}\) | VariFocal loss for positive-negative contribution control |
| \(mAP = \frac{1}{C}\sum AP_c\) | Final detection evaluation metric |
Conclusion. I have presented a systematic study of small-object detection in UAV drone imagery based on Cascade RCNN. I began by analyzing why UAV drone images are difficult: small objects occupy few pixels, scales vary widely, occlusion is common, backgrounds are cluttered, and class distributions are long-tailed. I then designed a first method that combines Cropmix, MSP, E-LFPN, focal loss, and category-aware sampling. In my experiments on VisDrone2019 and UAVDT, this method substantially improves mAP, mAP50, and mAP75 over the baseline and several recent detectors. I then designed FasterDet to address the deployment constraints of UAV drone platforms. FasterDet uses Faster GhostNet with partial convolution, a progressive feature pyramid with fast normalized fusion, and VariFocal loss. It reduces parameters and improves speed while keeping competitive accuracy. I conclude that the combination of scale-aware feature extraction, small-object-preserving feature pyramids, balanced sampling, and lightweight backbone design is an effective direction for UAV drone small-object detection.
Future work. I see several directions for further improvement. First, although FasterDet is faster than my first method, it is still not fully real-time on low-power UAV drone hardware. I plan to explore more efficient block designs, quantization, pruning, and neural architecture search. Second, I want to improve robustness under extreme illumination, fog, rain, and motion blur. This may require stronger augmentation, domain adaptation, or physics-aware image restoration before detection. Third, I want to reduce dependence on large manually annotated datasets by using semi-supervised or weakly supervised learning. Fourth, I plan to study temporal information in UAV drone videos, because motion cues can help distinguish small objects from background noise and can improve recall in dense scenes. Finally, I want to evaluate my methods on embedded UAV drone platforms in real flight conditions, because the gap between benchmark performance and field performance is still significant.
In my view, the most important lesson from this work is that UAV drone small-object detection should be treated as a joint problem of data distribution, receptive-field design, multi-scale feature preservation, loss balancing, and computational efficiency. When these factors are addressed together, a Cascade RCNN-based detector can become both accurate and practical for UAV drone imagery.