Locate then Calibrate: A Synergistic Framework for Small Object Detection from Aerial Imagery to Ground-Level Views

Highlights

What are the main findings?

• A synergistic “Locate then Calibrate” (LTC) framework is proposed, which combines spatial attention (to locate targets) with a novel adaptive multi-scale module (to calibrate features).
• The proposed LTC framework achieves a remarkable 11.7% increase in mAP50 over the YOLOv8 baseline on the challenging VisDrone dataset and demonstrates strong cross-domain generalization, significantly outperforming the baseline on ground-level datasets (e.g., KITTI and TT100K_mini).

What is the implication of the main finding?

• The LTC framework provides a more robust and reliable perception solution for safety-critical applications such as UAV-based aerial surveillance and autonomous driving.
• The “Locate then Calibrate” strategy offers a new and effective design principle for object detectors, demonstrating that decoupling spatial localization from scale adaptation is highly beneficial for small object detection.

Abstract

Detection of small objects in aerial images captured by Unmanned Aerial Vehicles (UAVs) is a critical task in remote sensing. It is vital for applications like urban monitoring and disaster assessment. This task, however, is challenged by unique viewpoints, diminutive target sizes, and dense scenes. To surmount these challenges, this paper introduces the Locate then Calibrate (LTC) framework. It is a deep learning architecture designed to enhance visual perception systems, specifically for the accurate and robust detection of small objects. Our model builds upon the YOLOv8 architecture and incorporates three synergistic innovations. (1) An Efficient Multi-Scale Attention (EMA) mechanism is employed to ‘Locate’ salient targets by capturing critical cross-dimensional dependencies. (2) We propose a novel Adaptive Multi-Scale (AMS) convolution module to ‘Calibrate’ features, using dynamically learned weights to optimally fuse multi-scale information. (3) An additional high-resolution P2 detection head preserves the fine-grained details essential for localizing diminutive targets. Extensive experimental evaluations demonstrate that the proposed model substantially outperforms the YOLOv8n baseline. Notably, it achieves significant performance gains on the challenging VisDrone aerial dataset. On this dataset, the model achieves a remarkable 11.7% relative increase in mean Average Precision (mAP50). The framework also shows strong generalization. Considerable improvements are recorded on ground-level autonomous driving benchmarks such as KITTI and TT100K_mini. This validated effectiveness proves that LTC is a robust solution for high-accuracy detection: it achieves significant accuracy gains at the cost of a deliberate increase in computational GFLOPs, while maintaining a lightweight parameter count. This design choice positions LTC as a solution for edge applications where accuracy is prioritized over minimal computational cost.

1. Introduction

Low-altitude remote sensing via Unmanned Aerial Vehicles (UAVs) plays a vital role in urban planning, disaster response, and precision agriculture [1]. The ability to accurately detect small objects from these images is critical. Aerial imagery, however, presents a formidable challenge due to diminutive target sizes, extreme object density, and complex backgrounds. This challenge is not unique to aerial platforms; it represents a core bottleneck in other critical domains. One notable example is ground-level autonomous driving, where perception systems must reliably detect distant pedestrians or traffic signs [2]. Therefore, efficient and robust small object detection remains a fundamental and cross-domain problem for resource-constrained intelligent systems.

Regardless of the viewpoint, lightweight models face three fundamental technical challenges when processing small objects:

1.

Feature Erosion: The fine-grained spatial details representing diminutive targets often span just a few pixels. These details are progressively diluted or entirely lost during the aggressive downsampling in the network’s backbone.

2.

Scale Mismatch and Feature Contamination: The large receptive fields of deep convolutional layers often engulf small targets. This causes their features to be overwhelmed and contaminated by dominant background textures.

3.

Label Assignment Instability: Metrics such as Intersection over Union (IoU) are notoriously volatile for small objects. Minor pixel-level perturbations in a predicted box can induce drastic IoU fluctuations, destabilizing the dynamic label assignment process (like the Task-Aligned Assigner) used by modern detectors and hindering robust model convergence.

Existing detectors struggle to resolve these challenges simultaneously. On one hand, lightweight one-stage detectors, such as YOLOv8 [3], provide a strong foundation for real-time analysis. But their standard architecture is inherently vulnerable to feature erosion, and their static feature fusion mechanisms are also insufficient to handle severe scale mismatch. In contrast, heavyweight State-of-the-Art (SOTA) models, such as Transformer-based architectures (e.g., DINO-DETR [4]) and emerging Mamba-style models (e.g., Vision Mamba [5], VMamba [6], etc.), have demonstrated exceptional performance in modeling global dependencies. Such models often rely on complex attention mechanisms to capture long-range feature interactions, for example, Multi-Head Self-Attention or its more efficient variants (e.g., Efficient Multi-Scale Attention [7]). They achieve significant performance gains in object detection and visual understanding tasks.

However, these heavyweight models universally possess massive parameter scales and extremely high computational complexity. This imposes stringent demands on memory, computing power, and bandwidth. Although Mamba-style architectures theoretically feature linear time complexity, their current implementations still rely on deep network structures and large-scale state-space modeling. This makes real-time inference in resource-constrained environments challenging. Consequently, such models are often difficult to deploy directly on edge computing platforms (e.g., UAV on-board processors or in-vehicle computers), limiting their practicality in applications with low-power and high-real-time requirements, such as aerial remote sensing and intelligent driving. Based on this, this paper focuses on designing an architecture that achieves high computational efficiency and lightweight feature expression while ensuring detection accuracy, aiming to realize a high-performance edge visual perception system.

To directly address the three aforementioned technical challenges without significantly impacting computational efficiency, we propose the Locate then Calibrate (LTC) framework. The LTC framework is a synergistic enhancement of the YOLOv8n baseline. It is engineered with three key components mapped directly to these challenges:

1.

To combat feature erosion and assignment instability, we augment the framework with a high-resolution P2 detection head. This preserves the fine-grained details necessary for localization and provides a more stable feature foundation for the label assigner.

2.

To mitigate feature contamination, we introduce the Efficient Multi-Scale Attention (EMA) mechanism to perform the “Locate” step. It captures global context to help the model focus on salient target regions and suppress background noise.

3.

To resolve the scale mismatch, we propose a novel Adaptive Multi-Scale (AMS) convolution module as the “Calibrate” step. This module dynamically re-calibrates multi-scale features, learning to optimally fuse target information based on the input content.

In order to validate the LTC framework’s accuracy and robustness, we conducted extensive experiments on multiple public datasets. The results show that LTC not only outperforms its YOLOv8n baseline and other competitive lightweight methods in the remote sensing domain but also shows excellent generalization across different domains.

Section 2 reviews related work in object detection and attention mechanisms, and details the LTC framework, elaborating on the architecture of the AMS module and its synergy with EMA and the P2 head. Section 3 mainly presents a comprehensive analysis of the model’s performance. Section 4 interprets the experimental findings, analyzing the framework’s limitations. And Section 5 concludes the paper with a summary of our findings and discusses potential directions for future research.

2. Materials and Methods

2.1. Related Work

2.1.1. The Computational Dilemma of Transformer and Mamba

