LCA-Net: A Lightweight Network for Small Object Detection in Road Traffic Scenes

Abstract

Detecting small and distant objects in road traffic scenarios remains challenging owing to limited pixel resolution, cluttered backgrounds, and resource constraints on edge computing platforms. This work presents LCA-Net, a computationally efficient framework for small object detection that balances accuracy with model complexity. The framework incorporates three complementary designs: an Adaptive Deformable Downsampling Module (ADDM) that merges asymmetric and deformable convolution operations to improve spatial feature encoding while explicitly accounting for the parameter and computational cost of offset and modulation-mask prediction; a Cross-Scale Feature Fusion Pyramid (CSFFP) specifically engineered for minute objects, which augments multi-scale feature learning and enhances detection of far-field small targets; and a Lightweight Feature-Gated Detection Head (LFGDH) that employs channel–spatial attention to selectively emphasize informative features, thereby reducing both parameter count and computational cost. On Udacity, LCA-Net improves mAP@0.5 by 2.3 percentage points; on VisDrone2019, it improves mAP@0.5 by 1.7 percentage points. Across both benchmarks, the complete model reduces the parameter count by 25.58% and GFLOPs by 16.05% relative to YOLOv8-N. On the RTX A6000, LCA-Net-N reduces forward-pass latency from 1.82 to 1.63 ms, increases throughput from 549 to 613 FPS, and lowers peak GPU memory from 1180 to 1015 MiB. These results demonstrate a favorable accuracy–efficiency trade-off for real-time traffic perception.

1. Introduction

With the development of intelligent transportation systems and autonomous driving, vehicle-mounted perception systems must recognize road users and infrastructure under diverse environmental conditions. Object detection supports trajectory prediction, decision making, and path planning and is therefore central to road safety and traffic efficiency [1,2]. Small and distant objects remain especially vulnerable to missed detection because illumination changes, partial occlusion, motion blur, and downsampling can suppress their already limited visual evidence.

Traditional detectors combine hand-crafted descriptors with statistical classifiers [3,4], but their limited representation capacity makes them sensitive to large appearance variations. Modern convolutional networks substantially improve accuracy and robustness. Two-stage detectors generate candidate regions before classification and box refinement, generally at a higher computational cost [5,6,7]. One-stage detectors, such as SSD and You Only Look Once (YOLO), directly predict categories and boxes from dense feature maps [8,9]. Nevertheless, compact YOLO variants still face a difficult trade-off between retaining weak small-object features and limiting computational cost in cluttered traffic scenes.

Two coupled problems are central to road-scene small-object detection. First, tiny targets occupy few pixels, so repeated downsampling can merge their distinguishing cues with the background. Fixed-grid convolutions cannot adapt their sampling locations to different object shapes, while conventional pyramids may leave a semantic gap between high-resolution detail and low-resolution abstraction. Second, deeper backbones, multi-path pyramids, and expensive attention improve representation but increase parameters, operations, latency, and memory. Recent attention-centric YOLO models, end-to-end real-time transformers, and compact traffic detectors continue to expose this tension [10,11,12,13,14]. However, the combined effects of geometry-aware downsampling, non-adjacent cross-scale fusion, and a gated lightweight head have not been isolated under a common traffic-oriented small-object protocol. We therefore assess both architecture-level complexity and measured server-side latency, throughput, and memory usage.

This study asks: Can a detector jointly improve small-object accuracy and reduce overall model complexity by combining geometry-aware downsampling, cross-scale feature encoding, and a compressed feature-gated head? To investigate this question, LCA-Net combines ADDM, CSFFP with the Multi-Scale Feature Encoding Module (MFEM), and LFGDH. ADDM uses small-object aspect-ratio statistics to select fixed odd kernel shapes and learns offsets and modulation masks; the resulting offset-and-mask prediction overhead is explicitly quantified. MFEM consolidates non-adjacent multi-resolution context through target-scale alignment, pooling, and $1\times 1$ fusion. LFGDH places channel–spatial gating after channel compression within a decoupled head. We evaluate the resulting design using detection accuracy, parameters, GFLOPs, and measured server-side latency, throughput, and memory.

The main contributions of this work are summarized as follows:

(1)

We design ADDM, which integrates asymmetric deformable convolutions with multi-scale adaptive attention. By adapting the sampling grid to small-object bounding-box statistics and jointly modeling channel and spatial importance, ADDM strengthens feature encoding with a measurable offset-and-mask prediction overhead.

(2)

We propose CSFFP with MFEM to align and fuse non-adjacent feature maps, combining high-resolution detail with high-level semantics.

(3)

We construct LFGDH, which performs channel–spatial feature filtering after channel compression. It reduces parameters and GFLOPs while preserving critical target-region information, producing a favorable accuracy–efficiency trade-off in the complete detector.

LCA-Net combines established primitives in three task-specific positions: geometry-guided deformable downsampling, non-adjacent cross-scale alignment and fusion, and channel–spatial gating after head compression.

Table 1. Module-level comparison with the closest architectural foundations.

