Object detection has long been a central topic in computer vision. Combining unmanned aerial vehicle (UAV) imagery with object detection tasks can greatly improve the practicality of drones and unlock broad application prospects. However, small objects inherently possess limited pixel areas, sparse appearance and geometric cues, and low discrimination against the background, making their feature extraction substantially more difficult than that of normally sized objects. Consequently, object detection in UAV scenarios faces numerous challenges. In this thesis, I carry out an in-depth study on the recognition of objects observed by UAVs using deep learning methods. My main contributions are summarized as follows.
First, I analyze the fact that the detailed information of small objects is more easily lost when feature map resolution decreases, compared with large objects. This means that deep feature maps often fail to respond to small object features. Therefore, enhancing the learning of shallow spatial detail information is more beneficial than enhancing deep semantic information for small object detection. To tackle the insufficient capability of mainstream convolutional modules in extracting fine details from small objects, I propose a small object detection algorithm based on an improved YOLOX-S. By applying a newly designed ATDE (Attention To Detail) convolutional module in the shallow layers of the network, the model gains a stronger ability to detect small objects. I train and evaluate the improved algorithm on the VisDrone2019 dataset. The experimental results show that the average precision (AP0.5) on the test set improves by 2.6% compared with the original model. This indicates that the algorithm has a strong capability to represent detailed information and significantly boosts the accuracy of object detection in UAV scenarios.
Second, I investigate how the receptive field size directly influences the features extracted by convolutional kernels. An improperly designed receptive field can degrade detection performance, especially for tiny objects. The receptive field distribution in existing feature extraction networks is often suboptimal for small object detection. To solve this problem, I propose a Slow Growth Receptive Field (SGRF) allocation strategy. The core idea of this strategy is to enlarge the receptive fields of shallow network stages while slowing down the expansion speed of receptive fields in later stages. Guided by this principle, I optimize both the network architecture and the convolutional modules of the detection algorithm. The optimized algorithm is trained and evaluated on the VisDrone2019 dataset. The experimental results demonstrate that the average precision (AP0.5) on the test set increases by 4.1% compared with the baseline YOLOX-S model, proving that the SGRF strategy effectively improves detection accuracy in UAV scenarios.
Third, I address the problem of low-light images. UAV imagery is often affected by the attitude of the aircraft or lighting conditions, leading to uneven illumination or excessively dark frames. Nighttime object detection is particularly challenging. To mitigate this, I design an adaptive low-light image enhancement system for UAV object detection. The system consists of three modules: a low-light image recognition module, a low-light image enhancement module, and a detection module. It adaptively preprocesses the input frames when weak lighting is detected. Test results show that the system effectively improves the stability of detection in UAV scenarios and reduces both missed detections and false detections under low-light conditions.
1. Introduction
In recent years, the rapid development of unmanned aerial vehicle (UAV) technology has enabled widespread adoption in agriculture, transportation, public security, and disaster response. Object detection in UAV images is a key enabler for these applications. However, UAV images are typically captured at high altitudes, resulting in many small objects that occupy only a few pixels. This property makes detection harder than in ordinary images. Researchers have developed many deep learning based detectors, including both one-stage and two-stage models, as well as transformer-based detectors. Nevertheless, applying these models directly to UAV scenarios often leads to significant performance degradation.
The main challenges in UAV object detection are summarized as follows:
- Small objects have limited appearance information and are easily confused with backgrounds.
- Deep convolutional networks gradually lose spatial details, making it harder for high-level feature maps to respond to small objects.
- The receptive field design of most backbone networks is not optimized for small object detection.
- UAV images may suffer from poor illumination, which reduces the contrast of small objects.
To address these issues, my research focuses on improving detection algorithms from three perspectives: high-dimensional feature extraction, slow-growth receptive field allocation, and adaptive low-light enhancement.
2. Technical Analysis of UAV Object Detection
2.1 Mainstream Convolutional Modules
I analyze three mainstream convolutional modules used in modern detection networks: the CSPResBlock module, the MobileNet inverted residual module, and the ConvNeXt module.
The CSPResBlock module adopts the Cross Stage Partial (CSP) structure. It divides the input feature map into two branches using 1×1 convolutions. One branch passes through a series of convolutional blocks, while the other branch is concatenated after the block. This design reduces computation and enriches gradient propagation. The structure is illustrated in the paper.
Given a loss function \(L(\mathbf{y}, \mathbf{y}_t)\), where \(\mathbf{y}\) is the module output and \(\mathbf{y}_t\) is the ground truth, the gradient with respect to weight \(w_0\) in a CSP structure contains two paths:
$$
\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}
$$
This richer gradient composition helps the network converge to better optima.
The MobileNet module, on the other hand, uses an inverted residual structure. It first expands the feature channels with a 1×1 convolution, applies depthwise separable convolution in the high-dimensional space, and then projects back with a linear 1×1 convolution. The computational cost of depthwise separable convolution is:
$$
C_2 = H^2 K^2 C_{in} + H^2 C_{in} C_{out}
$$
while standard convolution costs:
$$
C_1 = H^2 C_{in} C_{out} K^2
$$
The ratio is \(C_2/C_1 = 1/C_{out} + 1/K^2\), which is considerably lower when \(K\) is large.
The ConvNeXt module resembles a large-kernel depthwise convolution followed by 1×1 convolutions. It uses fewer activation functions and normalization layers, which sacrifices some nonlinearity but can improve speed. For small object detection, however, the lack of nonlinearity may hurt the ability to model complex distributions.
2.2 Detection Model Components
A typical one-stage detection network consists of a backbone, a feature pyramid network, and detection heads. The backbone extracts hierarchical features. The FPN merges multi-scale features. The detection head predicts categories and bounding boxes. YOLOX uses a decoupled head that separates classification, regression, and objectness branches. This decoupling avoids conflicts between tasks and speeds up convergence.
Positive and negative sample assignment is vital. I discuss both anchor-based and anchor-free strategies. OTA (Optimal Transport Assignment) dynamically assigns samples by solving an optimal transport problem. The Adam optimizer is employed in some experiments, while SGD with momentum is used in most of my training.
2.3 UAV Datasets
I compare several public UAV datasets: UAVDT, AU-AIR, DroneVehicle, and VisDrone2019. The comparisons are summarized in the following table.
| Dataset | Number of Images | Tasks | Number of Classes |
|---|---|---|---|
| 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 dataset for UAV detection. It contains more than 2.6 million annotated bounding boxes. I adopt VisDrone2019 as the benchmark dataset in this thesis. I exclude the “ignored regions” and “others” categories and only evaluate on 10 meaningful object classes: pedestrian, people, bicycle, car, van, truck, tricycle, awning-tricycle, bus, and motorcycle. The test set statistics show that over 65% of objects are small or extremely small, making this dataset ideal for evaluating small-object detectors.
3. Small Object Detection Algorithm Based on High-Dimensional Feature Extraction
3.1 Problem Analysis
Most convolutional backbones reduce the resolution of feature maps by strided convolutions or pooling. For an input of 640×640 pixels, the final feature map size is only 20×20. This design is efficient for large objects but fails to preserve fine details for small objects. Bottleneck residual structures, such as ResNet and CSPResBlock, first map the input to a low-dimensional space. This operation may cause small object details to vanish because low-dimensional spaces have limited capacity. Inverted residual structures map to a high-dimensional space but use “additive” skip connections, which can amplify responses of already strong large object regions while suppressing weak small object regions.
3.2 ATDE Module
I design the ATDE (Attention To Detail) module. Its structure is shown in the figure. The module first applies several depthwise separable convolutions with kernel size \(k \times k\). After each convolution, a BN layer and SiLU activation are used. The original input and all intermediate feature maps are concatenated along the channel dimension. This multi-level Concat structure preserves rich information and provides diverse gradient paths.
BN computes:
$$
\hat{x}_i = \frac{x_i – \mu_{\mathcal{B}}}{\sqrt{\sigma_{\mathcal{B}}^2 + \epsilon}} \cdot \lambda + \beta
$$
SiLU is:
$$
SiLU(x) = x \cdot \frac{1}{1 + e^{-x}}
$$
The concatenated tensor has \((1+\text{num})\cdot \text{dim} \cdot n\) channels after a 1×1 convolution. This high-dimensional mapping allows the network to separate features more easily and retain important spatial details. Finally, another 1×1 convolution reduces the channels back to the original number \(n\).
3.3 Loss Function
I improve the YOLOX-S loss by adding an auxiliary localization loss based on Mean Absolute Error (MAE). The total loss is:
$$
Loss = \frac{L_{cls} + L_{obj} + L_{reg}^1 + L_{reg}^2}{N_{pos}}
$$
where \(L_{cls}\) and \(L_{obj}\) are binary cross-entropy losses, \(L_{reg}^1\) is the IoU loss, and \(L_{reg}^2\) is the MAE loss on bounding box coordinates.
3.4 Experiments
I train on the VisDrone2019 training set (6471 images) and validate on the validation set (548 images). The input resolution is 640×640. I use the SGD optimizer with a batch size of 8, momentum 0.9, weight decay 0.0005, and a learning rate of 0.01. All models are trained for 150 epochs with the last 20 epochs using no data augmentation. The hardware setup consists of an NVIDIA TITAN Xp GPU and the MMDetection framework.
First, I conduct a visualization experiment to show the effect of high-dimensional expansion. The feature maps with dim = 0, 1, 2, 4 are displayed. As dim increases, the feature maps become more detailed, and small object areas are better preserved. The results are consistent on both training and test images.
Then, I perform ablation experiments with different expansion ratios. The results are shown below.
| Stage1 Block | AP0.5:0.95 | AP0.5 | FPS | Param (M) | APsmall | APmedium | APlarge |
|---|---|---|---|---|---|---|---|
| CSPResBlock | 0.175 | 0.327 | 66.9 | 8.941 | 0.090 | 0.262 | 0.349 |
| ATDEdim=0 | 0.181 | 0.340 | 70.4 | 8.94 | 0.093 | 0.272 | 0.354 |
| ATDEdim=1 | 0.183 | 0.341 | 68.6 | 8.966 | 0.097 | 0.271 | 0.378 |
| ATDEdim=2 | 0.186 | 0.346 | 68.5 | 8.991 | 0.097 | 0.276 | 0.391 |
| ATDEdim=4 | 0.190 | 0.353 | 68.3 | 9.04 | 0.100 | 0.278 | 0.374 |
Even with dim = 0, the ATDE module outperforms the baseline because of the Concat structure and depthwise separable convolutions. Higher dim values further improve small-object AP, with dim = 4 giving the best AP0.5 of 35.3%.
I also compare different convolutional modules placed in the Stage1 position.
| Stage1 Block | AP0.5:0.95 | AP0.5 | FPS | Param (M) | APsmall | APmedium | APlarge |
|---|---|---|---|---|---|---|---|
| ConvNeXt | 0.170 | 0.321 | 63.2 | 8.959 | 0.086 | 0.257 | 0.342 |
| MobileNet | 0.186 | 0.345 | 68.7 | 9.025 | 0.097 | 0.276 | 0.373 |
| ResNet | 0.172 | 0.323 | 69.6 | 8.936 | 0.088 | 0.258 | 0.341 |
| ResNeXt | 0.172 | 0.323 | 68.3 | 8.928 | 0.087 | 0.258 | 0.364 |
| ATDEdim=4 | 0.190 | 0.353 | 68.3 | 9.04 | 0.100 | 0.278 | 0.374 |
ConvNeXt performs worst, confirming that fewer activation functions and normalization layers hurt small object detection. MobileNet, which maps features to a high-dimensional space, performs much better than ResNet. However, ATDE still outperforms MobileNet due to the multi-level Concat and high-dimensional expansion design.
4. Small Object Detection Algorithm Based on SGRF Strategy
4.1 Problem Analysis
The receptive field \(RF_n\) at layer \(n\) is defined as the region in the input image that affects one output pixel. It can be calculated recursively:
$$
RF_n = RF_{n-1} + (k_n – 1) \prod_{i=1}^{n-1} s_i
$$
where \(k_n\) is the kernel size at layer \(n\) and \(s_i\) is the stride of layer \(i\). A larger receptive field provides more context but can also include too many unrelated objects. For small objects, an excessively large receptive field causes the network to see a large area containing multiple objects, which may lead to missed detections. Conversely, a too-small receptive field may fail to capture the whole object.
4.2 SGRF Strategy
The proposed Slow Growth Receptive Field strategy has two goals: enlarge shallow receptive fields and reduce the growth speed of receptive fields in deeper layers. This is achieved through the following techniques:
Simplified Stem. Instead of using the Focus module, I directly apply a stride-2 3×3 convolution to the input RGB image. The Focus operation slices the image and reduces resolution, which blurs edges and corners that are crucial for small object detection. Direct convolution preserves the original spatial structure better.
Large Kernel in Shallow Layers. I replace the 3×3 depthwise convolution in the Stage1 ATDE module with a 7×7 depthwise convolution. This creates a larger and more effective receptive field. The effective receptive field of a 7×7 convolution is far larger than that of stacked 3×3 convolutions of the same depth, and it allows the network to learn shape bias rather than only texture bias.
Reduced Kernel Sizes in Later Stages. Instead of keeping the same kernel size for all stages, I gradually reduce the kernel size: (7, 5, 3, 3). This prevents the receptive field from growing too quickly.
Reduced Depth in Stage2. The original Stage2 had 3 residual blocks. I reduce it to 1 block, so that the first prediction feature map retains more spatial details.
MixSPP Module. In the last stage, I design a Mixed Spatial Pyramid Pooling module. It runs feature extraction conv and three max-pooling branches in parallel, then fuses them layer by layer. This structure reduces parameters and slows the receptive field increase while maintaining representation power.
4.3 ATDeNet Architecture
Based on the SGRF strategy, I propose a new backbone network named ATDeNet. Its structure is depicted in the figure. The stem is a stride-2 3×3 convolution with 32 output channels. In Stage1, an ATDE module with kernel size 7, depth 1, and dim=4 is used. Stage2 uses ATDE with kernel size 5, depth 1, and dim=3. Stage3 uses ATDE with kernel size 3, depth 3, and dim=1. Stage4 uses MixSPP. The output feature maps are taken from Stages 2, 3, and 4. The PAFPN and decoupled head remain unchanged from YOLOX-S.
4.4 Experiments
I first test different kernel sizes in Stage1.
| Stage1 Kernel | AP0.5:0.95 | AP0.5 | FPS | Param (M) | APsmall | APmedium | APlarge |
|---|---|---|---|---|---|---|---|
| K=3 | 0.190 | 0.353 | 68.3 | 9.04 | 0.100 | 0.278 | 0.374 |
| K=5 | 0.191 | 0.354 | 68.0 | 9.041 | 0.101 | 0.280 | 0.381 |
| K=7 | 0.193 | 0.356 | 67.7 | 9.042 | 0.104 | 0.286 | 0.405 |
| Dilated r=3 | 0.186 | 0.346 | 67.4 | 9.04 | 0.097 | 0.275 | 0.390 |
The 7×7 convolution gives the best results, while the dilated convolution with equivalent theoretical receptive field performs worse due to missing local contiguous information.
Next, I verify the effectiveness of MixSPP by replacing the SPP and following CSPBlock in the baseline YOLOX-S.
| Stage4 Block | AP0.5:0.95 | AP0.5 | FPS | Param (M) | APsmall | APmedium | APlarge |
|---|---|---|---|---|---|---|---|
| SPP+CSPBlock | 0.175 | 0.327 | 66.9 | 8.941 | 0.090 | 0.262 | 0.349 |
| MixSPP | 0.175 | 0.330 | 68.8 | 8.422 | 0.090 | 0.263 | 0.386 |
MixSPP reduces the parameters by about 0.5M and slightly improves AP0.5, confirming that it is an efficient substitute.
To validate the SGRF strategy, I compare the gradually reduced kernel sizes (7,5,3,3) with three fixed-kernel designs. The results are shown below.
| Kernel Sizes | AP0.5:0.95 | AP0.5 | FPS | Param (M) | APsmall | APmedium | APlarge |
|---|---|---|---|---|---|---|---|
| (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 SGRF strategy (7,5,3,3) achieves the highest AP0.5 of 36.8%, outperforming all fixed-size designs. This confirms that slowing down the growth of deep receptive fields is beneficial for small object detection in unmanned aerial vehicle imagery.
I also compare ATDeNet with other popular backbones under the same detection framework.
| Backbone | AP0.5:0.95 | AP0.5 | FPS | Param (M) | APsmall | APmedium | APlarge |
|---|---|---|---|---|---|---|---|
| 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 achieves the best overall performance. It improves AP0.5 by 4.1 percentage points over the baseline CSPDarkNet while also improving the inference speed.
To ensure robustness, I also replace the backbone of YOLOv8-S with ATDeNet.
| Backbone in YOLOv8 | AP0.5:0.95 | AP0.5 | FPS | Param (M) | APsmall | APmedium | APlarge |
|---|---|---|---|---|---|---|---|
| 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.98 | 0.100 | 0.315 | 0.427 |
The improvement of 2.8% in AP0.5 demonstrates that ATDeNet is a robust backbone that works well beyond the custom detection framework.
I also test the algorithms at a higher input resolution of 800×800.
| Backbone at 800×800 | AP0.5:0.95 | AP0.5 | FPS | Param (M) | APsmall | APmedium | APlarge |
|---|---|---|---|---|---|---|---|
| CSPDarkNet (YOLOX-S) | 0.204 | 0.377 | 66.0 | 8.941 | 0.120 | 0.294 | 0.344 |
| ATDeNet | 0.221 | 0.404 | 68.5 | 9.649 | 0.134 | 0.317 | 0.371 |
ATDeNet still outperforms the baseline at higher resolution, confirming its robustness.
Training curves and confusion matrices are also provided. The loss curves of ATDeNet are consistently lower than those of CSPDarkNet for both classification and regression. The confusion matrix shows that ATDeNet improves the diagonal accuracy for almost all categories.
Visualization of detection results on selected test images shows that ATDeNet successfully finds more tiny objects in crowded scenes, weak-light scenes, and partially occluded scenes.
5. Adaptive Low-Light Enhancement System for UAV Detection
5.1 Requirement Analysis
UAV images are frequently affected by uneven illumination or dark frames. In addition, nighttime detection is inherently difficult because artificial lights create strong shadows and large dark regions. Small objects in such images lose most of their features, and the detection performance degrades substantially. To increase the stability of UAV detection systems, an adaptive preprocessing step is needed.
5.2 Analysis of Low-Light Enhancement Methods
Traditional methods include Histogram Equalization (HE) and Retinex-based methods. HE creates a mapping based on the cumulative histogram to stretch the dynamic range. However, HE often over-amplifies noise and distorts colors, especially in RGB images. Retinex-based methods decompose an image into reflectance and illumination components. The reflectance component is regarded as the intrinsic property of objects and is used as the enhanced result. However, these methods rely on hand-crafted priors and often produce artifacts.
Deep learning methods have become dominant. Retinex-Net uses a decomposition network to separate reflectance and illumination. KinD further introduces a reflectance restoration network and an illumination adjustment module. MBLLEN uses a multi-branch CNN to enhance images directly. A particularly effective approach is EnlightenGAN, an unsupervised generative adversarial network that does not require paired training data. Its enhancement results are cleaner and show more details than other methods. Therefore, I choose EnlightenGAN as the basis for my enhancement module.
5.3 System Design
The proposed system consists of three modules: a low-light recognition module, a low-light enhancement module, and a detection module. The detection module uses the ATDeNet based algorithm from the previous chapter.
Low-light recognition module. I compute a gray-level image from the RGB input, then use a sliding window of size 200×200 with a stride of 80. For each window, I calculate the mean \(\mu\) and variance \(\sigma^2\). The brightness metric \(\theta_i\) is defined as:
$$
\theta_i = \mu + 0.1 \sigma^2
$$
A window is considered dark if \(\theta_i < 120\). If more than one quarter of all windows are dark, the image is classified as low-light and sent to the enhancement module.
Low-light enhancement module. The enhancement module is a U-Net generator trained in an adversarial manner. I use a global discriminator and a local discriminator to focus on both global and local realism. The generator takes the input dark image and a self-regularized attention map computed as \(1 – I\), where \(I\) is the grayscale luminance. The U-Net contains five layers. To improve the receptive field, I replace the original two stacked 3×3 convolutions in each layer with a single 7×7 convolution. The relative discriminators are defined as:
$$
D_{r,f}(x_r, x_f) = \sigma ( C(x_r) – \mathbb{E}_{x_f \sim P_{fake}}[C(x_f)] )
$$
$$
D_{f,r}(x_f, x_r) = \sigma ( C(x_f) – \mathbb{E}_{x_r \sim P_{real}}[C(x_r)] )
$$
where \(C(\cdot)\) is the probability of being a real normal-light image.
I also add a self-feature preserving loss. It compares the feature maps of the original dark image and the generated enhanced image using the ATDeNet backbone. The loss is:
$$
L_{SFP} = \sum_{i=1}^{W_i H_i} \| \phi_i(I) – \phi_i(G(I)) \|^2
$$
The total loss combines global and local adversarial losses and self-feature preserving losses:
$$
Loss = L_{global} + L_{local} + L_{SFP}^{global} + L_{SFP}^{local}
$$
5.4 Experiments
I first evaluate the recognition module on the LOL dataset. The module processes an image in about 9.6 ms. The accuracy on dark images is 98.7% and on normal images is 95.4%, as shown below.
| Image Type | Number | Total Time | Accuracy |
|---|---|---|---|
| Dark | 485 | 4.65 s | 98.7% |
| Normal | 485 | 4.65 s | 95.4% |
I also test on images selected from VisDrone2019.
| Image Type | Number | Total Time | Accuracy |
|---|---|---|---|
| Dark | 480 | 17.7 s | 92.5% |
| Normal | 300 | 15.1 s | 96.7% |
Then, I select 480 low-light images from the VisDrone2019 test set and compare two approaches: direct detection with the ATDeNet detector (Model A), and detection after enhancement (Model B). The results are shown below.
| Model | AP0.5 |
|---|---|
| Model A (direct) | 0.302 |
| Model B (enhanced first) | 0.343 |
Enhancement improves AP0.5 by 4.2 percentage points, almost recovering the performance on normal-light images. Visualization results show that the system significantly increases the confidence scores of detected vehicles and reduces missed cars in dark regions.
6. Conclusion and Future Work
In this thesis, I have studied object detection in unmanned aerial vehicle scenarios and proposed several improvements. First, I introduced the ATDE module to enhance the feature extraction capability of shallow layers. Second, I proposed the SGRF receptive field allocation strategy to better balance the receptive field sizes across stages. Third, I developed an adaptive low-light enhancement system to improve detection robustness under poor illumination. The proposed methods have been thoroughly evaluated on the VisDrone2019 dataset. The results show significant improvements in average precision while maintaining real-time inference speed.
There are several directions for future research. First, the SGRF strategy slightly reduces the AP for large objects. Finding a better balance between small and large object detection remains an open problem. Second, the detection accuracy for highly oblique camera angles is still lower than for vertical top-down views. Data augmentation or viewpoint-aware feature extraction may help. Third, the low-light enhancement module and detector are trained separately. An end-to-end training scheme could further improve the overall performance. Finally, occlusion-aware detection in dynamic UAV videos is an interesting and challenging topic that deserves further investigation.