Compared to lightweight models, heavyweight models often yield better performance on small object detection. But, in terms of parameters and GFLOPs, their values are typically much higher than those of lightweight models, which makes them difficult to deploy on edge devices. This section will discuss Transformer and its variants and Mamba-style architectures.

In order to overcome the locality constraints of traditional CNNs in capturing long-range dependencies, the Vision Transformer (ViT) [8] introduced the self-attention mechanism. This mechanism allows every image patch to interact directly with all other patches, achieving a truly global receptive field and enabling breakthroughs in numerous visual tasks.

However, ViT’s global modeling capability comes at a high computational cost. The complexity of its self-attention mechanism is quadratic to the number of input patches (N), i.e., $O\left(N^2\right)$ [9]. As the spatial resolution of remote sensing or autonomous driving imagery increases, N grows rapidly, causing an explosive increase in ViT’s computational and memory demands, creating a severe “scalability crisis” [10]. This theoretical quadratic complexity translates to immense practical overhead. For instance, models like DETR [11] and its SOTA variant DINO-DETR, while achieving impressive performance using global attention, are computationally exorbitant.

To address ViT’s complexity, the Mamba architecture [12], based on Structured State Space Models (SSMs), emerged. Through an innovative selective scan mechanism (SSM), Mamba theoretically reduces the computational complexity to linear time, $O\left(N\right)$, while still modeling global context.

However, theoretical linear complexity does not equate to practical lightweight performance. The SOTA race, whether Transformer or Mamba-based, aims to maximize performance, not minimize cost. Consequently, emerging Mamba-style detectors (e.g., PanMamba [13] or MambaVision [14]) and optimized Transformers (e.g., RT-DETR [15]) still rely on massive parameter scales and high computational loads to achieve top performance on standard benchmarks, despite their efficiency improvements.

Therefore, these SOTA paradigms (both Transformer and Mamba) operate in a completely different computational class from lightweight models. This high performance is achieved at the cost of immense computational complexity, making them computationally infeasible for the real-time, on-board processing needs we focus on. As we summarize in

Table 1. Computational Cost Comparison: Lightweight (Edge) vs. Heavyweight (SOTA) Models.

Model	Params (M)	GFLOPs
RSM-CD	27.9	742.8
DINO-4scale	47	279
VMamba-T	50	271
RT-DETR [R50]	42	136
MambaBCD-Tiny	17.13	45.74
UAV-DETR-EV2	13	43
M-CD	69.8	29.58
YOLOv8n	3	8.1

Note: Models are sorted primarily in descending order of GFLOPs, and secondarily by Params (M). And the bold numbers indicate the lowest resource consumption in each column.

, the parameters and GFLOPs of these models are often an order of magnitude larger than our lightweight baseline (YOLOv8n). For instance, numerous recent SOTA models, whether they are general-purpose Transformer variants (e.g., DINO-4scale, RT-DETR (R50)) or specialized Mamba-style architectures for remote sensing (e.g., RSM-CD, M-CD [16], MambaBCD-Tiny [17], UAV-DETR-EV2 [18]), all fall into this heavyweight category.

Given this, our comparisons in the Results section (Section 3) will primarily focus on SOTA lightweight models published in the last year that are also based on the YOLO framework and specialize in small object detection.

2.1.2. Object Detection Paradigms and Baseline Choice

Our work is positioned in the critical domain of lightweight object detection, specifically targeting deployment on resource-constrained edge platforms like UAVs and in-vehicle systems. In this track, the primary challenge is maximizing detection accuracy under a strict computational budget. One-stage detectors, particularly the YOLO series [19,20,21], have become the de facto standard due to their exceptional balance of speed and accuracy.

YOLOv8, an influential version from Ultralytics, achieves a representative balance between detection speed and accuracy. Its architecture comprises an input pipeline, backbone, neck, and head. Compared to its predecessor YOLOv5, YOLOv8 introduces a more efficient C2f-based backbone and a Decoupled Head [22], which improves training stability and final accuracy by separating classification and regression tasks. In the neck, YOLOv8 retains the PAN topology [23] while enhancing feature fusion efficiency by simplifying upsampling stages and upgrading the SPP module [24] to the more efficient SPPF. Notably, YOLOv8 employs an anchor-free design and is available in multiple scales, from n (nano) to x (xlarge).

Although newer models like YOLOv11 [25] and YOLOv12 [26] have shown superior performance on standard benchmarks, this work intentionally selects YOLOv8n as the baseline. This decision is based not only on its core design, which provides an excellent and representative balance of accuracy and efficiency for resource-constrained hardware, but also on its mature ecosystem and broad community support, which are crucial for ensuring experimental reproducibility. Our research objective is therefore to develop and validate innovative perception algorithms for multi-scenario small object detection on this proven platform.

Given this fundamental difference in application tracks, our primary comparisons (in Section 3) focus on other SOTA lightweight models that share a similar computational budget. This section’s discussion aims to clearly position our work among all paradigms, clarifying that our contribution is an optimized solution for resource-constrained edge platforms that balances efficiency and accuracy.

2.1.3. Related Strategies for Small Object Detection

To address the three challenges mentioned in the Introduction (feature erosion, feature contamination, and assignment instability), various strategies have been proposed in the literature.

To combat feature erosion, enhancing multi-scale feature fusion is a primary approach. Since FPN [27] and PANet became standard, research has focused on optimizing the feature pyramid. A direct strategy involves incorporating feature maps from shallower, higher-resolution layers, such as the P2 layer, to preserve the fine-grained spatial details of minute targets. The efficacy of shallow features in boosting small object detection has been validated in works like YOLOv7 variants [28].

To address feature contamination and background noise, attention mechanisms are widely employed. Lightweight channel attention (e.g., SE-Net [29]) or spatial-temporal attention (e.g., CBAM [30] and our adopted EMA) have been shown to effectively help models “locate” salient feature regions and suppress irrelevant background noise, thereby improving the signal-to-noise ratio.

To handle label assignment instability, especially the volatility of IoU for small objects, research has shifted from traditional anchor-based static assignment to anchor-free dynamic assignment strategies. Dynamic assigners can adaptively assign positive and negative samples based on the quality and distribution of predictions. However, as noted in our Introduction, the stability of these strategies remains challenged when facing extremely diminutive targets. Our work builds upon these existing strategies, synergistically combining them to systematically address the aforementioned challenges.

2.2. Methodology

As illustrated in Figure 1, the proposed LTC architecture extends the foundational YOLOv8n framework—comprising a backbone, neck, and head—with three synergistic enhancements specifically engineered for small object detection. Specifically, we (1) substitute key C2f blocks with C2f-AMS modules for adaptive feature fusion; (2) incorporate the Efficient Multi-Scale Attention (EMA) mechanism into the backbone to refine feature salience; and (3) augment the neck with a high-resolution P2 detection head to preserve fine-grained details. The design principles and technical details of these components are elaborated upon in the subsequent sections.

2.2.1. The AMS Module