Component	Closest Foundations	Reused Primitives	Task-Specific Distinction in LCA-Net
ADDM	DCN [15]; SE/CBAM [16,17]	Offsets, masks, and channel–spatial reweighting	A $7\times 3$/$3\times 3$ dual branch selected from the observed $3:7$ aspect-ratio mode, followed by normalized branch fusion and spatial gating at downsampling stages.
CSFFP/MFEM	FPN/BiFPN [18,19]; CARAFE fusion [20]	Alignment, pooling, concatenation, and $1\times 1$ fusion	Each target scale receives both finer and coarser non-adjacent features; direct-pooling alternatives are compared in a controlled ablation.
LFGDH	CBAM [17]; decoupled YOLO head	Channel–spatial gating and decoupled branches	Gating follows two $1\times 1$ compression layers inside each prediction branch and therefore operates on a reduced representation.

compares each component with its closest foundations.

2. Related Work

2.1. Object Detection Based on YOLO and Its Extensions

Object detection is a core component of autonomous-vehicle perception because it supports real-time scene understanding. The YOLO family is widely used in this setting because it offers a practical balance between detection accuracy and computational cost.

Since YOLOv1 was introduced by Redmon et al. [9], YOLO-based detectors have been refined for higher accuracy and lower computational cost. Liu et al. [21] combined BiFPN with lightweight C2f modules to compress the backbone, although the reported accuracy gain was limited. Wang et al. [22] used K-means anchor initialization and a MobileNetV1 feature extractor to reduce parameters, but small-object false negatives and false positives remained. Cai et al. [23] introduced PAN++ and five detection scales to improve small-object accuracy at the cost of additional parameters and latency. Lv et al. [24] used large-kernel separable convolutions and residual connections to improve distant-object detection, with a corresponding increase in computation.

Recent efficiency-oriented detectors include attention-centric YOLO variants [10,11], end-to-end real-time transformer detectors such as DEIM and RF-DETR [12,13], and the 2026 lightweight traffic detector YOLOv8n-3SE-PD [14]. These studies advance individual attention, matching, search, or compression strategies, but they do not isolate geometry-aware downsampling, non-adjacent cross-scale fusion, and a compressed gated head under a common traffic-oriented small-object protocol. This unresolved accuracy–complexity interaction motivates the research question stated in Section 1.

2.2. Small-Object Detection

Deep learning has substantially advanced general-purpose object detection, yet small objects remain difficult because they occupy few pixels, occur less frequently, and are readily confused with background clutter and sensor noise. These challenges are pronounced in underwater imagery, autonomous-driving scenes containing traffic lights and road signs, and aerial surveillance [25,26,27,28].

Small-object detectors use architectural and data-oriented strategies to preserve weak target cues. Chen et al. [29] proposed MFMAM, which applies multi-scale feature fusion to reduce information loss and suppress false detections. The Feature Pyramid Network (FPN) [18] combines high-resolution early features with semantically strong deep features, and Deng et al. [30] adapted this idea to a high-resolution pyramid for small targets. Self-attention, channel attention, and spatial attention further emphasize target regions while suppressing background responses [31,32]. MobileNet and EfficientNet [33] reduce computation and memory, whereas sample replication, scale-aware sampling, self-supervised augmentation, and transfer learning address limited small-object data.

Despite this progress, increasing network depth or width to strengthen feature learning often raises latency and memory requirements. Persistent challenges include retaining high-resolution evidence, separating tiny targets from complex backgrounds, and maintaining stable accuracy across object scales.

2.3. Enhanced Small-Object Detection with Multi-Scale Fusion

Single-layer feature extraction typically fails to capture the comprehensive contextual cues needed to identify objects with varying scales, shapes, and textures. Consequently, sophisticated multi-scale feature processing and integration become crucial, particularly in complex traffic environments characterized by substantial intra-class scale diversity.

Multi-scale fusion combines complementary cues from different spatial resolutions. FPN [18] uses lateral pathways for hierarchical integration, and EfficientDet’s Bidirectional Feature Pyramid Network (BiFPN) [19] adds bidirectional connections with learnable fusion weights. MFMAM [29] reduces information loss during deep feature learning, CARAFE-based fusion [20] improves content-aware resampling, and dual SIE-FPN [34] supports joint aerial and ground-view detection. Ghost-YOLO [35] reduces redundancy with C3Ghost blocks, while Transformer-based fusion [36] expands global context. The remaining design challenge is to retain high-resolution small-object cues without excessive computation.

Inspired by these investigations, we formulate the Cross-Scale Feature Fusion Pyramid (CSFFP) tailored for small-object detection. CSFFP seeks to more efficiently integrate multi-scale features to derive highly distinctive representations for small targets while preserving computational efficiency, rendering it particularly suitable for small-object detection in complex traffic environments.

3. Proposed Method

In this section, we present the overall architecture of LCA-Net and its key components: ADDM, CSFFP with MFEM, and LFGDH. We provide unified notation, formal definitions, a training-pipeline summary, and a complexity analysis.

3.1. Overall Architecture and Notation

Let $\mathbf{I}$$\in {\mathbb{R}}^{H\times W\times 3}$ denote an input RGB image. A lightweight backbone (YOLOv8-N) extracts multi-scale backbonefeatures

$${\left\{{\mathbf{F}}_{\ell }^{\left(s\right)}\right\}}_{\ell =1}^L,{\mathbf{F}}_{\ell }^{\left(s\right)}\in {\mathbb{R}}^{C_{\ell }^{\left(s\right)}\times H_{\ell }^{\left(s\right)}\times W_{\ell }^{\left(s\right)}}$$

(1)

In Equation (1), $C_{\ell }^{\left(s\right)}$ is the channel dimension, and $H_{\ell }^{\left(s\right)},W_{\ell }^{\left(s\right)}$ are spatial sizes at level ℓ.

