Object detection is a core task in computer vision and plays a critical role in enabling intelligent perception for unmanned aerial vehicles (UAVs). The integration of UAV imagery with object detection algorithms greatly improves the practical value of UAV systems, with applications in traffic monitoring, search-and-rescue, precision agriculture, and security surveillance. However, UAV images usually contain numerous small objects, and these objects often occupy only a few pixels in the image. Because small objects have limited appearance cues and geometric evidence, their features are much harder to extract than those of normal-size objects. In this thesis, I focus on the problem of small object detection in UAV scenarios and propose a series of deep learning based algorithms and a practical low-light enhancement system to improve detection accuracy and robustness. The main contributions are summarized as follows.
First, I propose an ATDE (Attention To Detail) convolutional module to improve the extraction of spatial detail information in shallow layers. The module adopts a multi-level concatenation structure and maps the concatenated feature tensor to a higher-dimensional space before feature extraction. By applying this module to the shallow layers of the YOLOX-S network, the model is able to retain more fine-grained details of small objects. Experimental results on the VisDrone2019 benchmark show that the improved algorithm increases the mean average precision at IoU threshold 0.5 by 2.6 percentage points compared with the original YOLOX-S model.
Second, I propose a Slow Growth Receptive Field (SGRF) allocation strategy. The core idea is to increase the receptive field in shallow layers while slowing down the growth of receptive fields in deeper layers. Under this guidance, I simplify the stem structure, use larger convolution kernels in shallow stages, reduce the convolution depth in the second stage, and design a modified spatial pyramid pooling structure. These changes collectively improve the feature representation for small objects in unmanned aerial vehicles. The optimized algorithm achieves an AP0.5 of 36.8%, which is 4.1 percentage points higher than the original YOLOX-S baseline.
Third, I design an adaptive low-light image enhancement system for UAV object detection. The system consists of a low-light image recognition module, an enhancement module, and a detection module. The recognition module uses histogram statistics and a sliding-window strategy to determine whether an image is underexposed. The enhancement module uses a generative adversarial network with a U-Net generator to brighten low-light images. The detection module adopts the SGRF-based object detector. Experimental results indicate that the proposed system effectively reduces missed detections and false detections in dark or uneven illumination environments.
1. Introduction
Unmanned aerial vehicles have developed rapidly in recent years. Their high flight altitude and flexible maneuverability allow them to capture wide-area scenes that are difficult for ground-based cameras to obtain. This makes UAVs extremely useful in real-world applications. For example, UAV-based traffic monitoring can detect vehicles, pedestrians, and bicycles from a bird’s-eye view; UAV-based disaster response can locate survivors in hazardous areas without endangering human lives; and UAV-based agriculture can identify crop diseases and pests. In all these tasks, object detection is an essential component. However, the detection accuracy in UAV images is still far from satisfactory. The main difficulty comes from small objects. In a typical UAV image with a resolution of 640 by 640 pixels, a small object may occupy only 10 by 10 pixels or even fewer. Such objects contain very little discriminative information, and they are easily confused with complex backgrounds. Therefore, designing robust object detectors for unmanned aerial vehicles is a challenging but meaningful research direction.
In recent years, deep learning has become the dominant paradigm for object detection. Convolutional neural networks (CNNs) and, more recently, transformer-based models have achieved remarkable progress on generic object detection benchmarks. However, most existing detectors are designed for objects with moderate or large sizes. When they are directly applied to UAV images, performance drops significantly. This is because the feature extraction process, the design of receptive fields, and the loss functions are not optimized for small object detection. For instance, after successive down-sampling operations, a small object may occupy only a single pixel in the deepest feature map, making it impossible for the detector to accurately localize and classify it. Moreover, the semantic gap between low-level spatial details and high-level abstract semantics is large, and naive feature fusion cannot fully solve the problem. Thus, specific architectural designs are needed to protect the spatial details and to allocate appropriate receptive fields for different stages.
Apart from small object challenges, lighting conditions also severely affect the performance of UAV object detection. UAV images are often captured under changing weather, time, and angle. When the sun is behind clouds, at dusk, or at night, images may become too dark or unevenly illuminated. In such cases, target details are lost, noise is amplified, and the detection performance degrades. Low-light image enhancement is therefore a crucial preprocessing step for robust UAV perception. Traditional methods such as histogram equalization and Retinex-based algorithms have been widely studied, but they often produce color distortion and over-enhancement. Deep learning based enhancement methods, especially generative adversarial networks, have become popular because they can generate visually pleasing images with realistic colors. In this thesis, I combine low-light enhancement with object detection to build an adaptive system that can make UAV object detection more reliable in dark environments.
2. Technical Analysis of UAV Object Detection
2.1 Mainstream Convolutional Modules
Convolutional modules are the building blocks of deep detection networks. Different module designs have a direct impact on the ability to extract features from images. In this work, I analyze three representative convolution modules: YOLOX CSPResBlock, MobileNet’s inverted residual block, and ConvNeXt’s block.
The YOLOX network uses the CSPResBlock module. Its structure applies a CSP (Cross Stage Partial) strategy that splits the input feature map into two branches through 1×1 convolutions. One branch processes the features through bottleneck layers, while the other branch bypasses the processing and is concatenated later. This design reduces computational cost while preserving rich gradient information. Let the output of the module be y = x3, the gradient of the loss L with respect to w1 is:
$$
\frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial x_3} \cdot \frac{\partial x_3}{\partial x_2} \cdot \frac{\partial x_2}{\partial x_1} \cdot \frac{\partial x_1}{\partial w_1},
$$
while the gradient with respect to w0 is:
$$
\frac{\partial L}{\partial w_0} = \frac{\partial L}{\partial x_3} \cdot \frac{\partial x_3}{\partial x_0} \cdot \frac{\partial x_0}{\partial w_0}.
$$
The split and concatenate operations provide multiple paths for gradient back-propagation, which helps the network learn richer representations. However, the bottleneck structure first maps the input into a low-dimensional space. This operation can cause information loss for tiny objects because their weak signals are more likely to be discarded during dimension reduction.
The MobileNet module is a typical inverted residual block. It first expands the feature map into a high-dimensional space, then uses a depthwise separable convolution for feature extraction, and finally projects the features back to the low-dimensional space using a linear 1×1 convolution. The depthwise separable convolution decomposes a standard convolution into a depthwise convolution and a pointwise convolution. For an input feature map of size H x H x Cin and an output of H x H x Cout, the computational cost of standard convolution is:
$$
C_1 = H^2 \cdot C_{in} \cdot C_{out} \cdot K^2,
$$
while the cost of depthwise separable convolution is:
$$
C_2 = H^2 \cdot C_{in} \cdot K^2 + H^2 \cdot C_{in} \cdot C_{out}.
$$
The ratio is:
$$
\frac{C_2}{C_1} = \frac{1}{C_{out}} + \frac{1}{K^2}.
$$
The inverted residual structure operates in a high-dimensional space, which is beneficial for preserving detail. However, the residual connection uses element-wise addition, and this may amplify the response of large objects while suppressing the response of small objects.
The ConvNeXt module is inspired by Swin Transformer. It uses a 7×7 depthwise convolution first, followed by two 1×1 convolutions, and the whole block forms an inverted residual-like structure. ConvNeXt uses fewer activation functions and normalization layers to mimic transformer design. This design may reduce nonlinearity, which can be beneficial for large-sample classification but less suitable for small object detection in unmanned aerial vehicles.
These observations motivate my research direction: shallow layers must focus on spatial details, and the convolution modules should avoid aggressive dimension reduction. The proposed ATDE module is designed with this principle.
2.2 Detection Framework
Modern one-stage object detectors usually consist of three parts: a backbone network, a feature pyramid network, and a detection head. The backbone extracts hierarchical features from the input image. The feature pyramid fuses multi-scale features to handle objects of different sizes. The detection head predicts class labels and bounding box coordinates. The YOLOX-S model uses CSPDarkNet with a PAFPN and a decoupled detection head. Feature maps of sizes 80×80, 40×40, and 20×20 are produced for detection when the input resolution is 640×640. The decoupled head separates the classification and regression branches, which reduces the conflict between these two tasks and accelerates convergence.
Another important element in detection is positive/negative sample assignment. Anchor-free detectors often treat all pixels inside a ground-truth box as positive samples. More advanced assignment strategies, such as OTA, formulate sample assignment as an optimal transport problem. In this thesis, I do not redesign the assignment strategy but instead focus on feature extraction and receptive field allocation. The baseline YOLOX-S uses SimOTA assignment, which already provides good training stability.
2.3 UAV Datasets
To evaluate the performance of object detectors in UAV scenarios, a suitable dataset is necessary. Several public UAV datasets are available. The following table compares the most widely used datasets.
| Dataset | Number of Images | Vision Tasks | Object Categories |
|---|---|---|---|
| UAVDT | 8,000 | Detection, tracking | 1 |
| AU-AIR | 32,823 | Detection | 8 |
| DroneVehicle | 56,878 | Detection | 5 |
| VisDrone2019 | 261,908 | Detection, tracking, counting | 12 |
VisDrone2019 is the most comprehensive benchmark for UAV object detection. It contains 10209 static images and 288 video clips. The official training set has 6471 images, the validation set has 548 images, and the test set contains 1610 images with about 77,547 annotated objects. The categories include pedestrian, people, bicycle, car, van, truck, tricycle, awning-tricycle, bus, and motor. In my experiments, I exclude the ignored regions and the “others” category because they do not correspond to physical objects. Statistics show that more than 65% of objects in VisDrone2019 are small or extremely small, which makes it a very challenging and realistic benchmark for studying small object detection in unmanned aerial vehicles.
During training, I apply data augmentation including random affine transforms, horizontal flips, mosaic augmentation, and mixup. Mosaic augmentation combines four images into one, which increases the density of small objects and helps the detector become robust to scale variation. Mixup creates new training samples through linear interpolation, which improves generalization. In the last few epochs, data augmentation is disabled so that the model can converge to the true distribution of real images.
3. Small Object Detection Algorithm Based on High-Dimensional Feature Extraction
3.1 Problem Analysis
Small objects in UAV images are difficult to detect because they contain very few pixels. When a convolutional network performs down-sampling, the high-resolution feature map is gradually transformed into low-resolution feature maps. The fine spatial information of small objects is often lost in the early stages. Therefore, deep layers cannot effectively respond to small objects. It is more beneficial to strengthen the learning of shallow spatial details than to focus only on deep semantic information.
However, mainstream convolution modules are not well suited for preserving these details. The bottleneck residual structure reduces the dimension of the feature map before feature extraction, which may discard weak small-object signals. The MobileNet structure first expands to high dimensions but then uses a skip connection with addition, which can enhance large object responses and suppress small object responses. ConvNeXt reduces activation functions and normalization layers, leading to lower nonlinearity and slower convergence. To address these problems, I propose the ATDE module.
3.2 The ATDE Module
The ATDE module has two main parts. The first part is a multi-level concatenation structure. The input x is passed through several depthwise convolutions with kernel size k. After each convolution, the feature map is concatenated with the original input and with all previous features. This way, the network can dynamically choose the feature maps with the best responses. In addition, the concatenation operation preserves the original spatial information without amplifying large object regions. The gradient propagation becomes more diverse. For a module with two depthwise convolution layers, the output y is a function of x2, x1, and x0, and the gradient with respect to w1 can be decomposed into multiple paths:
$$
\frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial y} \cdot \left( \frac{\partial y}{\partial x_2} \cdot \frac{\partial x_2}{\partial x_1} + \frac{\partial y}{\partial x_1} \right) \cdot \frac{\partial x_1}{\partial w_1}.
$$
The second part of ATDE is a high-dimensional mapping. The concatenated tensor is first passed through a 1×1 convolution that expands the channel dimension by a factor of dim, where the output channel number is (1+num) * dim * n. Then a 1×1 convolution projects the feature map back to the original channel number n. This operation is similar to adding an MLP in the channel dimension. The expanded hidden layer increases the model’s capacity to fit complex functions and helps preserve small-object details. The batch normalization and SiLU activation are used after every convolution. Batch normalization is defined as:
$$
BN(x_i) = \gamma \cdot \frac{x_i – \mu_B}{\sqrt{\sigma_B^2 + \epsilon}} + \beta,
$$
and the SiLU activation is:
$$
SiLU(x) = x \cdot \frac{1}{1 + e^{-x}}.
$$
3.3 Loss Function
The overall loss of my improved algorithm consists of four parts: classification loss, objectness loss, regression loss, and an auxiliary localization loss. The classification and objectness losses use binary cross entropy:
$$
BCELoss = -\frac{1}{n} \sum_{i=1}^{n} \left[ y_i \log p_i + (1 – y_i) \log (1 – p_i) \right].
$$
The regression loss is the IoU loss:
$$
L_{reg1} = 1 – IoU.
$$
To improve localization accuracy, I add an auxiliary loss based on the mean absolute error between the predicted box and the ground-truth box:
$$
L_{reg2} = \frac{|x_p – x_g| + |y_p – y_g| + |w_p – w_g| + |h_p – h_g|}{4}.
$$
The final total loss is:
$$
Loss = \frac{L_{cls} + L_{obj} + L_{reg1} + L_{reg2}}{N_{pos}}.
$$
3.4 Architecture
I apply the ATDE module in the first stage of the YOLOX-S backbone. In this stage, the feature map size is 160×160, and the channel number is 64. The module uses a 3×3 depthwise convolution with depth 1. The concatenated feature map has 128 channels. It is expanded to 512 channels and then reduced back to 64 channels. The rest of the backbone remains the same as YOLOX-S. The improved network is trained on VisDrone2019 and evaluated on the test set.
3.5 Experiments and Results
3.5.1 Experimental Setup
All experiments use the MMDetection and PyTorch frameworks. The GPU is an NVIDIA TITAN Xp with 12GB memory. The input image size is 640×640. The SGD optimizer is used with a momentum of 0.9, weight decay of 0.0005, and batch size of 8. The training runs for 150 epochs. Data augmentation is disabled after epoch 130. Each model is trained three times, and the best result on the validation set is selected for testing.
3.5.2 Feature Visualization
To verify whether high-dimensional feature extraction improves detail information, I visualize the feature maps of the ATDE module with different dimension expansion ratios dim = 0, dim = 1, dim = 2, and dim = 4. The results show that as dim increases, the feature maps become richer and contain clearer edges and contours of small objects. The high-dimensional space allows the network to attend to all regions equally rather than focusing only on large objects. This behavior is consistent on both training images and test images, which demonstrates the robustness of the proposed module.
3.5.3 Ablation Study of Dimension Expansion Ratio
| Stage1 Block | AP0.5:0.95 | AP0.5 | FPS | Params (M) | AP_small | AP_medium | AP_large |
|---|---|---|---|---|---|---|---|
| CSPResBlock | 0.175 | 0.327 | 66.9 | 8.941 | 0.090 | 0.262 | 0.349 |
| ATDE dim=0 | 0.181 | 0.340 | 70.4 | 8.940 | 0.093 | 0.272 | 0.354 |
| ATDE dim=1 | 0.183 | 0.341 | 68.6 | 8.966 | 0.097 | 0.271 | 0.378 |
| ATDE dim=2 | 0.186 | 0.346 | 68.5 | 8.991 | 0.097 | 0.276 | 0.391 |
| ATDE dim=4 | 0.190 | 0.353 | 68.3 | 9.040 | 0.100 | 0.278 | 0.374 |
The results show that even when dim=0, the ATDE module outperforms the original CSPResBlock because of the multi-level ConcAt structure and depthwise convolution. The best performance is achieved at dim=4, where the AP0.5 is 2.6 percentage points higher than the baseline while the inference speed is slightly improved.
3.5.4 Comparison with Other Convolution Modules
| Stage1 Block | AP0.5:0.95 | AP0.5 | FPS | Params (M) | AP_small |
|---|---|---|---|---|---|
| CSPResBlock | 0.175 | 0.327 | 66.9 | 8.941 | 0.090 |
| ConvNeXt | 0.170 | 0.321 | 63.2 | 8.959 | 0.086 |
| MobileNet | 0.186 | 0.345 | 68.7 | 9.025 | 0.097 |
| ResNet | 0.172 | 0.323 | 69.6 | 8.936 | 0.088 |
| ResNeXt | 0.172 | 0.323 | 68.3 | 8.928 | 0.087 |
| ATDE dim=4 | 0.190 | 0.353 | 68.3 | 9.040 | 0.100 |
The comparison indicates that the low-dimensional bottleneck design of ResNet and ResNeXt is not suitable for small object detection. ConvNeXt with fewer nonlinearities obtains the lowest performance. MobileNet benefits from high-dimensional expansion, but its addition-based skip connection is less effective than the concatenation-based design in ATDE. Therefore, the proposed ATDE module is a strong choice for shallow-layer feature extraction in unmanned aerial vehicles.
4. SGRF Receptive Field Allocation Strategy
4.1 Problem Analysis
Receptive field size is one of the most important factors in convolutional neural networks. It determines how much context a feature map pixel can see in the original image. For a convolutional layer with kernel size k_n and stride s_i, the receptive field of layer n is computed as:
$$
RF_{n} = RF_{n-1} + \left( k_{n} – 1 \right) \prod_{i=1}^{n-1} s_{i}.
$$
As the network goes deeper, the receptive field grows rapidly. In UAV object detection, the feature maps used for detection are 80×80, 40×40, and 20×20. If the receptive field is too large, one pixel on the feature map may cover multiple objects. For example, a single pixel may cover a pedestrian, a bicycle, and a truck at the same time. In this case, the detector may miss some of these objects. Larger receptive fields also introduce more background noise, which is harmful for small objects. On the other hand, if the receptive field is too small, the target object cannot be fully seen by the filter, leading to incomplete feature extraction. Thus, the receptive field must be carefully allocated across stages.
4.2 SGRF Core Idea
I propose a Slow Growth Receptive Field strategy. The core idea is to increase the effective receptive field in the shallow network while reducing the expansion speed of receptive fields in subsequent stages. This way, the shallow layers can capture rich shape and detail information, while the deeper layers do not become overly large in context. The implementation of SGRF includes four components.
4.3 Stem Simplification
In the YOLOX-S backbone, the Focus module performs slice operations to reduce the resolution and increase the channel dimension. Although Focus does not lose pixel information, it rearranges pixels and can blur the edges of small objects. Since shallow layers mainly extract low-level features such as edges and corners, I replace Focus with a simple 3×3 convolution with stride 2. This stem directly downsamples the input image to 320x320x32. This design preserves more original spatial information and also increases inference speed.
4.4 Large Kernel in Shallow Layers
I increase the kernel size of the ATDE module in Stage1 from 3 to 7. A larger convolution kernel provides a larger effective receptive field. According to the receptive field formula, a 7×7 convolution with stride 1 after the stem has a receptive field of 7, while a 3×3 convolution has a receptive field of only 3. Although stacking multiple 3×3 convolutions can match the receptive field of a 7×7 convolution, the direct large kernel is more effective because it learns shape bias and preserves local continuity. The large kernel also avoids the missing information caused by dilated convolutions.
4.5 Network Structure Design
In mainstream networks, the same kernel size is used in all stages. To implement SGRF, I choose a decreasing kernel-size schedule: (7, 5, 3, 3). This schedule gives large receptive fields in shallow layers and slower growth in deeper layers. Additionally, I reduce the convolution depth of Stage2 from 3 to 1. This helps preserve spatial details in the first detection feature map and also reduces the growth of the receptive field.
4.6 MixSPP Module
At the end of the backbone, the original SPP module is followed by a CSPBlock. I replace these two modules with a MixSPP module. MixSPP performs a 3×3 depthwise convolution in parallel with three max-pooling operations with window sizes 5, 9, and 13. The outputs are progressively fused. This parallel design reduces the number of stacked 1×1 convolutions before feature extraction, decreases the risk of overfitting, and lowers the computational cost. The MixSPP module also produces a smaller final receptive field than the original SPP followed by convolutions, which is consistent with the SGRF strategy.
4.7 The Improved Backbone ATDeNet
The improved backbone is named ATDeNet. Its structure is as follows:
| Stage | Operation | Output Size |
|---|---|---|
| Stem | 3×3 Conv, stride 2 | 320x320x32 |
| Stage1 | 3×3 Conv, stride 2; ATDE k=7, depth=1, dim=4 | 160x160x64 |
| Stage2 | 3×3 Conv, stride 2; ATDE k=5, depth=1, dim=3 | 80x80x128 |
| Stage3 | 3×3 Conv, stride 2; ATDE k=3, depth=3, dim=1 | 40x40x256 |
| Stage4 | 3×3 Conv, stride 2; MixSPP | 20x20x512 |
ATDeNet outputs three feature maps from Stage2, Stage3, and Stage4. These feature maps are fed into the PAFPN and decoupled head for prediction. The full algorithm is named the SGRF-based small object detector.
4.8 Experiments and Results
4.8.1 Ablation of Shallow Receptive Field
| Stage1 ATDE | AP0.5:0.95 | AP0.5 | FPS | Params (M) | AP_small | AP_medium | AP_large |
|---|---|---|---|---|---|---|---|
| Kernel=3 | 0.190 | 0.353 | 68.3 | 9.040 | 0.100 | 0.278 | 0.374 |
| Kernel=5 | 0.191 | 0.354 | 68.0 | 9.041 | 0.101 | 0.280 | 0.381 |
| Kernel=7 | 0.193 | 0.356 | 67.7 | 9.042 | 0.104 | 0.286 | 0.405 |
| Dilated Conv r=3 | 0.186 | 0.346 | 67.4 | 9.040 | 0.097 | 0.275 | 0.390 |
The results show that the large kernel provides a more effective receptive field than dilated convolution. The AP_small increases from 0.100 to 0.104 when the kernel size increases from 3 to 7. This confirms that increasing the shallow receptive field is beneficial for small object detection in unmanned aerial vehicles.
4.8.2 Ablation of MixSPP
| Stage4 | AP0.5:0.95 | AP0.5 | FPS | Params (M) | AP_large |
|---|---|---|---|---|---|
| SPP+CSPBlock | 0.175 | 0.327 | 66.9 | 8.941 | 0.349 |
| MixSPP | 0.175 | 0.330 | 68.8 | 8.422 | 0.386 |
MixSPP achieves a better AP0.5 while having fewer parameters. This indicates that the parallel design is more efficient and improves the performance in the large-object regime as well.
4.8.3 SGRF Kernel Schedule Ablation
| Kernel Schedule | AP0.5:0.95 | AP0.5 | FPS | Params (M) | AP_small | AP_medium | AP_large |
|---|---|---|---|---|---|---|---|
| (7,5,3,3) | 0.201 | 0.368 | 72.6 | 9.649 | 0.110 | 0.295 | 0.397 |
| (3,3,3,3) | 0.195 | 0.361 | 72.7 | 9.644 | 0.105 | 0.289 | 0.368 |
| (5,5,5,5) | 0.194 | 0.360 | 72.2 | 9.668 | 0.104 | 0.287 | 0.386 |
| (7,7,7,7) | 0.196 | 0.358 | 71.5 | 9.703 | 0.104 | 0.288 | 0.379 |
The decreasing kernel schedule achieves the highest AP0.5 and the highest small-object accuracy. This strongly supports the SGRF strategy. Using a constant large kernel in all stages degrades the performance because the subsequent receptive fields become too large.
4.8.4 Comparison with Other Backbones
| Backbone | AP0.5:0.95 | AP0.5 | FPS | Params (M) | AP_small | AP_medium | AP_large |
|---|---|---|---|---|---|---|---|
| CSPDarkNet (YOLOX-S) | 0.175 | 0.327 | 66.9 | 8.941 | 0.090 | 0.262 | 0.349 |
| ConvNeXt | 0.147 | 0.282 | 64.8 | 9.142 | 0.072 | 0.222 | 0.287 |
| MobileNet | 0.185 | 0.351 | 72.4 | 10.42 | 0.100 | 0.272 | 0.382 |
| CSPDarkNet (YOLOv8-S) | 0.181 | 0.337 | 71.6 | 9.808 | 0.092 | 0.270 | 0.392 |
| ATDeNet | 0.201 | 0.368 | 72.6 | 9.649 | 0.110 | 0.295 | 0.397 |
ATDeNet improves the AP0.5 by 4.1 percentage points over the original YOLOX-S backbone while also improving the inference speed. The improvement is consistent across all object sizes, but especially for small objects.
4.8.5 Transfer to YOLOv8 Framework
To verify the generality of ATDeNet, I replace the backbone in YOLOv8-S with ATDeNet. The results are:
| Backbone | AP0.5:0.95 | AP0.5 | FPS | Params (M) | AP_small | AP_medium | AP_large |
|---|---|---|---|---|---|---|---|
| CSPDarkNet (YOLOv8-S) | 0.187 | 0.326 | 77.8 | 11.139 | 0.088 | 0.286 | 0.400 |
| ATDeNet | 0.207 | 0.354 | 80.0 | 10.980 | 0.100 | 0.315 | 0.427 |
The AP0.5 is improved by 2.8 percentage points. This confirms that ATDeNet is not only effective within my own framework but also transferable to other modern detectors.
4.8.6 Effect of Higher Input Resolution
I also test the algorithm with an input resolution of 800×800. The ATDeNet-based detector improves the AP0.5 by 2.7 percentage points over the baseline at this resolution. The results are shown in the table below.
| Backbone | AP0.5:0.95 | AP0.5 | FPS | AP_small | AP_medium | AP_large |
|---|---|---|---|---|---|---|
| CSPDarkNet (YOLOX-S) | 0.204 | 0.377 | 66.0 | 0.120 | 0.294 | 0.344 |
| ATDeNet | 0.221 | 0.404 | 68.5 | 0.134 | 0.317 | 0.371 |
Higher resolution helps small objects but also increases computational cost. Nevertheless, ATDeNet retains its advantage at higher resolution, demonstrating strong robustness.
5. Adaptive Low-Light Image Enhancement System for UAV Object Detection
5.1 Need Analysis
UAV images are often affected by the shooting angle, weather, and time. The images can be unevenly illuminated or globally dark. This problem becomes even more severe at night. In low-light environments, the details of small objects are lost, and the detection model produces more missed detections and false detections. Therefore, I design an adaptive system that recognizes the low-light condition, enhances the image, and then performs object detection.
The system consists of three modules. The first module is a low-light image recognition module. The second module is an enhancement module. The third module is the detection module, which uses the SGRF-based algorithm from Chapter 4.
5.2 Low-Light Enhancement Techniques
Traditional histogram equalization is a global method that maps the cumulative histogram to a wider range. It can increase contrast but often amplifies noise and causes color distortion. The Retinex model assumes that an observed image I is the product of illumination L and reflectance R:
$$
I(x,y) = L(x,y) \cdot R(x,y).
$$
In the logarithmic domain, the reflectance can be computed as:
$$
\log R(x,y) = \log I(x,y) – \log L(x,y).
$$
Deep learning methods such as Retinex-Net and KinD use neural networks to decompose the image into illumination and reflectance. EnlightenGAN is a generative adversarial network that performs enhancement without paired supervision. Its generator is a U-Net with attention modules, and its discriminator is a global-local dual structure. The self-feature preserving loss is used to maintain the content features before and after enhancement. The loss is:
$$
L_{SFP} = \sum_{i=1}^{W_i H_i} \left\| \phi_i(I) – \phi_i(G(I)) \right\|^2,
$$
where \(\phi_i\) is the feature extracted from the i-th layer of the pretrained ATDeNet. The global adversarial loss and local adversarial loss are:
$$
L_{global} = E \left[ \left( D_{global}(x_r, x_f) – 1 \right)^2 \right] + E \left[ \left( D_{global}(x_f, x_r) \right)^2 \right],
$$
$$
L_{local} = E \left[ \left( D_{local}(x_f) – 1 \right)^2 \right].
$$
The total training loss is:
$$
Loss = L_{global} + L_{local} + L_{SFP}^{global} + L_{SFP}^{local}.
$$
5.3 System Design
The recognition module converts the RGB image to a grayscale image using the average of the three channels. It then applies a sliding window of size 200×200 with a stride of 80. For each window, it computes the mean and variance. A brightness score is defined as:
$$
\theta_i = \mu_i + 0.1 \cdot \sigma_i^2.
$$
If the brightness score is less than 120, the window is considered low-light. If more than one quarter of all windows are low-light, the image is judged as a low-light image. This method is fast and effective; the average processing time per image is around 10 milliseconds.
The enhancement module uses the trained generator to brighten the input image. The generator is a U-Net with five layers. The first convolution in each layer is changed to a 7×7 convolution to increase the receptive field. An attention map is computed from the grayscale version of the input and is fed into the U-Net. The generator output is used as the enhanced image.
5.4 Experiments and Results
5.4.1 Recognition Module Performance
I first evaluate the recognition module on the LOL dataset. The results are:
| Image Type | Number | Processing Time | Accuracy |
|---|---|---|---|
| Low-light | 485 | 4.65 s | 98.7% |
| Normal | 485 | 4.65 s | 95.4% |
On VisDrone2019 test images, the recognition module achieves 92.5% accuracy on low-light images and 96.7% accuracy on normal images. This shows that the module can effectively identify low-light UAV images.
5.4.2 Enhancement and Detection Evaluation
I select 480 low-light images from the VisDrone2019 test set and evaluate two configurations. The first configuration directly uses the SGRF detector. The second configuration applies the enhancement module first and then runs the same detector. The AP0.5 results are shown below.
| Configuration | AP0.5 |
|---|---|
| Direct detection | 0.302 |
| Enhancement + detection | 0.343 |
The enhancement module improves the AP0.5 by 4.2 percentage points, bringing the low-light performance close to the normal-light performance of 36.8%. In qualitative results, the detection probability of vehicles in dark regions increases significantly, and the number of missed cars is greatly reduced.
6. Conclusion and Future Work
In this thesis, I have studied object detection in unmanned aerial vehicles from three perspectives: feature extraction, receptive field allocation, and low-light image enhancement. The proposed ATDE module improves the model’s ability to extract spatial details. The SGRF strategy further improves small object detection by carefully controlling the growth of receptive fields across the network. Finally, the adaptive low-light enhancement system makes the detector more robust in dark environments. Experimental results on the VisDrone2019 dataset demonstrate the effectiveness of each contribution. The final detector achieves 36.8% AP0.5 on the VisDrone2019 test set, which is 4.1 percentage points higher than the original YOLOX-S model. The low-light system increases detection accuracy on dark images by 4.2 percentage points.
There are still several limitations. First, the SGRF strategy slightly reduces the detection accuracy for large objects because the deep receptive field growth is intentionally slowed down. In low-altitude UAV scenes where large objects are common, a different strategy may be needed. Future work may explore adaptive receptive field allocation according to object scale distribution. Second, the detection performance degrades when the camera angle is highly oblique. This issue can be addressed by collecting more diverse training data or by designing rotation-aware components. Third, the low-light enhancement system is not trained jointly with the detector. An end-to-end trainable system could improve the overall performance and reduce inference overhead. Finally, moving objects in UAV videos often cause occlusion, which is not fully addressed in this thesis. Combining temporal information and tracking could further improve detection robustness in unmanned aerial vehicles.