This section details the design of the proposed Adaptive Multi-Scale (AMS) convolution module, a novel component engineered for efficient and adaptive feature fusion. The detailed architecture of the AMS module is illustrated in Figure 2. The design is conceptually motivated by the principle of feature redundancy, as effectively exploited by the lightweight network GhostNet [31]. The central tenet of GhostNet is to approximate the output of a standard convolution through a more computationally parsimonious, two-stage process. It first employs a primary convolution to generate a set of “intrinsic” feature maps, which capture the core characteristics of the input. Subsequently, it applies a series of lightweight linear operations to these intrinsic maps to produce supplementary “ghost” features. By concatenating these two feature sets, GhostNet significantly reduces parametric and computational costs while maintaining a comparable feature representation capacity. Building upon this principle of computational efficiency, Li Jin et al. introduced the Efficient Multi-Scale Convolution Pyramid (EMSCP) module [32].

The EMSCP module is designed to efficiently fuse multi-scale feature information. Its core mechanism involves splitting the input feature map into four parallel branches along the channel dimension. Each branch is then processed by a convolutional kernel of a different size (1 × 1, 3 × 3, 5 × 5, and 7 × 7, respectively). This design aims to simultaneously capture diverse levels of information, from fine-grained local details to broad contextual information. Subsequently, the output feature maps from all branches are concatenated and passed through a final 1 × 1 convolution for information integration and channel dimension restoration. Compared to using a single large-kernel convolution, this architecture acquires rich multi-scale features at a lower computational cost.

However, the analysis reveals a fundamental limitation of the EMSCP module: its input-agnostic static feature fusion strategy. The simple concatenation operation is tantamount to assigning a fixed and uniform weight to each scale branch. In practice, the importance of different scales is highly dynamic and content-dependent; scenes with small objects demand greater attention to fine-grained features (captured by small kernels), whereas those with large objects rely more on global context (captured by large kernels). EMSCP’s static fusion mechanism cannot adapt to these variations in input, leading to a sub-optimal representation where critical scale-specific information is diluted by redundant features, thereby limiting its performance in complex scenarios.

To overcome this limitation, we propose the Adaptive Multi-Scale (AMS) module, which introduces a novel Adaptive Scale Attention mechanism. This mechanism transforms the feature fusion from a passive, static aggregation into an active, content-dependent selection process. Specifically, a lightweight weight-learning network first leverages Global Average Pooling (GAP) [33] to generate a global context descriptor. Based on this descriptor, the network dynamically generates a unique attention weight for each parallel scale branch. In this manner, the AMS module selectively enhances the most informative scale-specific features while suppressing the others. This ensures the fused representation is optimally tailored to the input content, significantly improving the model’s adaptability and accuracy.

While this mechanism is inspired by channel attention networks such as SENet, the Adaptive Scale Attention operates on a fundamentally different dimension. SENet recalibrates the importance of features along the channel dimension. In contrast, the AMS module operates on the scale dimension, addressing the distinct challenge of dynamically allocating weights among parallel multi-scale branches. This approach elevates the concept of attention from the channel level to a structural, scale-wise level, offering a new perspective on multi-scale representation learning.

The process begins by splitting the input feature map $X\in {\mathbb{R}}^{C\times H\times W}$ evenly into N sub-feature maps $X_i\in {\mathbb{R}}^{(C/N)\times H\times W}$ along the channel dimension. Each sub-feature map is then fed into a separate branch with a specific kernel size for feature extraction, yielding a corresponding output feature map $F_i$ This operation is formulated as:

$$F_i={\mathrm{Conv}}_i\left(X_i\right),i=1,2,3,4$$

(1)

Here, ${\mathrm{Conv}}_1$, ${\mathrm{Conv}}_2$, ${\mathrm{Conv}}_3$, and ${\mathrm{Conv}}_4$ represent convolution operations with kernel sizes of 1 × 1, 3 × 3, 5 × 5, and 7 × 7 respectively.

The core innovation of the AMS module is its adaptive weight-learning network, which dynamically generates a set of weights $W=[W_1,W_2,W_3,W_4]$, based on the input feature map X. This process consists of two primary stages: adaptive weight generation and weighted feature fusion.

Adaptive Weight Generation

The generation of adaptive weights is a three-step process designed to convert the input feature map into a compact and informative set of weights for each scale branch:

• Global Information Squeeze: The process begins by capturing a global context descriptor from the input feature map. We hypothesize that the spatial distribution of features correlates with object size; small objects produce localized, sharp activations, while large objects produce more dispersed activations. To capture this, we use Global Average Pooling (GAP) to squeeze the entire feature map X into a single channel-wise descriptor vector z:

  $$z=\mathrm{GAP}\left(X\right)$$

  (2)
  This vector z encapsulates the global response intensity for each channel, serving as an effective summary of the scene’s characteristics.
• Weight Excitation: The global descriptor z is then fed into a lightweight network to learn the mapping from global information to branch importance. This is implemented using a simple 1 × 1 convolution, which acts as an efficient channel-wise fully connected layer, to produce a raw weight vector (logits) $w^{\prime }$:

  $$w^{\prime }={\mathrm{Conv}}_{1\times 1}\left(z\right)$$

  (3)
  The parameters of this convolutional layer are learned end-to-end with the rest of the network.
• Weight Normalization: To ensure the weights represent a probability distribution and to encourage competition among the branches, the Softmax function is applied to the raw weight vector $w^{\prime }$. This normalizes the weights so that they sum to 1 and amplifies the importance of the most relevant scale(s):

  $$W=\mathrm{Softmax}\left(w^{\prime }\right)$$

  (4)

Weighted Feature Fusion

After obtaining the adaptive weights W and the output features $F_i$ from each of the four scale branches, the AMS module performs a dynamic weighted fusion. Each feature map $F_i$ is scaled by its corresponding learned weight $w_i$. These weighted feature maps are then fused via summation to produce the final aggregated feature map, $F_{AMS}$:

$$F_{AMS}=\sum _{i=1}^4{w}_i·F_i$$

(5)

Finally, a 1 × 1 convolution is applied to the fused features to enable cross-channel information interaction and produce the final output Y of the AMS module:

$$Y={\mathrm{Conv}}_{1\times 1}\left(F_{AMS}\right)$$

(6)

This process allows the AMS module to dynamically re-calibrate the contribution of each scale branch based on the input features, shifting from a static aggregation to an active, content-aware selection of information.

2.2.2. The EMA Mechanism

In complex visual perception tasks, the random movement of vehicles and pedestrians, frequent object occlusions, and backgrounds with features similar to targets all pose significant challenges. These multi-scale interfering factors can degrade a model’s recognition accuracy, leading to missed or false detections and compromising the safety of critical applications. To address these issues, we introduce the Efficient Multi-Scale Attention (EMA) mechanism. Figure 3 shows the overall structure of the EMA mechanism.