LCA-Net inserts ADDM blocks into downsampling stages to obtain adaptively encoded features ${\mathbf{F}}_{\ell }^{\left(a\right)}$. These are fed into CSFFP, which uses MFEM blocks to produce pyramid features ${\left\{{\mathbf{F}}_i^{\left(p\right)}\right\}}_{i=1}^S$ for small-object detection. LFGDH operates on each ${\mathbf{F}}_i^{\left(p\right)}$ to output class scores and bounding boxes for K categories.

Throughout the paper, we use the following notation: bold uppercase letters (e.g., $\mathbf{F}$) denote feature maps, bold lowercase letters (e.g., $\mathbf{x}$) denote vectors, and normal letters ($C,H,W$) denote scalar dimensions. The operator ⊙ represents element-wise multiplication; $\sigma (·)$ and $\delta (·)$ denote the sigmoid and ReLU activation functions, respectively; ${\mathrm{Conv}}_{k\times k}$ indicates a $k\times k$ convolution; GMP and GAP denote global max and average pooling; and $I(·)$ denotes nearest-neighbor interpolation.

The overall architecture is illustrated in Figure 1. Next, we provide details on each module.

3.2. Adaptive Deformable Downsampling Module

Road-traffic scenes contain large variations in object scale, shape, illumination, and background clutter. Standard convolution samples a fixed grid at every location and therefore cannot adapt its receptive field to local geometry. Broad receptive fields provide semantic context but may also introduce background responses, whereas compact fields preserve local detail. ADDM combines geometry-adaptive sampling with elongated and compact branches to balance these effects during downsampling.

Following Zhu et al. [37] and Chen et al. [38], we applied K-means clustering to traffic-object boxes smaller than $20\times 20$ pixels in the original images. The dominant $3\text{:}7$ aspect ratio guided the asymmetric kernel design; Figure 2 shows the clustering result.

As illustrated in Figure 3, deformable convolution adapts its sampling grid to object geometry. The offset and modulation-mask generator contributes 0.06 M parameters and 0.12 GFLOPs to LCA-Net-N, and this cost is included in the reported model total. The asymmetric branches follow the observed small-object aspect-ratio distribution and encode complementary elongated and compact receptive fields. Their reweighted outputs concentrate sampling on target-supporting regions. The detailed architecture is depicted in Figure 4.

The input feature map first undergoes two parallel modulated deformable convolutions [15]. For $K=k_h{k}_w$ kernel positions, the output at $p_0$ is given in Equation (2):

$$y\left(p_0\right)=\sum _{p_n\in \mathcal{R}}w\left(p_n\right)x(p_0+p_n+\Delta p_n)\Delta m_n$$

(2)

where $\Delta p_n$ is the learned two-dimensional offset, and $\Delta m_n\in [0,1]$ is the modulation mask. A separate convolution predicts $3K$ channels: $2K$ offset coordinates and K masks. Non-integer positions use bilinear interpolation [39].

The implementation uses fixed kernel shapes across pyramid levels. The compact odd size isgiven in Equation (3):

$$k_s=3,$$

(3)

and the elongated size is the nearest centered odd realization of the dominant 7:3 ratiogiven in Equation (4):

$$k_l=2k_s+1=7.$$

(4)

The branches therefore use $7\times 3$ and $3\times 3$. Odd sizes preserve a unique center: the former matches the clustered aspect-ratio mode, and the latter retains isotropic local context.

Following the convolutional branches, MSA performs branch fusion and channel–spatial reweighting. Its channel component follows squeeze-and-excitation attention [16] and uses global average pooling to obtain a channel descriptorin Equation (5):

$$S=F_{ex}(z,W)=\sigma \left(W_2\delta \left(W_1\left(F_{sq}(F_1+F_2)\right)\right)\right)$$

(5)

where $F_1$ denotes the output of the $7\times 3$ convolution, $F_2$ denotes the output of the $3\times 3$ convolution, and $F_{sq}$ represents global average pooling. $W_1\in {\mathbb{R}}^{C/r\times C}$ and $W_2\in {\mathbb{R}}^{C\times C/r}$ are learnable weight matrices, $\delta$ denotes the ReLU activation function, and $\sigma$ denotes the sigmoid activation function.

The two branches are then fused under learnable coefficientsas shown in Equation (6):

$$F_{fused}={\alpha }_1{F}_{scale}(S_c,F_{1c})+{\alpha }_2{F}_{scale}(S_c,F_{2c})$$

(6)

where $F_{scale}(S_c,F_{ic})$ denotes channel-wise multiplication of the feature map $F_{ic}$ from the ith branch by the scalar $S_c$. The learnable fusion weights satisfy ${\alpha }_1\in [0,1]$ and ${\alpha }_2=1-{\alpha }_1$.

Next, spatial selection is applied to the fused map. Channel-wise maximum and average projections are concatenated and transformed into a spatial maskas defined in Equation (7):

$$S_{space}=\sigma \left({\mathrm{Conv}}_{1\times 1}[{\mathrm{MaxPool}}_c\left(F_{fused}\right),{\mathrm{AvgPool}}_c\left(F_{fused}\right)]\right).$$

(7)

Here, ${\mathrm{MaxPool}}_c$ and ${\mathrm{AvgPool}}_c$ reduce only the channel dimension and retain the $H\times W$ grid. This distinguishes them from the global pooling in Equation (5).

3.3. Feature Pyramid Network for Cross-Scale Feature Fusion

Conventional FPN upsamples coarser maps before merging them with adjacent finer layers. This local pathway does not directly expose each target level to both non-adjacent fine detail and coarse semantics. MFEM therefore aligns finer and coarser sources to a common target grid.

Let the target size be $H_t\times W_t$. For a finer map $F_l$, $I_{2t}$ aligns it to $2H_t\times 2W_t$, after which non-overlapping $2\times 2$ pooling with a stride of 2 produces the aligned featurein Equation (8):

$$F_{lt}={\mathrm{MaxPool}}_{2,2}\left(I_{2t}\left(F_l\right)\right)+{\mathrm{AvgPool}}_{2,2}\left(I_{2t}\left(F_l\right)\right).$$

(8)

Interpolation standardizes non-integer source-to-target ratios, maximum pooling retains salient responses, and average pooling preserves regional context. For integer ratios, direct pooling is valid and is evaluated in Section MFEM Downsampling Alternatives.

For a coarser map $F_s$, nearest-neighbor interpolation aligns it directlyas defined in Equation (9):

$$F_{st}=I_t\left(F_s\right),$$

(9)

where $I_t$ resizes to $H_t\times W_t$, and the notation $F_s$ is used consistently. The aligned branches are concatenated and fused with a $1\times 1$ convolution. The controlled ablation in Section MFEM Downsampling Alternatives compares alignment plus dual pooling with direct average pooling, direct maximum pooling, interpolation alone, and stride-2 convolution.

CSFFP follows PAN-style aggregation but routes non-adjacent feature maps through MFEM blocks. Finer and coarser maps are aligned to each target resolution, aggregated, and fused with $1\times 1$ convolutions. Interpolation provides geometric alignment without trainable weights, while the final convolutions control the channel width. The high-resolution pathways retain small-object detail, and coarser features supply semantic context.

The architecture is summarized in Figure 5.

3.4. Lightweight Feature-Gated Detection Head

CSFFP produces four prediction scales, each of which requires a detection head. To control this added cost, we incorporate the Convolutional Block Attention Module [17] after channel compression in the head, forming the Feature Gating Module (FGM). The module first applies two sequential $1\times 1$ convolutions for channel compression and feature fusionas shown in Equation (10):

$$x_2={\mathrm{Conv}}_{1\times 1}\left({\mathrm{Conv}}_{1\times 1}\left(x\right)\right)$$

(10)

where x denotes the input feature map.

The compressed feature is filtered first by channel attention, computed from global max pooling (GMP) and global average pooling (GAP)as shown in Equation (11):

$$x^{\prime }=x_2\odot \sigma \left(\mathrm{MLP}\left(\mathrm{GMP}\left(x_2\right)\right)+\mathrm{MLP}\left(\mathrm{GAP}\left(x_2\right)\right)\right)$$

(11)

where MLP denotes a multilayer perceptron, $\sigma$ is the sigmoid activation, and ⊙ is element-wise multiplication.

Spatial attention then reweights individual locationsas defined in Equation (12):

$$\mathrm{out}=x^{\prime }\odot \sigma \left({\mathrm{Conv}}_{k\times k}\left(\mathrm{Concat}\left({\mathrm{MaxPool}}_c\left(x^{\prime }\right),{\mathrm{AvgPool}}_c\left(x^{\prime }\right)\right)\right)\right)$$

(12)

where ${\mathrm{MaxPool}}_c$ and ${\mathrm{AvgPool}}_c$ reduce the channel dimension while retaining the spatial grid, and Concat denotes channel-wise concatenation. Because both gates operate after channel compression, FGM filters informative target regions at reduced width. Embedding FGM in each decoupled prediction branch yields LFGDH, reducing redundant computation while preserving task-relevant responses.

3.5. Training Pipeline

The end-to-end training flow for LCA-Net is summarized in

Table 2. LCA-Net training pipeline.

Step	Description
Input resize	Resize image to $640\times 640$; normalize to $[0,1]$.
Augmentation	Mosaic (disabled in last 10 epochs), random scaling/cropping/flipping, HSV jitter; box labels transformed accordingly.
Backbone	YOLOv8-N backbone with inserted ADDM blocks at downsampling stages.
Neck	CSFFP with MFEM for cross-scale aggregation to produce $\left\{{\mathbf{F}}_i^{\left(p\right)}\right\}$.
Head	LFGDH on each ${\mathbf{F}}_i^{\left(p\right)}$ with decoupled cls/reg branches.
Loss	$\mathcal{L}={\lambda }_{\mathrm{box}}{\mathcal{L}}_{\mathrm{box}}+{\lambda }_{\mathrm{cls}}{\mathcal{L}}_{\mathrm{cls}}+{\lambda }_{\mathrm{dfl}}{\mathcal{L}}_{\mathrm{dfl}}$ (IoU-based box loss, focal-style classification loss, and distribution focal loss).
Optimizer	SGD with momentum 0.937 and weight decay $5\times {10}^{-4}$; cosine learning-rate schedule; batch size 32; 350 epochs; 8 workers.
EMA	Exponential moving average of model weights for stable evaluation.

. It covers data preprocessing, augmentation, optimization, and loss composition applied consistently across the datasets.

3.6. Complexity Analysis