Attention mechanisms were proposed to overcome the limitations of traditional Convolutional Neural Networks (CNNs) in complex scenarios. By learning to weigh feature maps, attention modules enable a model to focus on salient target regions while suppressing irrelevant background information, thereby enhancing its feature discrimination capabilities in a plug-and-play manner. Current mainstream attention mechanisms can be broadly categorized. The Squeeze-and-Excitation (SE) module, for instance, models channel inter-dependencies but can suffer from information loss due to its dimensionality-reduction step. The CBAM module integrates both channel and spatial attention, showcasing the potential of cross-dimensional information interaction. More recently, the Coordinate Attention (CA) module [34] embedded positional information into channel attention by capturing long-range spatial dependencies through two 1D global pooling operations. However, these methods still have shortcomings in multi-scale feature fusion; for example, the limited receptive field of CA’s 1 × 1 convolutions can hinder detailed global and cross-channel modeling.

To overcome these limitations, the Efficient Multi-Scale Attention (EMA) module was introduced. Its architecture is designed to capture rich multi-scale spatial dependencies while preserving channel information integrity. The core of EMA can be deconstructed into three main stages: (1) Channel Splitting and Reshaping for efficient feature representation, (2) a parallel multi-scale network to extract short- and long-range dependencies, and (3) a Cross-Spatial Learning mechanism to fuse these dependencies adaptively.

Channel Splitting and Reshaping

Unlike the SE module, which uses a dimensionality-reduction bottleneck that can lead to information loss, EMA avoids this by retaining complete channel information. Given an input feature map $X\in {\mathbb{R}}^{C\times H\times W}$, the channel dimension C is first split into G groups. This operation is formulated as a tensor reshape:

$$X\to X^{\prime }\in R^{(C/G)\times H\times W\times G\times B}$$

(7)

To enable parallel processing and reduce computational overhead, the group dimension G is then merged into the batch dimension B. This yields a reshaped tensor $X_{group}\in {\mathbb{R}}^{(C/G)\times H\times W\times (G\times B)}$, which serves as the input to the subsequent parallel branches.

Parallel Multi-Scale Feature Extraction

The reshaped tensor $X_{group}$ is fed into a dual-branch parallel sub-network. One branch employs a 3 × 3 convolution to capture local spatial context and short-range dependencies. The other branch uses two sequential 1 × 1 convolutions to model cross-channel correlations and long-range dependencies efficiently. This parallel design allows EMA to simultaneously perceive features at different scales and levels of abstraction.

Cross-Spatial Learning and Fusion

To adaptively fuse the information from the parallel branches, EMA employs a cross-spatial learning mechanism based on dot-product attention. This stage explicitly models pixel-level pairwise relationships to highlight global contextual information. Specifically, a Query (Q) is generated from the output of the 1 × 1 convolution branch (long-range context), while a Key (K) and Value (V) are generated from the output of the 3 × 3 convolution branch (local context).

After flattening the spatial dimensions, such that $Q,K,V\in {\mathbb{R}}^{(C/G)\times (H\times W)\times (G\times B)}$, an attention map A is computed by measuring the similarity between the query and the key:

$$A=\mathrm{softmax}\left({\displaystyle \frac{Q^{T}K}{\sqrt{d_k}}}\right)$$

(8)

where $d_k$ is the dimension of the key vectors. The resulting attention map $A\in {\mathbb{R}}^{(B\times G)\times (H\times W)\times (H\times W)}$ encodes the pairwise importance between every pixel in the long-range feature map and every pixel in the local feature map. This map then weights the values V to produce an attended feature map:

$$F_{out}=A·V^T$$

(9)

Then, the output tensor ${\mathbf{F}}_{\mathbf{out}}$ is reshaped back to the original dimensions ${\mathbb{R}}^{B\times C\times H\times W}$.

While EMA’s fusion mechanism uses a dot-product attention similar to standard Self-Attention (SA), it implements a form of Cross-Attention. In SA, the query, key, and value are derived from the same input tensor. In EMA, the query is derived from one branch (global context) and the key/value pair from another (local context). This design enables the module to explicitly model the relationships between long-range and short-range dependencies.

In our architecture, the EMA and AMS modules are highly complementary, addressing spatial and scale attention, respectively. EMA functions as a global spatial attention mechanism, modeling long-range dependencies to identify salient target regions. Subsequently, AMS performs fine-grained scale fusion, dynamically weighting parallel convolutional branches to select the optimal feature scale for the target. EMA first determines where to focus, and AMS then decides what scale to use, significantly enhancing the model’s detection performance in complex scenarios.

2.2.3. P2 Small Object Detection Head

Reliable detection of small objects is critical across multiple domains. Examples include tiny targets in remote sensing images, as well as distant vehicles and traffic lights in ground-level views. These objects are susceptible to feature degradation during the successive downsampling operations within the network backbone. To fully leverage the fine-grained features enhanced by EMA and AMS modules and to counteract this information loss, we adapt the network’s detection neck by incorporating a higher-resolution P2 feature layer (160 × 160). Figure 4 provides a visual comparison of the detection heads between the YOLOv8n baseline and the LTC framework. This approach follows the proven practices in established detectors such as FPN and YOLOv5.

While this higher-resolution layer inherently aids in localizing small objects by utilizing shallow features with smaller receptive fields, our primary motivation stems from addressing a critical training instability in modern dynamic label assignment strategies. Dynamic assigners, such as the Task-Aligned Assigner used in YOLOv8, face “cold-start” and “high IoU sensitivity” challenges, particularly with small objects. In the initial training stages, when the model’s predictions are still inaccurate, even a minor offset in a predicted bounding box for a small target can cause its Intersection over Union (IoU) to drop precipitously below the matching threshold. Consequently, the assigner fails to find sufficient positive samples, leading to unstable gradients and inefficient convergence.

The introduction of the P2 detection head directly mitigates this issue. The denser anchor points and finer-grained features on the 160 × 160 map provide a more robust basis for matching. Even with slight prediction inaccuracies, there is a higher probability that a prediction will achieve sufficient IoU with a ground-truth object. This ensures a stable and high-quality stream of positive samples for the label assigner, especially in the crucial early phases of training. This stabilization accelerates model convergence and leads to superior final detection performance for small targets.

As specified in our network architecture, the P2 feature map is generated by first upsampling the P3 feature layer (80 × 80) from the neck. This upsampled map is then fused via concatenation with the shallow C2 feature layer (160 × 160) from the backbone. The resulting feature map is processed by a final C2f block before being fed into the detection head.

2.3. Experiments

2.3.1. Datasets

In this work, we utilize seven datasets to comprehensively evaluate our model: VisDrone [35], RSOD [36,37], KITTI [38], TT100K_mini [39], SDC_L_mini [40], UA-DETRAC [41], and BDD100K_mini [42]. The key statistics and characteristics of these datasets are summarized in

Table 2. Dataset statistics.

Dataset	Train	Val	Test	Total	Key Characteristics
VisDrone	6471	548	1610	8629	Drone-based aerial views; High density of small objects.
RSOD	748	148	-	936	Remote Sensing; Significant scale and orientation variation.
KITTI	6029	1452	-	7481	Classic autonomous driving; Urban/highway scenes with occlusion.
TT100K_mini	6793	1949	996	9738	Traffic sign detection; Targets are often small and low-resolution.
SDC_L_mini	6400	600	-	7000	General road driving images; Complex urban and highway environments.
UA-DETRAC	8639	2231	-	10,870	Traffic surveillance; High vehicle density and severe occlusion.
BDD100K_mini	3332	1258	-	4590	Large-scale diverse driving; Wide range of weather and time-of-day.