For a convolution with kernel size $k_h\times k_w$, input/output channels $C_{\mathrm{in}}$/$C_{\mathrm{out}}$, and output size $H_o\times W_o$, the parameter and FLOP estimates are given in Equations (13) and (14):

$$\mathrm{Params}\approx k_h{k}_w{C}_{\mathrm{in}}{C}_{\mathrm{out}}$$

(13)

$$\mathrm{FLOPs}\approx 2k_h{k}_w{C}_{\mathrm{in}}{C}_{\mathrm{out}}{H}_o{W}_o.$$

(14)

For a modulated deformable branch with $K=k_h{k}_w$ positions, a $k_g\times k_g$ generator predicts $3K$ offset/mask channels. Including bias, its added parameters and FLOPs aregiven in Equations (15) and (16):

$$P_{\mathrm{off}}=3K(k_g^2{C}_{\mathrm{in}}+1),$$

(15)

$$F_{\mathrm{off}}\approx 2k_g^2{C}_{\mathrm{in}}\left(3K\right)H_o{W}_o.$$

(16)

In LCA-Net-N, the offset-and-mask generators contribute 0.06 M parameters and 0.12 GFLOPs. The reported total of 2.24 M parameters and 6.8 GFLOPs includes these layers.

ADDM retains the same asymptotic convolutional order but has a larger constant from its branches and predictor. CSFFP alignment costs $\mathcal{O}\left(CHW\right)$ per scale and its $1\times 1$ fusion costs $\mathcal{O}\left(C_{\mathrm{in}}{C}_{\mathrm{out}}HW\right)$. LFGDH replaces dense $3\times 3$ prediction branches with compressed $1\times 1$ processing and lightweight gates. Because operation counts omit kernel-launch, memory-access, and other runtime effects, latency and memory are reported separately in Section 4.2.

4. Experiments and Results

4.1. Training Parameters and Environment Configuration

The server configuration used in this study is summarized in

Table 3. Server configuration.

Parameter	Configuration
Operating System	Ubuntu 24.04
CPU	Intel(R) Xeon(R) w5-3435X
GPU	NVIDIA RTX A6000
PyTorch	1.12.1
GPU Acceleration (CUDA)	CUDA 11.3
Programming Language	Python 3.9

.

To meet the model’s input requirements, the original images were resized to 640 × 640 pixels. The batch size was set to 32, and stochastic gradient descent (SGD) was adopted as the optimizer with a momentum of 0.937. The model was trained for 350 epochs using the above environment configuration. The training parameters are shown in

Table 4. Training parameter settings.

Parameters	Setup
Epochs	350
Batch Size	32
Workers	8
Image Size	640
Optimizer	SGD
Close_mosaic	10
Momentum	0.937

.

4.2. Server-Side Inference Efficiency

Inference was profiled on the RTX A6000 server in Table 3 usinga batch size of 1 and $640\times 640$ inputs, PyTorch eager mode, 200 warm-up iterations, 1000 timed iterations, and CUDA synchronization around each forward pass. The timer covered model forward propagation; FPS was calculated as the reciprocal of mean per-image latency, and peak GPU memory was reset immediately before timing.

As shown in

Table 5. Server-side inference efficiency on the NVIDIA RTX A6000.

Model	Precision	Latency, ms per Image	Throughput, Images per Second	Peak GPU Memory, MiB	Weight Size, MiB
YOLOv8-N	FP32	1.82	549	1180	12.0
LCA-Net-N	FP32	1.63	613	1015	9.0

, LCA-Net-N reduces mean forward-pass latency by 10.44% (1.82 to 1.63 ms), increases throughput by 11.66% (549 to 613 FPS), lowers peak GPU memory by 13.98% (1180 to 1015 MiB), and reduces weight-file size by 25.0% (12.0 to 9.0 MiB) relative to YOLOv8-N. The measured gains are consistent with the model-level reductions and confirm practical inference efficiency on the reported server configuration.

4.3. Experimental Data

To assess the proposed network’s effectiveness, we perform experiments on representative benchmarks from autonomous driving and UAV-based vision domains. Model development and ablation studies utilize the Udacity dataset, while final validation employs the VisDrone2019 dataset.

The Udacity autonomous driving dataset, originally created for autonomous driving algorithm competitions, contains 15,000 urban road images at 1980 × 1280 resolution. The dataset encompasses 11 object categories: bicyclists, cars, pedestrians, traffic lights (including green, green-left, red, red-left, yellow, and yellow-left variants), and trucks. Data partitioning allocates 9000 images for training, 3000 for testing, and 3000 for validation. Dataset composition analysis, visualized in Figure 6, reveals several characteristics: Figure 6a displays per-category instance counts, showing pronounced class imbalance; Figure 6b shows center-aligned bounding box overlays, indicating high spatial concentration and predominantly small scales, confirming that small objects dominate the dataset; Figure 6c depicts bounding box center coordinate distributions, with substantial concentration near image centers, likely reflecting vehicle instance prevalence; Figure 6d presents width–height scatter plots, further confirming the prevalence of small-scale objects.

The VisDrone2019 dataset [40], a large-scale open-source UAV benchmark released by Tianjin University, comprises 10,209 static images captured from varied aerial perspectives, with 6471 training, 1610 test, and 548 validation images. The dataset encompasses approximately 2.6 million annotated instances spanning 10 categories: pedestrians, crowds, bicycles, cars, vans, trucks, tricycles, covered tricycles, buses, and motorcycles. This benchmark serves to evaluate model generalization and detection capability in aerial imaging scenarios.

4.4. Evaluation Metrics

We evaluate detection with mAP@0.5 and mAP@0.5:0.95 and report model complexity using parameter count and GFLOPs. Precision and recall are defined in Equations (17) and (18), respectively:

$$\mathit{Precision}={\displaystyle \frac{\mathit{TP}}{\mathit{TP}+\mathit{FP}}}$$

(17)

$$\mathit{Recall}={\displaystyle \frac{\mathit{TP}}{\mathit{TP}+\mathit{FN}}}$$

(18)

where TP, FP, and FN denote true-positive, false-positive, and false-negative detections, respectively. Average precision for category i is the area under its precision–recall curvedefined in Equation (19):

$$A{P}_i={\int }_0^1{P}_i\left(R\right)\mathrm{d}R$$

(19)

where $P_i\left(R\right)$ is the precision of category i at recall R.

Mean average precision (mAP) is the class-wise mean of APdefined in Equation (20):

$$\mathrm{mAP}={\displaystyle \frac{1}{n}}{\displaystyle \sum _{i=1}^n}{\mathrm{AP}}_i$$

(20)

where n is the number of evaluated classes.

mAP@0.5 evaluates AP at an intersection-over-union (IoU) threshold of 0.5. The mAP@0.5:0.95 metric averages AP over IoU thresholds from 0.5 to 0.95 in steps of 0.05.

4.5. Ablation Studies

We present LCA-Net, an object detection network built upon the YOLOv8 baseline, incorporating three enhancement modules: ADDM, CSFFP, and LFGDH. To systematically assess each component’s contribution to overall performance, we perform comprehensive ablation experiments, with results summarized in

Table 6. Ablation settings and results for each improvement module on the Udacity dataset. A checkmark indicates that the corresponding component is enabled.

Group	Baseline	ADDM	CSFFP	LFGDH	mAP@0.5, %	mAP@0.5:0.95, %	Params, M	GFLOPs
group 1	✓				67.5	39.4	3.01	8.1
group 2		✓			68.7	40.5	2.90	7.8
group 3			✓		70.5	42.3	2.87	12.2
group 4				✓	64.9	38.4	2.38	5.5
group 5		✓	✓		69.4	41.5	2.76	11.9
group 6		✓		✓	67.1	39.2	2.27	5.3
group 7			✓	✓	67.5	40.2	2.35	7.1
group 8		✓	✓	✓	69.8	41.3	2.24	6.8

.

Training dynamics for LCA-Net are visualized in Figure 7. The three loss components ($\mathit{box}\text{\_}\mathit{loss}$, $\mathit{cls}\text{\_}\mathit{loss}$, and $\mathit{dfl}\text{\_}\mathit{loss}$) decline steadily and plateau at approximately 300 epochs. The validation losses converge slightly later while following similar trajectories. The precision, recall, mAP@0.5, and mAP@0.5:0.95 curves improve rapidly during early training and stabilize after approximately 100 epochs.

Table 6 reveals a non-additive interaction between representation and compression. Relative to YOLOv8-N, ADDM alone improves mAP@0.5/mAP@0.5:0.95 by 1.2/1.1 percentage points with slightly lower complexity, whereas CSFFP alone gives the highest accuracy (70.5%/42.3%) but increases computation from 8.1 to 12.2 GFLOPs. LFGDH alone reduces parameters by 20.93% and GFLOPs by 32.10%, with accuracy decreases of 2.6/1.0 points. Combining all three modules recovers most of the CSFFP accuracy while offsetting its computational cost: the complete model reaches 69.8%/41.3%, improves on the baseline by 2.3/1.9 points, and reduces parameters and GFLOPs by 25.58% and 16.05%, respectively. Thus, ADDM and CSFFP primarily enhance representation, whereas LFGDH supplies the main model-level compression.

To verify design effectiveness under more demanding aerial imaging conditions, we conduct additional ablation studies on VisDrone2019. As a prominent UAV-based detection benchmark, VisDrone2019 features dense small objects and intricate backgrounds that complement road-traffic scenarios. Results are presented in

Table 7. Ablation settings and results for each improved module on the VisDrone2019 dataset. A checkmark indicates that the corresponding component is enabled.

Group	Baseline	ADDM	CSFFP	LFGDH	mAP@0.5, %	mAP@0.5:0.95, %	Params, M	GFLOPs
group 1	✓				33.7	19.5	3.01	8.1
group 2		✓			34.7	20.1	2.90	7.8
group 3			✓		37.1	22.0	2.87	12.2
group 4				✓	31.7	18.3	2.38	5.5
group 5		✓	✓		38.4	22.7	2.76	11.9
group 6		✓		✓	32.7	18.7	2.27	5.3
group 7			✓	✓	34.0	19.6	2.35	7.1
group 8		✓	✓	✓	35.4	20.5	2.24	6.8

.

The VisDrone2019 results in Table 7 show a similar accuracy–complexity trade-off. The complete model reaches 35.4% mAP@0.5, 1.7 percentage points above YOLOv8-N, while reducing parameters by 25.58% and GFLOPs by 16.05%. This result provides complementary evidence from dense aerial scenes in addition to the road-view Udacity evaluation.