Note: The hyphen (-) indicates that an official test split is unavailable or was not used for this dataset.

.

The selection of datasets covers a wide range of challenging real-world conditions. VisDrone offers a unique challenge with its drone-captured aerial imagery, which includes dense scenes and significant object occlusions. We also include the RSOD dataset, a common benchmark for remote sensing object detection, to further evaluate aerial performance. The KITTI dataset provides a standard benchmark for autonomous driving tasks, featuring 8 classes such as ‘Car’ and ‘Pedestrian’. To evaluate performance on traffic sign detection, we use a subset of the TT100K dataset. We also incorporate the SDC_L_mini dataset, a custom subset derived from the Udacity Self Driving Car project and provided via the Roboflow platform. This dataset features real-world driving scenes with annotations for common road objects. In addition, we incorporate the UA-DETRAC dataset for its focus on difficult vehicle detection scenarios and a subset of the large-scale BDD100K dataset, which is renowned for its diversity in weather, time of day, and driving environments. For all large-scale datasets, we created smaller subsets (denoted by “_mini”) to ensure a manageable and balanced experimental setup.

For all experiments, models were trained on the respective train splits. We used the validation splits for hyperparameter tuning and to select the best model checkpoint. The final performance metrics are reported on the official test splits for the VisDrone and TT100K datasets. For all other datasets where a test split was not available or used, we report the performance of the best model on the validation split.

2.3.2. Experimental Setup

To comprehensively evaluate the performance of the LTC framework and the AMS module, we conducted experiments on the seven datasets described previously. We chose the lightweight YOLOv8n as baseline architecture, given the resource constraints of edge devices. The proposed model, LTC, is built upon this baseline by replacing some C2f modules with C2f-AMS blocks, integrating the EMA attention mechanism, and adding a P2 small object detection head.

All experiments were conducted on a workstation with an Intel i9-12900HX CPU, 32GB of RAM, and an NVIDIA GeForce RTX 4080 GPU. The software environment consisted of Python 3.10, PyTorch 2.1.2, and CUDA 12.1.

To ensure a consistent and accurate experimental process, set the training parameters outlined in

Table 3. Training parameters.

Parameter	Configuration
size	640
epoch	150
batch size	8
optimizer	SGD
learning rate	0.01
mosaic	0

.

To validate the effectiveness of our approach, we compare LTC framework with the baseline YOLOv8n and five other state-of-the-art methods for small object detection: YOLOv8-QSD [43], PV-YOLO [44], YOLO-AL [45], YOLOv8-EMSCP, and MobileNetv3_CA-YOLOv8 [46]. For a rigorous evaluation, we designed a tiered comparison strategy. The primary comparison is conducted between the proposed LTC framework and the YOLOv8n baseline. To ensure methodological purity, both of these models were trained from scratch on the target datasets without using any pre-trained weights. This provides a direct, apples-to-apples comparison of the architectural contributions.

Additionally, to showcase the maximum potential of the LTC framework and to facilitate a fair comparison with other state-of-the-art methods that also leverage pre-training, we provide a version of LTC initialized with COCO pre-trained weights, denoted as LTC (pretrain). For the other competing methods, we strictly followed the training protocols from their original publications, faithfully reproducing their respective initialization strategies (i.e., some were trained from scratch, while others used pre-trained weights).

Apart from the initialization method, all models were subsequently trained on the target datasets under identical hyperparameters and experimental settings.

2.3.3. Evaluation Metrics

To prove the effectiveness of LTC framework, we evaluated it on the test sets (or validation sets where test sets were not available) of the seven aforementioned datasets. We use the following standard metrics:

(1) Accuracy Metrics: The primary metric for detection accuracy is the mean Average Precision (mAP), specifically the COCO-style mAP calculated over IoU thresholds from 0.5 to 0.95 (mAP@0.5:0.95). We also report Precision (P) and Recall (R).

Precision (P) is the ratio of true positives ($TP$) to the total number of predicted positives ($TP$ + $FP$ (false positive)).

$$P={\displaystyle \frac{TP}{TP+FP}}$$

(10)

Recall (R) is the ratio of true positives ($TP$) to the total number of actual ground-truth positives ($TP$ + $FN$ (false negative)).

$$R={\displaystyle \frac{TP}{TP+FN}}$$

(11)

(2) Complexity Metrics: To evaluate model efficiency, we measure the total number of learnable Parameters and the computational complexity in terms of $FLOPs$.

$FLOPs$ (Floating Point Operations) quantify the amount of computation required for a forward pass. For a standard convolutional layer, the $FLOPs$ are approximately twice the number of Multiply-Accumulate operations (MACs). The formula is:

$$FLOPs=2\times H_{out}\times W_{out}\times C_{in}\times K^2\times C_{out}$$

(12)

Here, $H_{out}$ and $W_{out}$ are the spatial dimensions of the output feature map, $C_{in}$ and $C_{out}$ are the number of input and output channels, and K is the kernel size.

3. Results

3.1. Main Results

To ensure a fair and rigorous comparison, all computational costs (Parameters and GFLOPs) presented in

Table 4. Comparison with State-of-the-Art Methods on Multiple Datasets.

Model	Dataset	P	R	mAP50	mAP50-95	Parameters	GFLOPs
MobileNetV3_CA	VisDrone	0.349	0.268	0.248	0.136	2.4	5.8
PV-YOLO	VisDrone	0.404	0.302	0.296	0.168	1.6	4.7
YOLOv8-QSD	VisDrone	0.424	0.309	0.312	0.181	3.1	9.3
YOLOv8	VisDrone	0.435	0.326	0.325	0.186	3	8.1
LTC (pretrain)	VisDrone	0.459	0.358	0.36	0.211	2.8	12.3
LTC	VisDrone	0.464	0.357	0.363	0.215	2.8	12.3
YOLO-AL	VisDrone	-	-	-	-	-	-
YOLOv8-EMSCP	VisDrone	-	-	-	-	-	-
PV-YOLO	RSOD	0.904	0.851	0.887	0.587	1.6	4.7
YOLOv8	RSOD	0.892	0.878	0.896	0.638	3	8.1
MobileNetV3_CA	RSOD	0.882	0.849	0.903	0.626	2.4	5.8
YOLO-AL	RSOD	0.923	0.883	0.922	0.642	2.6	7.5
YOLOv8-QSD	RSOD	0.899	0.905	0.926	0.637	3.1	9.3
YOLOv8-EMSCP	RSOD	0.909	0.904	0.926	0.64	2.8	12.3
LTC	RSOD	0.927	0.894	0.926	0.65	2.8	12.3
LTC (pretrain)	RSOD	0.931	0.921	0.944	0.679	2.8	12.3
MobileNetV3_CA	TTK100K_mini	0.533	0.508	0.506	0.363	2.4	5.8
PV-YOLO	TTK100K_mini	0.581	0.562	0.574	0.433	1.6	4.7
YOLOv8-QSD	TTK100K_mini	0.641	0.609	0.649	0.498	3.1	9.3
YOLOv8	TTK100K_mini	0.699	0.571	0.654	0.496	3	8.1
YOLO-AL	TTK100K_mini	0.693	0.621	0.679	0.516	2.6	7.5
YOLOv8-EMSCP	TTK100K_mini	0.684	0.664	0.718	0.549	2.8	12.3
LTC	TTK100K_mini	0.733	0.652	0.733	0.565	2.8	12.3
LTC (pretrain)	TTK100K_mini	0.779	0.694	0.78	0.601	2.8	12.3
PV-YOLO	SDC_L_mini	0.638	0.672	0.691	0.395	1.6	4.7
MobileNetV3_CA	SDC_L_mini	0.805	0.569	0.704	0.39	2.4	5.8
YOLOv8-QSD	SDC_L_mini	0.676	0.71	0.733	0.426	3.1	9.3
YOLOv8	SDC_L_mini	0.797	0.66	0.737	0.437	3	8.1
YOLO-AL	SDC_L_mini	0.82	0.706	0.772	0.469	2.6	7.5
YOLOv8-EMSCP	SDC_L_mini	0.881	0.647	0.804	0.487	2.8	12.3
LTC	SDC_L_mini	0.804	0.73	0.804	0.488	2.8	12.3
LTC (pretrain)	SDC_L_mini	0.814	0.72	0.816	0.499	2.8	12.3
MobileNetV3_CA	KITTI	0.854	0.74	0.838	0.58	2.4	5.8
PV-YOLO	KITTI	0.879	0.775	0.867	0.617	1.6	4.7
YOLOv8-QSD	KITTI	0.892	0.78	0.868	0.626	3.1	9.3
YOLOv8	KITTI	0.92	0.813	0.9	0.662	3	8.1
YOLO-AL	KITTI	0.903	0.839	0.903	0.665	2.6	7.5
YOLOv8-EMSCP	KITTI	0.911	0.841	0.918	0.691	2.8	12.3
LTC (pretrain)	KITTI	0.899	0.853	0.92	0.695	2.8	12.3
LTC	KITTI	0.901	0.86	0.924	0.697	2.8	12.3
MobileNetV3_CA	UA-DETRAC	0.57	0.483	0.5	0.343	2.4	5.8
YOLO-AL	UA-DETRAC	0.598	0.538	0.564	0.407	2.6	7.5
YOLOv8-EMSCP	UA-DETRAC	0.539	0.588	0.571	0.41	2.8	12.3
LTC	UA-DETRAC	0.706	0.52	0.581	0.422	2.8	12.3
LTC (pretrain)	UA-DETRAC	0.62	0.584	0.583	0.417	2.8	12.3
YOLOv8	UA-DETRAC	0.606	0.592	0.595	0.429	3	8.1
PV-YOLO	UA-DETRAC	0.635	0.587	0.597	0.418	1.6	4.7
YOLOv8-QSD	UA-DETRAC	0.601	0.616	0.613	0.446	3.1	9.3
MobileNetV3_CA	BDD100K_mini	0.417	0.251	0.24	0.123	2.4	5.8
PV-YOLO	BDD100K_mini	0.381	0.264	0.246	0.131	1.6	4.7
YOLOv8-QSD	BDD100K_mini	0.428	0.273	0.263	0.145	3.1	9.3
YOLOv8	BDD100K_mini	0.486	0.272	0.288	0.159	3	8.1
LTC	BDD100K_mini	0.462	0.329	0.331	0.177	2.8	12.3
YOLOv8-EMSCP	BDD100K_mini	0.52	0.325	0.344	0.184	2.8	12.3
LTC (pretrain)	BDD100K_mini	0.506	0.348	0.363	0.198	2.8	12.3
YOLO-AL	BDD100K_mini	-	-	-	-	-	-

Note: A dash (-) in the table indicates that the experiment did not run successfully due to significant architectural incompatibilities or hardware limitations. For each dataset block, models are sorted primarily in ascending order of mAP50, and secondarily by mAP50-95. And the bold numbers indicate the best performance in each column.

were benchmarked using a unified script with a consistent input resolution (640 × 640). For baseline methods lacking official code, we meticulously re-implemented their architectures as described in their respective papers. This standardized evaluation ensures that all comparisons of efficiency and accuracy are conducted on an equal basis.

On the exceptionally challenging VisDrone dataset, characterized by extreme object density and occlusion, our LTC framework (0.363 mAP50) significantly outperforms the YOLOv8n baseline (0.325 mAP50), achieving a relative improvement of 11.7%. While the absolute performance metrics on VisDrone are modest across all methods. This is because the VisDrone dataset not only includes occlusion but also has a vast number of diminutive targets far smaller than typical benchmarks. Still, the substantial relative improvement highlights the effectiveness of our architecture in dense aerial scenarios. This strong performance is mirrored on the RSOD dataset, where the LTC (pretrain) model (0.944 mAP50) also achieves the top performance, closely followed by the from-scratch LTC model (0.926 mAP50, 0.65 mAP50-95). This validates its effectiveness for remote sensing tasks with significant scale and orientation variations.

The framework’s robust generalization to ground-level scenarios is most evident on the TT100K_mini dataset, which is rich in small traffic signs. The LTC (pretrain) model achieves 0.780 mAP50, a remarkable relative improvement of 19.3% over the YOLOv8n baseline (0.654 mAP50). Similarly, LTC achieves the highest mAP50 scores on the KITTI (0.924) and SDC_L_mini (0.816) datasets, confirming its effectiveness on general driving scenes.

To provide a transparent analysis of the framework’s boundaries, we highlight the results on the UA-DETRAC and BDD100K_mini datasets. On the highly diverse BDD100K_mini, the LTC (pretrain) model (0.363 mAP50) still shows a large gain over the baseline (0.288 mAP50), though all models perform poorly, likely due to the mini-subset’s limited sample size. More notably, on the UA-DETRAC dataset, our LTC and LTC (pretrain) models (0.581 and 0.583 mAP50) underperform the YOLOv8-QSD baseline (0.613 mAP50). We attribute this limitation to the nature of UA-DETRAC, which contains low-resolution, compressed video frames with high vehicle density and severe occlusion. Furthermore, the dataset includes images from multiple, distinct viewpoints, and the limited sample size for each view likely impacts model training. We hypothesize that our AMS module’s dynamic calibration mechanism may struggle with the prevalent motion blur and compression artifacts, while the insufficient data from each viewpoint prevents our model from learning adequate features. This limitation warrants future investigation and will be elaborated upon in the Discussion section.

In terms of efficiency, LTC maintains a lightweight parameter count (2.8M) comparable to the YOLOv8n baseline (3.0M). However, the inclusion of the high-resolution P2 head and attention modules results in an increased computational load (12.3 GFLOPs) compared to the baseline (8.1 GFLOPs). We argue this is a necessary trade-off: the framework prioritizes significant accuracy gains, especially for small objects, at the cost of higher computational demand. This design choice makes LTC suitable for applications requiring higher accuracy, and a cost of 12.3 GFLOPs remains a viable range for many edge devices. Nonetheless, this does indicate a limitation for deployment on extremely resource-constrained devices. Potential optimizations for this computational cost will be further explored in the Section 4.