Additionally, to verify ADDM reliability with Multi-Scale Adaptive Attention (MSA) incorporating branch fusion weights, we perform comparative experiments by embedding several established spatial and channel attention mechanisms—SE [16], CBAM [17], and CA [41]—into ADDM to determine the optimal configuration. SE attention emphasizes important features via channel-wise weight allocation, CBAM enables refined feature selection through dual-dimensional (channel and spatial) attention, and CA enhances spatial attention localization precision by incorporating coordinate information. MSA ablation settings and results are presented in

Table 8. The ablation settings and results of the MSA module on the Udacity dataset.

Attention	mAP@0.5, %	mAP@0.5:0.95, %	Params, M	GFLOPs
SE	67.7	39.9	2.90	7.8
CBAM	66.8	39.2	2.97	7.8
CA	67.4	40.2	2.89	7.8
MSA	68.7	40.5	2.90	7.8

.

As indicated in Table 8, compared to ADDM variants using SE, CBAM, and CA attention, our MSA module with branch fusion weights attains superior detection accuracy, achieving 68.7% mAP@0.5 and 40.5% mAP@0.5:0.95. Moreover, the MSA-enhanced ADDM maintains relatively low parameter complexity, demonstrating that MSA improves performance while preserving lightweight properties. These findings confirm MSA’s effectiveness in feature extraction and attention allocation, as well as its advantages over conventional attention mechanisms.

MFEM Downsampling Alternatives

Only the finer-to-target operator in Equation (8) was changed; the backbone, source features, fusion width, optimizer, seed policy, and schedule were held fixed. Direct pooling tested whether interpolation was redundant, interpolation-only isolated scale alignment, and stride-2 convolution tested a learned downsampler. The compared downsampling alternatives and their results are summarized in

Table 9. Ablation of the MFEM finer-to-target downsampling operator on Udacity. Bold values indicate the best accuracy in the comparison.

Operator	mAP@0.5, %	mAP@0.5:0.95, %	Params, M	GFLOPs
Direct average pooling	69.3	40.9	2.24	6.8
Direct maximum pooling	69.1	40.7	2.24	6.8
Nearest interpolation only	68.9	40.5	2.24	6.8
Stride-2 convolution	69.5	41.0	2.30	7.0
Alignment + max/average pooling (ours)	69.8	41.3	2.24	6.8

.

The proposed alignment followed by maximum/average pooling attains 69.8% mAP@0.5 and 41.3% mAP@0.5:0.95. It improves the two metrics by 0.5/0.4 percentage points over direct average pooling, 0.7/0.6 points over direct maximum pooling, and 0.9/0.8 points over nearest-neighbor interpolation alone. It also exceeds stride-2 convolution by 0.3 points on both metrics while using 0.06 M fewer parameters and 0.2 fewer GFLOPs. These results support the use of explicit scale alignment followed by complementary max/average aggregation.

4.6. Comparative Experiments

We further evaluate LCA-Net against efficiency-oriented CNN and transformer detectors under the same dataset splits and evaluation protocol. The comparisons include YOLO-Nano variants (YOLOv8, YOLOv10 [42], YOLO11 [43], YOLO12 [10], and YOLOv13 [11]), RT-DETR-R50 [44], DEIM-D-FINE-S [12], and RF-DETR-N [13]. The parameter–accuracy trade-off among the Nano-scale YOLO baselines is visualized in Figure 8.

As demonstrated in Figure 8 and

Table 10. Comparison of experimental results with YOLO-Nano series models on the Udacity dataset.

Model	mAP@0.5, %	mAP@0.5:0.95, %	Params, M	GFLOPs
YOLOv8-N	67.5	39.4	3.01	8.1
YOLOv10-N	66.2	39.1	2.27	6.5
YOLO11-N	66.7	39.4	2.58	6.3
YOLO12-N	65.1	38.2	2.56	6.3
YOLOv13-N	65.2	38.2	2.45	6.2
LCA-Net (Ours)	69.8	41.3	2.24	6.8

, LCA-Net has the highest detection accuracy and the lowest parameter count within this Nano-scale comparison. Relative to YOLOv8-N, YOLOv10-N, YOLO11-N, YOLO12-N, and YOLOv13-N, its mAP@0.5 improvements are 2.3, 3.6, 3.1, 4.7, and 4.6 percentage points, respectively.

Table 11. Comparative experimental results with other state-of-the-art detection models on the Udacity dataset.

Model	mAP@0.5, %	mAP@0.5:0.95, %	Params, M	GFLOPs
YOLOv8-N	67.5	39.4	3.01	8.1
YOLOv8-S	70.9	43.4	11.13	28.5
YOLOv8-M	72.6	45.6	25.85	78.7
YOLOv10-N	66.2	39.1	2.27	6.5
YOLO11-N	66.7	39.4	2.58	6.3
YOLO12-N	65.1	38.2	2.56	6.3
YOLO12-S	70.0	43.1	9.24	21.2
YOLO12-M	72.5	44.8	26.35	88.6
YOLOv13-N	65.2	38.2	2.45	6.2
RT-DETR-R50	63.3	34.8	41.96	125.7
DEIM-D-FINE-S	72.1	45.3	10.5	29.8
RF-DETR-N	67.0	40.1	19.2	48.5
LCA-Net-N (Ours)	69.8	41.3	2.24	6.8
LCA-Net-S (Ours)	72.7	44.8	8.64	24.0
LCA-Net-M (Ours)	74.3	47.6	18.70	68.3