The evaluation results on the standard autonomous driving benchmark, the KITTI dataset, are presented in

Table 5. Comparison of Detection Results on the KITTI Dataset.

Method	Car	Van	Truck	Tram	Pedestrian	Cyclist	Misc	mAP50
MobileNetV3_CA	0.931	0.88	0.942	0.959	0.677	0.749	0.783	0.846
YOLOv8-QSD	0.944	0.904	0.944	0.964	0.723	0.795	0.805	0.868
PV-YOLO	0.951	0.909	0.947	0.955	0.727	0.804	0.779	0.868
YOLOv8	0.953	0.942	0.961	0.973	0.754	0.845	0.868	0.9
YOLO-AL	0.958	0.936	0.974	0.969	0.757	0.848	0.881	0.903
YOLOv8-EMSCP	0.969	0.961	0.972	0.96	0.794	0.88	0.89	0.918
LTC (pretrain)	0.967	0.955	0.972	0.957	0.811	0.873	0.905	0.92
LTC	0.97	0.955	0.975	0.969	0.807	0.892	0.901	0.924

Note: The bold numbers indicate the best performance in each column.

. The LTC framework again demonstrates its superior performance, with the LTC version leading the rankings with an mAP50 of 0.924, significantly outperforming the YOLOv8 baseline (0.900) and all other competing methods. This performance advantage is comprehensive across most individual classes. It is particularly noteworthy that the LTC models exhibit the strongest detection capabilities on pedestrian and cyclist, two of the more challenging categories that are of critical importance to autonomous driving safety. This highlights the robustness and reliability of our framework for standard multi-class detection tasks, especially in identifying vulnerable road users with varied shapes.

To dynamically illustrate model performance, we plotted the validation convergence curves on the TT100K_mini dataset in Figure 5. The chart clearly visualizes the Precision, Recall, mAP@50 and mAP@50-95 metrics for all models throughout the training process. It is evident that the curves for the LTC and LTC (pretrain) models consistently remain above all baselines, indicating that our approach maintains a performance advantage at all training stages. Furthermore, the LTC models’ convergence curves demonstrate a stable upward trend, ultimately achieving the highest performance level. This confirms that the LTC framework not only achieves superior final accuracy but also possesses efficient and stable training convergence properties.

3.2. Ablation Study

We conducted detailed ablation studies to verify the synergistic effects of our proposed LTC framework in the context of small object detection. Our primary analysis was performed on the challenging VisDrone remote sensing dataset, with further studies on the TT100K_mini and KITTI datasets to validate the generalization of our method. This section aims to systematically evaluate the baseline model, the contributions of each independent component, and their synergistic effects within the LTC framework.

We first trained the baseline model on all three datasets and then added each of the three modules separately to observe their individual performance. The results confirmed the independent effectiveness of all components. The detailed results on VisDrone are presented in

Table 6. Ablation study on the VisDrone dataset.

Baseline	AMS	EMA	P2	mAP50	P	R
✓				0.325	0.435	0.326
✓		✓		0.343	0.450	0.342
✓	✓			0.344	0.452	0.34
✓			✓	0.359	0.462	0.354
✓	✓	✓		0.344	0.448	0.341
✓	✓	✓	✓	0.363	0.464	0.357

Note: The check mark (✓) indicates that the corresponding module or component is included in the experiment of that row. And the bold numbers indicate the best performance in each column.

. Compared to the baseline (0.325 mAP50), adding our innovative AMS module (0.344 mAP50), the established EMA module (0.343 mAP50), or the P2 detection head (0.359 mAP50) individually all yielded significant performance improvements.

However, during the validation of the synergistic framework, we discovered that the AMS and EMA modules exhibit functional redundancy on the VisDrone dataset when the P2 detection head is absent. As the data shows, both modules individually achieved 0.344 and 0.343 mAP50, respectively, but when combined, the performance remained at 0.344 mAP50, indicating their gains did not stack. We hypothesize that for the unique scenario of VisDrone with its extremely small and dense targets, the benefits of EMA’s spatial attention were largely “absorbed” by the powerful feature fusion of AMS, causing them to compete for the same optimization space on low-resolution features. Nevertheless, a minor increase in Recall was observed, suggesting a positive effect on identifying a few hard-to-detect targets. Finally, the introduction of the P2 detection head delivers the second significant performance leap, increasing the mAP50 by 5.5% to the final score of 0.363. This result strongly validates the decisive role of preserving high-resolution features in dense, small-object remote sensing scenarios.

Furthermore, to validate the cross-domain generality of our components, we conducted the same ablation studies on two ground-level autonomous driving datasets: TT100K_mini and KITTI. As detailed in

Table 7. Ablation study on the TT100K_mini dataset.

Baseline	AMS	EMA	P2	mAP50	P	R
✓				0.654	0.699	0.571
✓		✓		0.662	0.651	0.613
✓	✓			0.693	0.714	0.624
✓			✓	0.695	0.709	0.632
✓	✓	✓		0.706	0.739	0.628
✓	✓	✓	✓	0.733	0.733	0.652

Note: The check mark (✓) indicates that the corresponding module or component is included in the experiment of that row. And the bold numbers indicate the best performance in each column.

and

Table 8. Ablation study on the KITTI dataset.

Baseline	AMS	EMA	P2	mAP50	P	R
✓				0.9	0.92	0.813
✓		✓		0.908	0.914	0.834
✓	✓			0.908	0.92	0.829
✓			✓	0.917	0.897	0.85
✓	✓	✓		0.913	0.924	0.839
✓	✓	✓	✓	0.924	0.901	0.86

Note: The check mark (✓) indicates that the corresponding module or component is included in the experiment of that row. And the bold numbers indicate the best performance in each column.

, the results on these datasets exhibit an even more ideal trend. In contrast to the “functional redundancy” observed on VisDrone, no such redundancy was present in these datasets; the ablation studies on these datasets show a clear, steady, and incremental improvement in the mAP50 metric with the addition of each successive component—from AMS, to EMA, and finally to the P2 head. This not only reaffirms the individual effectiveness of each module but also explicitly demonstrates that the EMA module provides a distinct and complementary performance gain in these scenarios, further proving the robustness and general applicability of our LTC framework design.

3.3. Qualitative Results

To intuitively visualize our model’s detection efficacy, we first conducted a qualitative comparison on the RSOD remote sensing dataset, as shown in Figure 6. The figure displays (a) the original images, (b) the detection results from the baseline, and (c) the results from our LTC model. It is evident that the baseline struggles with objects from a remote sensing perspective, exhibiting significant false positives (incorrect detections) and false negatives (missed detections) for targets like airplanes. Furthermore, the baseline fails to detect other objects, such as overpasses and playgrounds. In contrast, our LTC model demonstrates superior robustness, accurately detecting and localizing these challenging targets.

Furthermore, to validate the robustness of the LTC framework in more diverse aerial scenarios, we present an additional qualitative comparison on the VisDrone dataset in Figure 7, covering challenging conditions including nighttime and daytime scenes.

In the nighttime scene on the left, the low-light conditions result in extremely low contrast between targets and the background. The baseline model fails to detect small targets such as pedestrians and motorcycles in this low signal-to-noise environment, leading to missed detections. In contrast, the LTC framework successfully identifies these objects. This suggests that the feature enhancement modules in the model (EMA and AMS) work synergistically to refine the weak feature signals of targets, thereby improving the model’s robustness under adverse lighting conditions.

The daytime comparisons in the middle and right panels highlight LTC’s superior advantage in processing distant, small-scale targets. LTC clearly detects and provides more precise bounding boxes for diminutive objects in the far field that are entirely missed by the baseline. This is primarily attributed to the P2 detection head, which provides the necessary high-resolution feature foundation for the model to perceive and leverage fine-grained details that are otherwise lost in lower-resolution feature maps.

Beyond its strong performance on aerial imagery, we further evaluated the generalization capabilities of the LTC framework across different sensing modalities. To this end, we present additional qualitative comparisons on ground-level autonomous driving scenarios from the TT100K_mini and KITTI datasets in Figure 8 and Figure 9, respectively.

Figure 8 displays the comparison results on the TT100K_mini dataset. As can be observed, all models face challenges when dealing with densely arranged traffic signs. However, the LTC model (far left) successfully detects the highest number of signs, showcasing superior recall, despite also having one missed detection. In contrast, the baseline model and all other competing methods exhibit more significant instances of missed detections. This visually substantiates the advantage of LTC framework in identifying dense, small targets.

Figure 9 further illustrates the model’s performance in complex urban scenes from the KITTI dataset, validating LTC’s comprehensive capabilities in mitigating missed, false, and duplicate detections.

• In the top-row scene, only LTC model successfully detects the farthest, partially occluded white vehicle at the end of the road. All other models failed to identify this diminutive target, which validates the effectiveness of incorporating the P2 detection head to preserve high-resolution features.
• In the middle-row motorcycle detection scene, many competing models produce multiple, overlapping, and redundant bounding boxes for the closely parked targets. The LTC model, however, generates a single, precise bounding box for each target. This is credited to the synergistic effect of the AMS and EMA modules, which enhance feature discriminability, leading to cleaner and more reliable predictions after Non-Max Suppression (NMS).
• In the bottom-row pedestrian detection scene, the situation is more nuanced. While most models identify the pedestrians, models such as the Baseline and QSD generate excessive redundant boxes. The LTC model effectively suppresses these duplicates for a cleaner result. It is noteworthy that the EMSCP model performs best in this specific scenario with the most accurate boxes, which may suggest its multi-scale structure is particularly well-suited for the feature scale of pedestrians at a medium distance. However, when all scenarios are considered, LTC strikes the best overall balance in suppressing missed detections (top row), duplicate detections (middle row), and false positives, demonstrating its comprehensiveness as a robust detector.

4. Discussion

The experimental results presented in this paper strongly validate the effectiveness of the proposed Locate then Calibrate (LTC) framework. Our core hypothesis—that a synergistic strategy of “Locate” (suppressing background noise) and “Calibrate” (re-weighting scale features) is essential for small object detection—was consistently supported. The ablation studies confirmed this synergy: the AMS (“Calibrate”) and P2 head components provided the largest performance gains on the challenging VisDrone dataset, while the EMA (“Locate”) module showed clear, incremental benefits on ground-level datasets like TT100K_mini and KITTI. This suggests that the framework successfully integrates specialized modules (AMS/P2 for dense aerial targets) with general-purpose enhancers (EMA for background suppression), forming a robust and adaptable architecture.

However, this work is not without its limitations, which must be discussed transparently. The first and most evident is the efficiency trade-off. As noted in our results, the LTC framework (12.3 GFLOPs) incurs a higher computational cost than the YOLOv8n baseline (8.1 GFLOPs). This increase is a deliberate and necessary consequence of incorporating the high-resolution P2 detection head, which is computationally expensive but methodologically critical for preserving the fine-grained features of small targets. While we argue that this trade-off is justified by the substantial accuracy gains (e.g., +11.7% on VisDrone and +19.3% on TT100K_mini), it does present a boundary condition: LTC, in its current form, is geared towards applications where accuracy is paramount, rather than those operating under extreme hardware constraints.

The second limitation, identified in our main results, is the framework’s performance on the UA-DETRAC dataset, where it did not surpass the YOLOv8-QSD model. We attribute this to the unique and challenging characteristics of that specific dataset: a combination of low-resolution compressed video, high object density, severe occlusion, and insufficient training samples for each distinct camera viewpoint. We hypothesize that our modules, particularly AMS, are sensitive to such severe compression artifacts and motion blur, failing to calibrate features effectively. This “failure case” is valuable, as it clearly defines the boundaries of our method’s applicability and suggests a sensitivity to extreme data degradation.

Last but not least, regarding the use of both aerial and ground-level datasets, we consider that while their applications differ, they share a common core challenge: the robust detection of small objects. Our primary focus was solving small object detection in remote sensing, and the strong performance on ground-level benchmarks was not the result of an intention to solve disparate fields (remote sensing, driving, traffic signs), but rather to demonstrate that the principles of locating and calibrating small, difficult-to-detect objects are general-purpose. The success in these diverse scenarios validates the robustness of the LTC framework’s core idea.

5. Conclusions

In this paper, we addressed the challenge of small object detection in aerial imagery for remote sensing by proposing a novel framework, termed Locate then Calibrate (LTC). Implemented upon the YOLOv8 baseline, the LTC framework synergistically integrates three key components: a novel C2f-AMS module that uses adaptive multi-scale convolution to dynamically learn feature weights, thereby suppressing background interference; an EMA attention mechanism to enhance the perception of critical features; and an additional high-resolution P2 detection head to preserve the details of diminutive targets.

Extensive experimental results on several public datasets demonstrate that the LTC framework significantly outperforms the baseline and other competing methods, especially on challenging VisDrone and RSOD data. Crucially, the framework achieves these substantial accuracy gains through a deliberate design trade-off: it moderately increases computational GFLOPs (a cost we argue is necessary for high-accuracy perception) while maintaining a lightweight parameter count comparable to the baseline.

Despite these promising results, our work highlights several limitations and suggests avenues for future research.

(1)

Addressing the efficiency trade-off identified in our Discussion, future work should explore model compression, pruning, or quantization to create a more edge-friendly version of LTC.

(2)

To address the identified failure case on UA-DETRAC, further research is needed to improve robustness against severe compression artifacts and motion blur.

(3)

While the P2 head alleviates some issues, it does not fundamentally solve the “IoU sensitivity” problem inherent to dynamic label assignment strategies. In the future, investigating or designing a novel loss function or label assigner that is more robust to the challenges of tiny objects would be a valuable endeavor.

Future work could explore more advanced data augmentation techniques or viewpoint-invariant feature learning—a particularly relevant challenge when bridging aerial and ground-level perspectives—to improve the model’s robustness and stability in varied scenarios.