extends the comparison to multiple YOLO scales and recent real-time transformer detectors. All models were trained and evaluated on the same Udacity split with the common $640\times 640$ protocol.

As shown in Table 11, LCA-Net defines a favorable accuracy–complexity frontier across model scales. Relative to YOLOv8 at N, S, and M scales, LCA-Net improves mAP@0.5 by 2.3, 1.8, and 1.7 percentage points, while reducing parameters by 25.58%, 22.37%, and 27.66%, respectively. LCA-Net-N also exceeds RF-DETR-N by 2.8 points in mAP@0.5 and 1.2 points in mAP@0.5:0.95, while using 88.33% fewer parameters and 85.98% fewer GFLOPs. DEIM-D-FINE-S produces 2.3-/4.0-point higher accuracy than LCA-Net-N but requires 4.69 times the parameters and 4.38 times the GFLOPs. At the S scale, LCA-Net-S exceeds DEIM-D-FINE-S by 0.6 points in mAP@0.5, is 0.5 points lower in mAP@0.5:0.95, and uses 17.71% fewer parameters and 19.46% fewer GFLOPs.

We additionally evaluated all Nano-scale and transformer baselines on VisDrone2019 using the same training/test partition and input resolution; the results are reported in

Table 12. The comparison results with various baseline models on the VisDrone2019 dataset.

Model	mAP@0.5, %	mAP@0.5:0.95, %	Params, M	GFLOPs
YOLOv8-N	33.7	19.5	3.01	8.1
YOLOv10-N	33.2	19.4	2.27	6.5
YOLO11-N	33.0	19.1	2.58	6.3
YOLO12-N	33.0	19.2	2.56	6.3
YOLOv13-N	32.6	18.4	2.45	6.2
RT-DETR-R50	30.0	16.5	41.96	125.7
DEIM-D-FINE-S	36.2	21.0	10.5	29.8
RF-DETR-N	33.5	19.2	19.2	48.5
LCA-Net (Ours)	35.4	20.5	2.24	6.8

.

As shown in Table 12, LCA-Net improves mAP@0.5 and mAP@0.5:0.95 by 1.7 and 1.0 percentage points over YOLOv8-N while reducing parameters by 25.58% and GFLOPs by 16.05%. It also exceeds RF-DETR-N by 1.9 and 1.3 points on the two accuracy metrics while using 88.33% fewer parameters and 85.98% fewer GFLOPs. DEIM-D-FINE-S is 0.8/0.5 points more accurate than LCA-Net but requires 4.69 times the parameters and 4.38 times the GFLOPs. Thus, the expanded comparison confirms that LCA-Net remains competitive with recent real-time transformer detectors at substantially lower model complexity.

4.7. Visual Analysis

Beyond quantitative evaluation, we conduct qualitative analysis to further investigate LCA-Net behavior in complex traffic environments. Figure 9 visualizes detection heatmaps for representative Udacity images, contrasting attention distributions between YOLOv8-N and LCA-Net. The first row depicts scenes containing large, medium, and small objects; the second emphasizes medium and small objects; and the third shows only distant small objects under varying illumination. Heatmap color intensity reflects model attention strength per region. Across all scenarios, LCA-Net generates more focused and precise responses around small-object locations, effectively reducing attention dispersion evident in YOLOv8-N.

Figure 10 compares final detection boxes generated by YOLOv8-N and LCA-Net. The first two rows contain scenes in which most small targets are identified, whereas the third row contains partially overexposed distant objects. In these examples, LCA-Net detects more distant small targets under dense traffic and heterogeneous illumination, while YOLOv8-N misses several small or poorly illuminated targets. The qualitative patterns are consistent with the quantitative improvements in the ablation and comparative experiments.

Figure 11 complements the qualitative examples in Figure 9 and Figure 10 with matched predictions from difficult scenes. Compared with YOLOv8-N, LCA-Net-N preserves more small and distant detections under strong shadows, low contrast, partial occlusion, and nighttime illumination, with fewer missed or low-confidence targets. The remaining errors are concentrated on targets represented by very few pixels or obscured by other objects; these cases define the practical boundary of the current detector.

5. Conclusions

This paper presents LCA-Net for small- and distant-object detection in road-traffic and aerial scenes. ADDM adapts sampling to object geometry, CSFFP/MFEM aggregates cross-scale information, and LFGDH reduces redundancy in the prediction head. Relative to YOLOv8-N, LCA-Net improves mAP@0.5 by 2.3 percentage points on Udacity and 1.7 points on VisDrone2019, while reducing parameters by 25.58% and GFLOPs by 16.05%. On the RTX A6000, the Nano model reduces forward-pass latency by 10.44%, increases throughput by 11.66%, lowers peak GPU memory by 13.98%, and reduces weight-file size by 25.0%.

The module ablations identify complementary contributions: ADDM and CSFFP strengthen representation, LFGDH supplies most of the compression, and the selected MFEM alignment-plus-pooling operator achieves the best accuracy among five downsampling alternatives without increasing the 2.24 M/6.8-GFLOP model total. Comparisons with DEIM-D-FINE-S and RF-DETR-N further place LCA-Net on a competitive accuracy–complexity frontier. The difficult-scene analysis shows improved robustness over YOLOv8-N while locating the remaining errors primarily in extremely small or heavily occluded targets.

Future work will extend difficult-scene training data, investigate lighter dynamic operators, and combine mixed-precision inference with structured compression and hardware-aware optimization.