Optimizing Small Object Detection in Low-Resolution Imagery: A Unified Super-Resolution and Detection Framework Using YOLO-Flex

1  Introduction

The primary aim of the object detection (OD) task is to precisely recognize and describe targets within images or video sequences based on their size, position, and spatial relationships. This objective finds relevance across several domains, including computer vision, digital image processing, and deep learning. The fundamental method for deep learning-based object detection can be categorized into three essential stages: feature extraction, object detection, and localization. Despite significant advancements in the development and examination of these subdivisions, typical practical obstacles exist with fine-grained object localization approaches utilizing generic deep object detectors. These issues stem from factors such as limited resolution, elevated noise levels, inadequate information, and ambiguous images. A case in point is that current surveillance technologies frequently encounter challenges with low-resolution (LR) and unclear visual perception, especially in surveillance and urban security contexts, where the detection of small objects is impeded by hardware limitations, technological constraints, and environmental factors. Due to the risk of losing essential feature characteristics while scaling to analyze a specific object of interest, which results in blurriness and identity errors, it remains a formidable undertaking to extract crucial feature information from LR data.

The instance-based sparse representation technique establishes a connection between LR and SR images by capturing the sparse relationships among different segments of the images. This facilitates the reconstruction of images using image super-resolution [1]. Deep learning-based super-resolution approaches can be classified into two primary categories: feature-space approaches and pixel-space approaches. A pixel-based super-resolution technique, as demonstrated by Super Resolution Convolutional Neural Network (SRCNN) [2], utilizes a 9×9 convolutional layer for feature extraction from the input image, a 1×1 convolutional layer to capture the nonlinear associations between low resolution (LR) and high resolution (HR) features, and concludes with a 5×5 convolutional layer for the reconstruction of super-resolution images. A generator mechanism is utilized by Super Resolution Generative Adversarial Networks (SRGAN) [3], a super-resolution technique derived from a feature space approach, to learn the non-linear transformation from (LR) to high-resolution (HR) images, and the discriminator is used to constrain the semantics of the output super-resolved image.

These algorithms for object detection and super-resolution have accomplished commendable achievements in their respective domains. However, they do not perform the integrated functionalities of super-resolution and small object detection (SOD) with pinpoint accuracy for specific application domains. Super-resolution techniques offer potential performance and accuracy improvements in object detection; however, they often face challenges in achieving high detection probabilities and mitigating key missed detection, particularly for small objects. Detecting small objects proves difficult because of the limited detailed information they contain, sometimes resulting in their disappearance within deep networks. Enlarging the resolution to address this issue can amplify problems related to scale variance and significantly increase computational costs. Additionally, current feature-level super-resolution models lack direct supervision through explicit target features during training, leading to training instability and limited overall quality of super-resolution features for fine-grained object localization. In comparison to the baseline algorithm, our prospective approach, the YOLO-Flex algorithm, faced several challenges during the experiments carried out, especially on the VisDrone dataset:

1.   Numerous Targets: Each image contains hundreds of objects that need to be detected, many of which overlap.

2.   Target Deformation: Unlike traditional data sets, the shooting angle of unmanned aerial vehicles (UAVs) leads to target deformation.

3.   Small Target Sizes: Due to being captured from the air at a significant distance, the targets appear very small in the images, rendering standard model training ineffective.

4.   Complex Backgrounds and Scenes: The dataset features two types of scenes, day and night, with the UAV capturing images from a broad perspective, resulting in intricate backgrounds.

Each of these challenges is addressed by a specific component of the YOLO-Flex framework. The numerous overlapping targets challenge is addressed by the trimmed Path-Aggregation Bi-directional Feature Pyramid Network (PBi-FPN) feature fusion network, which provides dense multi-scale feature representations that preserve spatial proximity information critical for distinguishing adjacent objects. Target deformation arising from UAV shooting angles is addressed by the RFCN’s block-level residual clustering, which preserves fine-grained spatial detail regardless of object orientation. The small target size challenge is addressed jointly by the SR preprocessing stage, which reconstructs high-frequency spatial detail before detection, and by the added stride-4 detection head, which provides a denser detection grid specifically tuned for sub-32-pixel objects. Complex backgrounds and scene variability are addressed by the Squeeze-and-Excitation Attention Module (SEAM) channel attention mechanism, which learns to weight feature channels according to their discriminative relevance for the detection task, suppressing background clutter features relative to object features.

We illustrate in Fig. 1 the typical workflow of GAN-based super-resolution techniques. The architecture encompasses the detector and resolution blocks for the enhancement and detection of objects in the input image. The proposed method aims to improve the detection and localization of small objects, particularly in satellite/aerial vehicle images characterized by LR datasets. By employing image SR for improved small target features, the study integrates the RFCN module for image SR, utilizing the Enhanced Deep Super-Resolution Network (EDSR) with residual blocks for small target feature extraction. The generative adversarial network supplies the adversarial loss, with the discriminant network trained based on its ability to distinguish if the image can be deceived. Additionally, we enhance our discriminator loss function by incorporating the Average Relativistic Discriminator (ARD) as a mechanism for ensuring the quality of generated images. The final detector function incorporates elements from YOLOv5 [4], employing Fast-Spatial Pyramid Pooling (SPPF) and path aggregation network (PAN) with Bi-FPN for multi-scale feature fusion.

Figure 1: The standard workflow of GAN-based super-resolution methods, illustrating the general generator-discriminator architecture for image enhancement prior to detection.

This approach involves three key parts: an enhanced small object detector framework, the use of residual blocks with an RFCN appendage for more accurate super-resolution, and the adoption of a non-cyclic approach to reduce network size, leading to improved detection performance. The principal contributions of this work are as follows:

1.   First, we present YOLO-Flex as a purposeful engineering integration framework, wherein each architectural decision is motivated by the specific requirements of small object detection (SOD) in super-resolved spatially degraded imagery. Rather than claiming algorithmic novelty for individual components, we demonstrate that their co-design produces a coherent system whose whole is greater than the sum of its parts, as validated by our ablation studies.

2.   Second, we introduce a joint training objective that couples detection loss with super-resolution optimization through unified backpropagation, ensuring that the SR network is trained to produce images that are not merely perceptually sharp but also geometrically faithful to object boundaries relevant for downstream detection.

3.   Third, we propose a principled backbone reduction and asymmetric scale prioritization strategy that achieves competitive detection accuracy at a parameter count of 1.25 million, making the framework deployable in resource-constrained scenarios such as embedded UAV platforms.

4.   Fourth, we introduce the Average Relativistic Discriminator into the SR-GAN training loop, replacing the conventional SRGAN discriminator and providing a more stable and calibrated training signal for high-frequency texture recovery critical for small object visibility.

The remainder of this paper is organized as follows. Section 2 reviews related studies and summarizes recent advances in super-resolution techniques for small object detection. Section 3 presents the proposed methodology, including the optimization of the baseline EDSR framework and the integration of the Residual Feature Cluster Network (RFCN) to enhance image reconstruction performance. This section also describes the redesign of the YOLOv5 architecture, resulting in a lightweight and efficient detection framework tailored for small object detection tasks. Section 4 details the experimental setup, benchmark datasets, evaluation metrics, comparative analyses, and ablation studies used to validate the effectiveness of the proposed approach. Section 5 discusses the contributions of the key architectural components and examines their potential applicability across real-world industrial scenarios. Finally, Section 6 concludes the paper by summarizing the main findings and outlining promising directions for future research.

2  Related Works

In a bid to explore the landscape of image super-resolution in low-pixel-count object recognition, we delve into the existing body of literature that lays the foundation for our research on image super-resolution techniques in relation to low-pixel-count object recognition. This essential review of previous studies will provide insight into the development of image enhancement and object detection methods, shedding light on the various challenges, advancements, and strategies that researchers have employed in this domain.

By analyzing the strengths and weaknesses of earlier work, we seek to place our own approach in context, illustrating its significance in tackling the complexities associated with detecting small objects through improved image resolution.

2.1 Small Object Detection (SOD)

Image super-resolution for fine-grained object localization is an end-to-end deep learning concept that enhances image quality before using a detector network. Multi-scale feature fusion, a popular approach in SOD, when combined with advanced object detection networks, yields efficient models. Recent frameworks emphasize five critical components: multi-scale feature extraction, data augmentation techniques, training methodologies, context-aware learning, and the incorporation of generative networks.

Effective models for low-pixel-count object recognition include Faster R-CNN [5,6], Feature-fused SSD [7], MDSSD (Multi-scale deconvolutional SSD) [8], SCAN (Semantic context-aware network) [9], and the RefineDet [10]. Region-based strategies, especially in the initial detection stage, concentrate on tiny candidate regions while ignoring larger ones. Two-stage object detection systems like Faster R-CNN [6], Deformable R-CNN [11], and Deconvolution R-CNN [12] are widely used for detecting various objects, including small vehicles, airplanes, ships, and structures.

An adaptive Intersection Over Union-based Deformable R-CNN proposed by Yan et al. (2019) [11] showed a significant 4.8% improvement in object detection performance. Modifications to the Region Proposal Network (RPN) of Faster R-CNN put forward by Ren et al. (2018) [13] were introduced to improve small region identification, incorporating contextual information. Deconv R-CNN by Zhang et al. (2018) [12], with a deconvolution layer, enhanced feature retrieval, and small target positioning accuracy. These approaches deliver high accuracy but are limited by their computational cost.

While there has been extensive research on two-stage detection networks for addressing fine-grained object localization in remote sensing, one-stage detector networks have received less attention. Recent studies have explored the integration of semantic segmentation with object detection to enhance contextual understanding in aerial imagery. For instance, a hybrid framework combining semantic segmentation and YOLO-based detection has demonstrated improved localization accuracy for vehicles in UAV-captured scenes by leveraging pixel-level contextual cues. Such approaches highlight the importance of contextual reasoning in complex aerial environments, where objects are often small, densely distributed, and affected by background clutter [14]. Some studies have utilized YOLO-based frameworks, such as YOLOv2 and YOLOv3, for SOD in remote sensing images, including ships, people [15], and airplanes. However, YOLO detectors are typically optimized for real-time computer vision applications and may exhibit lower detection accuracy, especially with small objects.

In 2020, Liu et al. [15] proposed UAV-YOLO, adapting YOLOv3 for small objects using UAV imagery by combining residual blocks and enhancing dataset training. This modification achieved better performance compared to YOLOv3 and SSD variants, while Pham et al. [16] adjusted YOLOv3 by introducing lower sub-sampling factors to focus on small-sized objects, thereby improving the detection of smaller objects.

Furthermore, Zhao and Ren [17] implemented YOLOv3 in 2020 for ship detection without modifications, showcasing superior computational performance compared to Faster R-CNN and SSD. The research work proposed by Nina et al. [18] compared YOLOv3 and YOLT (You Only Look Twice) [19] for ship detection, and with no suggested changes to the original YOLOv3 architecture. Xie et al. [20] introduced LOCO for detecting small and dense building footprints, but specifically designed it for rectangular-shaped buildings, limiting its applicability to objects of varying sizes and shapes. In 2021, Wang et al. [21] introduced SSS-YOLO, utilizing a path augmentation fusion network (PAFN) and dilated Resblocks to outperform YOLOv3 and Faster R-CNN in mean Average Precision (mAP) and inference time on SAR datasets.

LOCO is specifically designed for rectangular building footprints, limiting its applicability to objects of arbitrary shape, aspect ratio, and orientation. SSS-YOLO employs dilated residual blocks within a path augmentation fusion network that increases receptive field coverage but does not address the feature homogenization problem in deep residual networks operating on severely low-resolution inputs. YOLO-Flex addresses both limitations through two distinct mechanisms. The RFCN’s selective residual clustering preserves block-level feature specificity regardless of object shape, enabling detection of non-rectangular targets without architectural constraints. The trimmed PBi-FPN asymmetrically prioritizes high-resolution feature pathways rather than uniformly expanding receptive fields, directly addressing the small object information loss that dilated convolutions partially but incompletely compensate for.

One-stage detectors like YOLO have not gained widespread adoption in the field of remote sensing, yet they remain an attractive option for real-time applications due to their exceptional efficiency. The limited enthusiasm for these detectors may be attributed to a critical drawback: while YOLO models are often considered top contenders for real-time computer vision tasks, they tend to deliver significantly lower detection accuracy, particularly when it comes to identifying small objects, especially in comparison to region-based detectors.

Lamichhane et al. (2025) [22] provide a comprehensive review of CNN-based object detection, highlighting the trade-off between the speed of single-stage detectors such as YOLO and the higher localization accuracy of two-stage methods like Faster R-CNN. The survey identifies small object detection as a major unresolved challenge due to the loss of fine spatial details during feature downsampling. It also notes that multi-scale feature extraction and attention mechanisms are the primary strategies used to address this issue. Motivated by these findings, YOLO-Flex introduces a unified framework that combines super-resolution preprocessing with an asymmetric multi-scale detection architecture, improving small object detection accuracy while maintaining computational efficiency.

Deploying object detection models on UAV platforms is heavily constrained by limited computational resources and storage capacity, as embedded UAV hardware typically supports only lightweight models with low gigaFLOP requirements and compact memory footprints [23]. These limitations motivate the efficiency-oriented design of YOLO-Flex, where architectural decisions are guided by achieving an effective balance between detection accuracy and computational efficiency suitable for resource-constrained UAV environments.

The architectural constraints of one-stage detectors discussed above are compounded by a second, largely independent problem: the absence of image enhancement as a pre-processing stage. Even the most capable YOLO architectures receive degraded low-resolution inputs without any resolution recovery. This motivates the review of GAN-based super-resolution approaches in Section 2.2, where we examine how SR techniques can be integrated with enhanced detection pipelines.

2.2 GAN-Based Super-Resolution

Super-resolution methods seek to improve resolution-impaired input images by converting them into higher-resolution versions, offering more detailed information for tasks like fine-grained object localization. Generative Adversarial Networks (GANs) are a well-established approach for achieving high-resolution image reconstruction.

The Generative Adversarial Network [24], introduced by Goodfellow et al., consists of two primary components: a generator network and a discriminator network. GANs have made notable advancements in the space of image resolution enhancement, as demonstrated by Ledig et al. [3]. In this setup, the generator network is tasked with generating super-resolved images, attempting to mislead the discriminator network into thinking that these generated images are authentic, high-resolution images. In contrast, the discriminator’s role is to distinguish between actual high-resolution images and the reconstructed images generated by the generator.

EDSR [25], EnhanceNet [26], and LapSRN [27] are super-resolution techniques based on residual learning, such as ResNet. Residual networks use shortcut connections to efficiently capture the differences between input and output. These networks enhance super-resolution by optimizing high-frequency information and efficiently learning residual features. However, Edge-Enhanced Deep Super-Resolution Network (EEDSR) faces a key limitation in its heavy reliance on large, varied training datasets, which presents a crucial constraint. VDSR [28] introduced residual networks to super-resolution, leading to expanded receptive fields and faster convergence, and outperformed SRCNN. However, when subjected to unfamiliar forms of image degradation—such as different degrees of noise or motion blur—VDSR performance may deteriorate greatly, producing less than ideal results. In 2019, Li et al. [29] proposed an image super-resolution feedback network, while Dai et al. [30] introduced a second-order attention network for challenges with blur and noise. To generate rich high-frequency information, Xu et al. [31] introduced a dynamic convolutional network for feature-space contextual super-resolution.

According to the findings of Ferdous et al. [32], the image SR performed better in detection and classification than LR images. Additionally, Bashir and Wang [33] combined Cyclic GAN with a YOLOv3 one-stage detector on an enhanced EDSR base network to improve network performance, and it successfully operated for a scale factor of 8 and 16 on LR images. In a bid to provide a comprehensive technique, edge-enhanced SRGAN (EESRGAN) [34] combines the enhanced SRGAN (ESRGAN) [35] and edge-enhanced GAN (EEGAN) [36]. A detection network composed of the Faster Region-Based Convolutional Network (Faster R-CNN) alongside a single-shot multibox detector (SSD) produced the EESRGAN. The performance of classification and detection for HR aerial images was enhanced using EESRGAN. ESRGAN and its derivatives inherently encompass multiple parameters that require careful fine-tuning and optimization, resulting in extended processing durations.

Our research introduces an architecture designed to improve both accuracy and efficiency in detecting small objects, making it ideal for real-time applications. By combining tasks into a single network, our model boosts performance while simplifying the structure. Notably, we replace traditional residual blocks with RFCN-based blocks and improve feature concatenation to enhance the network’s overall effectiveness.

3  Proposed Methodology

In the discipline of computer vision and deep learning-driven object detection, challenges persist when dealing with small objects or low-quality images. To tackle these challenges, we put forward an efficient approach that combines super-resolution (SR) techniques to enhance image quality with an improved object detection network. Experiments have shown a direct link between improvements in object detection and image quality enhancements, as measured by metrics like Peak Signal-to-Noise Ratio (PSNR) and Structural Similarity Index Measure (SSIM) within the SR model. This SR and object detection integration effectively addresses current constraints in object detection models. This research presents a two-step approach for the detection of sub-32-pixel targets, combining super-resolution and object detection to increase accuracy in dealing with LR images. The YOLO-Flex architecture builds upon EDSR and YOLOv5 models, with our comprehensive architectural workflow illustrated in Fig. 2.

Figure 2: The complete comprehensive YOLO-Flex network architecture.

Our enhanced detector structure is integrated into the overall solution architecture to handle the detection task on the SR images produced by the non-cyclic SR-GAN, creating a comprehensive architectural framework. The YOLO-Flex architecture integrates GAN-based super-resolution with multi-scale feature refinement and optimization for robust fine-grained object localization. The generator enhances resolution-impaired inputs while the discriminator enforces perceptual quality. Extracted features are refined using Residual Feature Cluster Networks across multiple scales, followed by ARD-Average Relativistic Discriminator. The fused features are then processed by a YOLO detection head to produce accurate bounding box predictions, particularly for small and densely distributed objects. The primary objective is to employ our enhanced detector within the overall model to align the objects of interest in the generated SR image as closely as possible with the ground-truth high-resolution (HR) image. Fig. 2 illustrates the final model, incorporating the YOLO-Flex detection network into the SR-GAN model, which has been trained on HR images with fixed weights.

3.1 Super-Resolution Modules

3.1.1 Residual Feature Cluster Network (RFCN)

In this context, our SR network comprises a spatially degraded image alongside its associated high-resolution reference. By reducing the gap between the image SR function f(LR) and ground-truth reference HR image, the network produces a super-resolved image (SR), confirming that our super-resolved output image is a direct function of an LR input image. Convolutional neural networks (CNNs), primarily composed of cascaded convolutional layers, followed by one or more pixel shuffling layers, serve as the fundamental architectural templates for the image SR process. The dimensions of extracted feature information represented by (B,Ch,H,W) are tweaked with the aid of the shuffling layer to (B,Ch,Hq,Wq), where B,Ch,H,W,q denote the batch size, channels, feature map height & width, and the up-sampling factor, respectively. For an up-sampling factor of 2, the dimensions of the output feature maps of x- and y-axes are doubled.

In conventional residual networks, intermediate features are combined through element-wise addition before propagation, which effectively preserves identity mappings and stabilizes training. However, this progressive fusion mechanism may limit the explicit retention of diverse intermediate feature representations, particularly in super-resolution tasks where fine-grained texture and structural details are critical. This progressive fusion induces feature normalization across blocks, wherein high-frequency spatial components critical for reconstruction are increasingly weakened in deeper layers. This is not a failure of residual learning in general, but a resolution-specific diminishing effect, consistent with observations in RRDB (Zhang et al., 2018) [37]. To address this limitation, we introduce the Residual Feature Concatenation Network (RFCN), which aggregates intermediate residual outputs through channel-wise feature concatenation rather than direct summation. This approach enables the network to preserve distinct local feature responses from multiple residual blocks before fusion.

To control the resulting dimensionality growth, a 1×1 convolution layer is applied to adaptively compress and recalibrate the concatenated features. This design enhances feature expressiveness while maintaining computational efficiency, thereby improving the reconstruction quality of the generated high-resolution images.

In the RFCN training process, a normalization layer is employed to standardize the pixel values in the three color channels. The optimization of the SR network is achieved through the utilization of the Adam optimizer and an L1 loss function. When evaluated using image quality assessment (IQA) metrics like PSNR and SSIM, notable enhancements are observed in comparison to bicubic interpolation. Additionally, the incorporation of RFCN results in further improvements of image quality in comparison to the standard EDSR approach.

It is important to note that the observation of satisfactory detection performance when using a scaling factor of 8 is derived exclusively from a preliminary exploratory qualitative experiment. This specific finding serves as a descriptive insight into how the model behaves under high scaling, rather than acting as a definitive measure of success for the entire object detection framework. Nonetheless, to further enhance detection accuracy, particularly for small objects, and to establish a more robust image super-resolution framework, we have introduced additional modifications to the original method. In this revised approach, the initial layer of a typical SR network is employed for extracting shallow features, the middle segment consists of residual blocks for obtaining additional features, and the final section is dedicated to image restoration. The surface features produced by the initial branch are as follows:

F0=S(ILR)(1)

Here, S represents the function responsible for feature extraction in the initial layer, while F0 denotes the initial shallow extracted feature output. The extracted features are transferred to the RFCN module as shown in Fig. 3 for feature learning. For N number of residual blocks, the feature function is formulated as follows:

Fn=Mn(Fn−1)=Mn(Mn−1(...(M0(F0))...))(2)

where Mn is the nth residual block with input feature Fn−1 and output feature Fn, and the image reconstruction process of the extracted feature Fn handles the image up-scaling with the following formula:

ISR=ℜ(Fn+F0)=ϕ(ILR,℘)(3)

Figure 3: RFCN network architecture.

Here, the super-resolved image is denoted by ISR, ℜ is the reconstruction function. The function ϕ serves as the image resolution function, tasked with transforming the spatially degraded image (LR) into a higher resolution (HR) image. Meanwhile, ℘ represents the parameters of this image super-resolution function, encompassing the features learned by the network through various LR–HR image pair training. This combination constitutes the super-resolution function within our proposed network.

3.1.2 Enhanced Non-Cyclic RFCN

In this section, we configure the RFCN as the generator network within our non-cyclic SR-GAN Wasserstein generative adversarial networks (WGAN) [38], utilising 32 RFCN-based residual blocks of size 128 × 128, which were specifically designed to facilitate and address the detection of sub-32-pixel targets, and consequently improve the overall detection accuracy. The fundamental structure of a GAN network comprises a feature generator paired with a discriminator, where the discriminator’s role is to assess the credibility of the generated super-resolved image. During each iteration, the discriminator network module also undergoes improvement, and the generator employs the feedback provided by the discriminator to calibrate its parameters utilizing the L1 loss function. This iterative process leads to the generation of progressively more realistic images.

In our proposed SR enhancement shown in Fig. 4, we configure the RFCN as the generator network, utilizing 32 RFCN-based residual blocks of size 128 × 128. Meanwhile, the discriminator network, denoted as D, remains the same as the one used in SR-GAN [3], only a non-cyclic rendition, to assess the authenticity of the generated images. The RFCN block shown in the Generator Network path serves as the GAN generator; the second RFCN block labelled (Object Detection) is a shared-weight feature extraction branch feeding the YOLO-Flex detector head. By combining adversarial losses with perceptual similarity measurements, there is a substantial reduction in the blur. The pixel-wise loss is incorporated due to the presence of the counterpart HR reference of the LR image. This is therefore a legacy SRGAN-style theoretical reconstruction loss and is defined as follows:

LSRGAN=EIHR∼Pdata(IHR)[log(D(IHR))]+EILR∼Pdata(ILR)[log(1−D(G(ILR)))]+EILR∼Pdata(ILR)[||G(ILR)−IHR||2](4)

Figure 4: Optimised SR architecture.

The first, second, and third components of the equation above represent the adversarial network loss, the perceptual loss, and the mean squared error (MSE), respectively, all calculated on a per-pixel basis. Here, ILR, G(ILR), and IHR refer to the LR image, the generated SR image, and the genuine high-resolution image, respectively. This formulation is presented as a background reference and serves as the theoretical foundation for our implemented loss function. Effective training relies on having a substantial collection of LR and HR image pairs. Pdata connotes the per-pixel data representation on which the individual losses are calculated. Pixel loss ensures low-level fidelity, perceptual loss ensures semantic similarity, and the adversarial loss ensures photo-realism.

3.1.3 Average Relativistic Discriminator (ARD)

In addition to the previously mentioned improvements, which are primarily emphasized within the architecture’s generator network, we have also enhanced the discriminator network using the relative GAN approach [39], distinguishing it from the conventional discriminator D employed in SRGAN. The Average Relativistic Discriminator DRa seeks to evaluate the probability that a real image appears more authentic compared to a synthetic image generated by the model generator module. In contrast, the SRGAN discriminator solely calculates the likelihood that an input image x is real. Consequently, the discriminator loss and the adversarial loss for the generator network are computed as follows:

L(DRa)=−Exr∼P[log(D~(xr))]−Exf∼Q[log(1−D~(xf))](5)

where,

D(xr,xf)Ra=D~(x)={Sigmoid[C(x)−Exf∼QC(xf)]ifxisrealSigmoid[C(x)−Exr∼PC(xr)]ifxisfake(6)

L(DRa)=−Exr∼P[log(DRa(xr,xf))]−Exf∼Q[log(1−(DRa(xf,xr))](7)

L(GRa)=−Exr∼P[log(1−(DRa(xr,xf))]−Exf∼Q[log(DRa(xf,xr))](8)

In the above expressions, P represents the real data distribution, while Q denotes the distribution of generated (fake) data. Dx stands for the discriminator’s evaluation at x. The operation Exf entails the aggregation of all the data generated within a specific mini-batch. The super-resolved image produced from the input LR image is denoted as xf (for fake) and xr (for real), corresponding to the ground-truth HR image. During adversarial training, the generator function leverages gradients from both generated data and real data.

During training, the resulting SR image is input into the YOLO-Flex network to detect small objects, and the prediction box coordinates are employed to compute the detector’s loss function, denoted as L(det). The gradient of the overall loss is computed, and via back-propagation, the weights of both the generator and discriminator network modules are updated.

Our approach encompasses three distinct parts: the generator, the discriminator, and the detector sub-modules, each associated with different loss functions. The detection loss is incorporated into the super-resolution network through backpropagation during the training process to enhance detection capabilities. Eqs. (6) and (7) reference the enhanced average relativistic discriminator and the corresponding generator function in Eq. (8), while the detector loss function Ldet is formulated as follows:

Ldet=λbox⋅LCIoU+λobj⋅Lobj+λcls⋅Lcls(9)

where, localization loss

Lloc=λ1LCIoU+λ2LNWD(10)

LCIoU=1−IoU+ρ2(b,bgt)c2+αυ(11)

LNWD=1−exp⁡(−W22C)(12)

LCIoU represents the standard complete Intersection over Union (IoU) loss, where IoU represents the overlap ratio, ρ2(b,bgt) is the center distance, c is the diagonal of the enclosing box, υ denotes the aspect ratio consistency, and α is the balance term. The original coordinate-based regression loss was found to be scale-sensitive, which may cause large objects to dominate optimization gradients. To address this limitation, our detector employs a hybrid CIoU-NWD localization objective. The CIoU term normalizes centroid deviation using the enclosing-box diagonal and preserves aspect-ratio consistency, while the Normalized Wasserstein Distance (NWD) weighting term improves robustness for extremely small objects whose IoU values are highly sensitive to minor coordinate perturbations.

Objectness loss,

Lobj=−∑i=1N[oilog⁡(o^)+(1−oi)log⁡(1−o^i)](13)

And classification loss,

Lcls=−∑i=1N∑c=1Gyiclog⁡(y^ic)(14)

Eq. (14), governs class probability optimisation across all predicted categories.

The final YOLO-Flex detector adopts the standard multi-component YOLO loss function, consisting of localization, objectness, and classification losses. The localization component employs the Complete Intersection over Union (CIoU) loss, which jointly optimizes overlap consistency, centroid distance, and aspect ratio alignment. The objectness loss estimates the confidence of object presence within each anchor prediction, while the classification loss optimizes category prediction accuracy. This design ensures consistency with modern YOLO-based detection frameworks and improves localization robustness for small objects.

L(G)=ℒ(p)=1N∑i=1N∥G(ILRi)−IHRi∥1′(15)

In Eq. (15), we have G(ILRi) representing the ith generated SR image, IHRi as the ground truth HR image, P denoting the network parameters, L(G) as the generator loss function, and N as the total sample number. In the final YOLO-Flex implementation, the generator network is optimized using L1 reconstruction loss, as defined in Eq. (15), because L1 loss empirically preserves edge sharpness and high-frequency structural details more effectively than L2 loss, which tends to produce over-smoothed reconstructions. This design choice is especially important for SOD tasks where edge fidelity and fine-grained texture preservation directly influence localization accuracy.

LD=Exf∼Pg[D(xf)]−Exr∼Pr[D(xr)]+λEx^∼Px^(‖∇x^D(x^)‖2−1)2(16)

where LD denotes the discriminator loss function leveraging an improved Wasserstein GAN and incorporates a substantial gradient penalty coefficient within the discriminator loss function. E[⋅] represents the expectation operator, xr denotes a real high-resolution (HR) image sampled from the true data distribution Pr, and xf denotes the super-resolved image generated by the generator network, sampled from the generated data distribution Pg. The critic function D(⋅) outputs a scalar score that estimates the Wasserstein distance between the real and generated distributions.

The third term corresponds to the gradient penalty regularization term, where λ is the gradient penalty coefficient that controls the strength of the Lipschitz constraint, typically set to 10 in accordance with the standard WGAN-GP formulation. The sample x^ is an interpolated image constructed along the straight-line path between real and generated samples and is drawn from the interpolation distribution Px^. The interpolated sample x^ is defined as x^= εxr+(1 −ε)xf where ε ∼U(0,1) is a random scalar sampled from a uniform distribution over the interval [0,1]. The operator ∇x^D(x^) denotes the gradient of the critic output with respect to the interpolated input sample x^. The Euclidean norm ‖⋅‖2 measures the magnitude of this gradient.

Pt, Pg, and Pr denote the probability density distributions associated with the ground-truth HR image, the generated SR image, and the randomly sampled image, respectively. The gradient penalty term is evaluated on interpolated samples x^ generated by linearly combining real and super-resolved images using a uniformly sampled interpolation coefficient ε. The discriminator loss consists of three major components. The first term evaluates the critic response for generated super-resolved images, while the second term evaluates the response for real high-resolution images. Together, these two terms estimate the Wasserstein distance between the real and generated distributions. The third term is the gradient penalty regularization, which stabilizes training by constraining the gradient norm of the critic to remain close to one along interpolated samples between real and generated images. This regularization is essential for satisfying the Lipschitz continuity requirement and preventing unstable adversarial convergence.

To account for divergence, the discriminator loss function incorporates a divergence coefficient λ, which has a high value of 10. The YOLO-Flex detector loss function is defined as Ldet.

L(F)=λG⋅L(GRa)+λD⋅[L(DRa)+ϱ⋅LGP]+λdet⋅Ldet(17)

The loss weighting coefficients, λG=1.0 for the generator, λD=0.05 for the discriminator, and λdet=0.01 for the detector, were determined through iterative tuning informed by the relative scale and stability of each loss component during joint training. The generator loss was assigned the highest weight to prioritize structural reconstruction fidelity and edge preservation, as degradation in these qualities directly undermines downstream detection performance. The discriminator weight was kept intentionally small to stabilize GAN training dynamics and suppress texture hallucination, a known failure mode when adversarial pressure is applied too aggressively in SR tasks. The comparatively low detector weight reflects the scale disparity between the SR reconstruction loss and the detection loss in the early phases of joint optimization, when the SR generator has not yet produced outputs of sufficient quality for the detector to extract reliable gradients. To address this instability, a two-phase training protocol was employed: in Phase 1, the SR network was pretrained for 50 epochs with λ3=0 to establish a baseline reconstruction quality; in Phase 2, joint training was conducted for an additional 100 epochs with λ3=0.01, allowing detection gradients to refine the SR output geometry without destabilizing the perceptual quality achieved in Phase 1. The complete procedure, including parameter initialization, per-epoch update rules, and gradient flow through the SR generator, is formalized in Algorithm 1.

3.2 Detector Network Structure Alteration

Before describing the individual structural modifications, it is important to establish the design philosophy that governs the YOLO-Flex detector as a whole. The modifications introduced in this section are not proposed as isolated algorithmic contributions, nor do they represent the unreflective assembly of available components. Rather, each decision follows from a shared set of design constraints imposed by the target problem: the detection of objects occupying fewer than 32×32 pixels in images reconstructed from LR inputs, at inference speeds suitable for real-time UAV deployment, and within the parameter budget of a lightweight network deployable on resource-constrained hardware. Standard YOLOv5, while highly capable across general object detection benchmarks, was not designed with these constraints in mind. Its three-scale detection architecture allocates equal capacity to large, medium, and small objects, which introduces unnecessary computational overhead when the target distribution is heavily skewed toward small objects, as is the case in the VisDrone, DOTA, and COWC datasets used in this study. The detector modifications described in the following subsections systematically realign the network’s capacity toward the small object regime through four co-designed decisions: asymmetric backbone reduction, the addition of a stride-4 detection head, task-aware SE attention placement, and a trimmed bidirectional feature fusion pathway. The interaction among these decisions, rather than any single decision in isolation, produces the efficiency and accuracy profile reported later in the experiments section.

The YOLO-Flex detector network is designed to address the SOD problem by evaluating and restructuring some core components of the default YOLOv5 architecture alongside other optimization steps. The gradient of the overall loss is computed through back-propagation and adequate modifications are applied to the weights of both discriminator and generator networks to enhance optimization.

The standard YOLOv5 structure generates feature maps at three scales for detecting multiple-sized objects, which leads to the generation of unnecessary computational resources and parameters when detecting small objects. To address this, we remove layers responsible for feature fusion and convolution down-sampling on high-level feature maps. We also discard the high-resolution feature maps from the initial convolutional layers, which are unnecessary for most object detection tasks. This streamlining process results in a more efficient lightweight network, reducing computational resource demands of the backbone network and improving SOD accuracy. Additionally, every layer within the backbone network is annotated with its module name, the number of parameters it employs, and the relevant parameters, encompassing the input/output channel values and the convolution kernel attributes. In the simplified rendition of the backbone, the sampling layers are omitted, reflecting a substantial reduction in parameter count, as represented in Fig. 5.

Figure 5: Backbone disparity between Yolov5 and YOLO-Flex detector.

In our proposed model, we tackle the difficulty of detecting small objects by implementing a novel concatenation layer within the Neck module. This layer combines HR feature maps from the initial C3 layer of the backbone, preserving crucial spatial information. To achieve this, we integrate four new layers, including convolutional, upsample, concatenation, and C3 layers, within the Neck module. This addition increases the count of upsampled layers from 2 to 3, effectively reducing the loss of spatial data and enhancing the model’s detection capabilities.

To enhance the detection of small objects even more, we modify the YOLOv5 model by introducing an extra output layer with a reduced stride of 4. This new output layer complements the original strides of 32, 16, and 8, designed for detecting large, medium, and small objects. Lower strides lead to a denser detection grid, particularly beneficial for smaller objects, which form the predominant category in our datasets. As a result, our proposed architecture features three output heads with strides of 16, 8, and 4, focusing the model’s attention on small-sized objects. This structural improvement not only boosts detection accuracy but also decreases the overall size of the model, resulting in quicker inference speeds. For a detailed visual representation of these changes, refer to Fig. 6, where we use green and red color patches to highlight the added and removed layers, respectively.

Figure 6: Restructured detector architecture.

3.2.1 SEAM

To enhance feature extraction and consequently accuracy, we incorporated an innovative channel attention mechanism into the Backbone. The SE (Squeeze-and-Excitation) module [40] is a light network block that appends to the model an attention mechanism. Attention-based feature recalibration has also been widely adopted to enhance detection performance in fine-grained visual tasks. Attention-based feature recalibration has been widely adopted to enhance detection performance across fine-grained visual tasks. Hu et al. [40] demonstrated that the Squeeze-and-Excitation mechanism achieves effective channel-wise feature recalibration with minimal computational overhead, improving representational power by explicitly modelling interdependencies between feature channels. This principle has since been applied in numerous detection architectures, reinforcing the motivation for incorporating the SEAM module into the YOLO-Flex backbone to improve feature discrimination for small aerial object targets. Any baseline architecture can benefit from adding this straightforward and effective add-on module to gain better performance with barely perceptible computational burden. Fig. 7 provides a detailed visual representation of the Squeeze and Excitation module.

Figure 7: Squeeze & excitation attention module (SEAM).

The feature maps in CNNs are generated by the convolutional filter channels depending on the weights within the filters. The magnitude of the value of various feature maps varies, meaning some channels’ features are more significant than others. As a result, it is logical to assign higher significance to the “more vital” channels. This principle underlies the attention mechanism, which prioritizes channels containing extracted features more crucial to the detection task. The SE attention module offers a simple yet effective means of achieving this objective.

A convolutional layer generates feature map channels with dimensions H × W × C, representing the height, width, and number of channels (or convolutional kernels), respectively. To evaluate the significance of each feature channel, we employ Global Average Pooling (GAP) to condense the feature maps into a single numerical value. This process yields a vector of size n, where n corresponds to the number of convolutional channels. This vector is then fed into a two-layer neural network, producing an output vector of the same size. Subsequently, these n values serve as weights for the original feature maps, rescaling each channel according to its significance.

The SE block functions by taking an input convolutional block with a certain number of channels, reducing each channel to a single value through average pooling, introducing non-linearity via a fully connected layer followed by ReLU activation, and adjusting the channel complexity by using a specific ratio to transform feature channels. A second fully connected layer restores the channels to their original dimension, followed by a Sigmoid activation, resulting in a smooth gating function for each channel. This approach improves channel interaction understanding and reduces network parameters compared to using a single FC layer. We integrate these reduction and expansion layers to weigh feature maps in the convolutional block without significantly increasing computational costs.

In our research, we incorporate the SE attention module into the YOLOv5 Backbone, which primarily consists of Conv and C3 blocks. We implement the SE module between these two component blocks to enhance the utilization of features from the Conv block. Placing the SE layer after the initial two Conv layers in the backbone substantially increases the model’s parameters and negatively impacts training and inference speed due to high-resolution feature maps. To address this, we insert the SE module between the C3 and Conv layers after the third Conv layer.

Our proposed network exclusively applies the SE module within the backbone because the majority of feature extraction occurs in this region. The SE module is strategically applied only within the backbone, specifically between the C3 and Conv layers after the third convolutional stage, to balance efficiency and effectiveness. Introducing SE at earlier layers, where feature maps are large and encode low-level textures, leads to unnecessary computational overhead without meaningful performance gains. Experimental results showed that early placement increased parameters by about 18% and slowed inference by 3.2 ms per frame, with no significant improvement in detection accuracy. In contrast, positioning the SE module at deeper layers, where features are more semantically informative, enables effective channel recalibration with minimal cost, increasing parameters by less than 2%. Limiting SE usage to the backbone also ensures that attention is applied where feature extraction most strongly influences detection performance, making this placement both computationally efficient and empirically justified.

3.2.2 Feature Fusion Network Module (FFNM)

In this section, we explore feature fusion as an extension of Feature Pyramid Networks to effectively detect objects of various scales. This approach is motivated by the limitations of earlier algorithms that leveraged high-level feature maps for detection, failing to attain notable accuracy with regards to small objects. The basic processes of FPN [41], PANet [42], and BiFPN [43], which come together to form the improved feature fusion network employed by our detector network is depicted in Fig. 8. (a) depicts the basic structure of FPN feature fusion, (b) is the Path Aggregation Network PAN structure, (c) weighted bi-directional feature pyramid network (BiFPN), (d) is the effective aggregation of PAN and BiFPN called PBi-FPN, (e) is our improved and reduced PBi-FPN for low-pixel-count object detection.

Figure 8: Trimmed PBi-FPN feature fusion Path.

The proposed PBi-FPN differs from BiFPN and PANet in that it prioritizes low-pixel-count objects rather than treating all feature scales equally. While BiFPN applies symmetric bidirectional fusion across all pyramid levels and PANet enhances bottom-up pathways without addressing scale imbalance, both allocate unnecessary capacity to large-scale features that are less relevant for small objects. In contrast, PBi-FPN removes the stride-32 branch associated with large objects and strengthens feature fusion at high-resolution levels, particularly stride-8 and stride-4. This design preserves fine spatial details from the super-resolution module and prevents them from being diluted during fusion. With adaptive weighting, the network focuses on the most relevant feature scales, resulting in a structure that is better aligned with the characteristics of SOD tasks.

PBi-FPN improves upon traditional algorithms like PANet and BiFPN by introducing additional feature fusion pathways that facilitate the integration of features from the upper to the lower regions. Moreover, it incorporates new horizontal branches to enhance the bottom-up fusion process, thereby augmenting the algorithm’s capability to detect small objects. The conventional FPN, on the other hand, combines multi-scale features in a top-down fashion and can be described as follows:

Pnout=Conv(Pnin+Resize(Pn+1out))(18)

where n is the input feature level, Resize typically involves a matching resolution operation of up-sampling or down-sampling and Conv denotes a convolutional feature processing operation. Our final feature fusion path, PBi-FPN combines BiFPN, which integrates swift normalized fusion with bidirectional cross-scale connections, PANet, and our new augmented fusion paths, to further enrich top-to-bottom feature quality. The base network (Bi-FPN) for our proposed PAN aggregated bi-directional feature pyramid network (PBiFPN) is formulated as follows:

P4intd=Conv(ω1.P4in+ω2.Resize(P5in)ω1+ω2+ε)(19)

where P4intd is the intermediate feature map between P4in and P4out. Conv and Resize represent convolution and sampling operations, respectively. Meanwhile, ω and ε denote the weight and a small constant, often set to 0.0001 to maintain numerical stability.

P4out=Conv(ω1′⋅P4in+ω2′⋅P4intd+ω3′⋅Resize(P3out)ω1+ω2+ω3+ε)(20)

3.2.3 SPPF

The Fast-Spatial Pyramid Pooling (SPPF) module is a model performance enhancement module integrated into the most recent version of the YOLOv5 architecture. SPPF is an enhanced iteration of SPP; though mathematically identical, it requires fewer FLOPs. Our intuitive implementation of SPPF within the enhanced detector model is represented in Fig. 9.

Figure 9: SPPF block integration.

To harness the full potential of feature expression in the final output feature map between the network’s neck and the prediction head, and to enhance model performance, we introduced an SPPF module block at the intersection of these network sections.

4  Experimentation

4.1 Implementation Details

We conducted training for the YOLO-Flex detector using super-resolved images generated by the non-cyclic RFCN network to assess its detection performance under realistic spatially degraded scene conditions. All experiments were performed on an NVIDIA A100-SXM4-40 GB GPU using PyTorch 2.10.0 with CUDA 12.8. The detector was initialized from pretrained YOLOv5s weights and fine-tuned using the Stochastic Gradient Descent (SGD) optimizer with initial learning rate 0.01, momentum 0.937, weight decay 5e-4, and a cosine decay learning rate schedule with three warmup epochs. Complete implementation details are provided in the following section.

The training process was carried out using three benchmark datasets, namely COWC, VisDrone, and DOTA, which provide diverse object scales and real-world complexities suitable for evaluating SOD performance. All input images were resized to a fixed spatial resolution of 640×640 to maintain consistency across experiments and to align with standard object detection practices. The super-resolution module was configured with a fixed scale factor of ×4 throughout all quantitative experiments, based on prior ablation analysis demonstrating its optimal balance between reconstruction quality and detection performance.

The overall training schedule was designed to ensure convergence stability and sufficient feature learning across both the super-resolution and detection sub-networks. The models were trained for a total of 300 epochs using a batch size of 16. Model selection was performed based on validation set performance, specifically using mean Average Precision as the primary criterion. No early stopping mechanism was applied, as extended training was observed to improve both reconstruction fidelity and detection accuracy without overfitting under the chosen regularization settings.

Optimization of the super-resolution generator and discriminator networks was performed using the Adam optimizer, with momentum parameters β1=0.9 and β2=0.999. The initial learning rate for both networks was set to 1×10−4 to ensure stable convergence during adversarial training. In parallel, the detection network was optimized using stochastic gradient descent with a momentum of 0.937 and a weight decay factor of 5×10−4, which are commonly adopted configurations for YOLO-based architectures. This dual-optimizer strategy allows each component to be trained under conditions best suited to its learning dynamics.

A cosine annealing learning rate schedule was employed to gradually reduce the learning rate over the course of training, enabling smooth convergence toward optimal parameter values. The training process included a warm-up phase spanning the first five epochs, during which the learning rate was progressively increased from a small initial value to the predefined base learning rate. Following this phase, the learning rate decayed smoothly to a minimum value of 1×10−6, helping to stabilize late-stage training and refine model performance.

The proposed framework adopts a multi-objective loss formulation that integrates generator loss, discriminator loss, and detection loss into a unified optimization objective. The corresponding weighting coefficients were empirically determined and set to λ1=1.0 for the generator loss, λ2=0.05 for the discriminator loss, and λ3=0.8 for the detection loss. These values were selected based on validation experiments to balance reconstruction fidelity, adversarial realism, and detection accuracy. During training, gradients from the detection loss were propagated back into the super-resolution module, enabling task-aware feature enhancement that directly benefits low-pixel-count object detection performance.

The entire framework was trained in an end-to-end manner, allowing the generator, discriminator, and detector components to co-evolve during optimization. This joint training strategy ensures that the super-resolution module does not operate as an isolated preprocessing step, but rather as an integral part of the detection pipeline that adapts to the needs of downstream tasks. Such integration is particularly important for the detection of sub-32-pixel targets, where subtle improvements in feature representation can significantly impact localization and classification outcomes.

For evaluation, inference was conducted using a batch size of 1 to simulate real-world deployment conditions. The reported inference time was measured as the average forward-pass latency over 1000 iterations, excluding data loading and preprocessing overhead to ensure consistency. This evaluation protocol provides an accurate reflection of the computational efficiency of the proposed method and supports fair comparison with other state-of-the-art approaches.

In this section, we highlight the capabilities of our YOLO-Flex network and conduct a thorough evaluation. By comparing the results of our experiments with those obtained from other top-tier methods in the field, we aim to demonstrate its effectiveness and advantages. Additionally, we assess the performance of the conventional YOLOv5 detector for fine-grained object detection on SR images and contrast the outcomes with the detection performance observed in the HR version of the images. When our proposed solution is employed as a standalone model for image reconstruction tasks, the baseline network EDSR and EDSR-RFCN do not yield very high-quality images, as indicated in the following results of Table 1. In contrast, the YOLO-Flex SRGAN as a whole produces high-quality SR output images with significantly higher PSNR values.

Unless otherwise stated, all experiments in this study utilize a super-resolution scale factor of ×4. The choice of this scaling factor was guided by preliminary validation experiments and comparative analyses against existing GAN-based super-resolution methods. As summarized in Table 1, the ×4 setting yielded consistently strong reconstruction performance across the DOTA, VisDrone, and COWC datasets, achieving superior or highly competitive PSNR and SSIM values while preserving computational efficiency. Lower scaling factors provided limited enhancement of small-object details, whereas larger scaling factors introduced additional computational cost with diminishing performance gains.

All detection experiments in this study are evaluated using the standard 0.50 IoU thresholds, reported in the columns of Tables 2 and 3, to address both the specific requirements of the detection of sub-32-pixel targets and the need for cross-study comparability.

4.2 Dataset Aggregation

During experimentation, it was paramount that we use datasets closely relevant to the task, which also present the real scenario of detecting small objects. We therefore utilize three (3) highly referenced benchmark datasets to evaluate our method

•   The official VisDrone2019-DET train and validation splits were used. The training set contains 6,471 images and the validation set contains 548 images following the standard VisDrone 2021 challenge protocol taken from various street bird’s-eye perspectives. No custom filtering was applied. LR images were generated by bicubic downsampling at scale factor ×4. In addition, the images were taken from different perspectives, in a variety of settings and contain diverse targets.

•   The DOTA, compiled by Wuhan University, with 2806 images in it. The researcher’s initial concept for this dataset was to effectively test the detector’s efficacy on same objects of various sizes and directions. Consequently, the DOTA dataset has a large number of orientated objects when compared to other datasets. It contains 15 distinct classes and covers a range of pixel sizes from 30 × 30 to 1200 × 1200. As our test images, we use images with small objects. From the 2806 available images, a subset was selected using the criterion that at least 30% of annotated instances have bounding box areas smaller than 32 by 32 pixels. This yielded 1104 qualifying images split 70/15/15 for train, validation, and test with stratification by scene type. LR images were generated by bicubic downsampling at scale factor ×4.

•   The 58,247 annotated images that make up the COWC dataset were collected by Lawrence Livermore National Laboratory. The complete COWC dataset of 58,247 annotated images was used without filtering, as all vehicle annotations satisfy the small object criterion by construction, with bounding box dimensions ranging from 10 by 24 to 20 by 48 pixels. The dataset was split 80/10/10 following the official Lawrence Livermore partition. LR images were generated by bicubic downsampling at scale factor x4. We acknowledge that COWC introduces a strong single-class vehicle bias and explicitly frame it as a domain-specific evaluation rather than a general benchmark in the revised discussion.

The dataset’s label count and label density are depicted in Fig. 10a. The histogram distribution of the object of interest within the dataset is shown in Fig. 10b. As can be seen, this dataset is adequate for our SOD algorithm’s training and validation.

Figure 10: Comprehensive dataset analysis.

4.3 SOD with YOLO-Flex Detector

We conducted training for our novel object detector using SR images generated by the non-cyclic RFCN network to assess its performance. We employed LR images from the same datasets for both model training and testing. These SR and LR images served as the training data for our YOLO-Flex model.

As shown in Tables 2 and 3, compared with lightweight baseline detectors such as YOLOv5n and YOLOv7-tiny, the proposed method demonstrates substantial gains, particularly under the stricter Common Objects in Context (COCO)-style metric. These improvements validate the effectiveness of integrating super-resolution reconstruction with structure-preserving feature enhancement for dense aerial small-object scenarios. Although the inclusion of the RFCN module increases inference latency, the full framework maintains an effective throughput, which satisfies standard real-time deployment requirements. This trade-off is justified by the substantial gain in detection accuracy, particularly for small and limited resolution image targets.

The increase in computational cost arises primarily from the super-resolution reconstruction stage. Nevertheless, the proposed framework preserves real-time applicability for practical surveillance, UAV monitoring, and autonomous perception tasks where frame rates above 30 frames per second (FPS) are generally sufficient. All latency measurements were obtained on an NVIDIA RTX 3090 GPU with batch size 1 and input resolution 640×640. For resource-constrained edge deployment, the lightweight YOLO-Flex detector may be used independently, while the full RFCN-enhanced pipeline is recommended for accuracy-critical applications.

The effectiveness of our detector, measured in terms of mean Average Precision (mAP), is detailed in Table 4, where it is contrasted with different versions of the baseline YOLOv5 detector. Additionally, Fig. 11 offers visual examples of super-resolution and detection across the chosen datasets.

Figure 11: SR Comparison on COWC, VisDrone & DOTA datasets.

The resolution results present a qualitative comparison of super-resolution outputs across the three evaluation datasets. Several observations merit discussion. On the COWC dataset, the YOLO-Flex output preserves vehicle boundary sharpness more faithfully than Bicubic, EDSR, and LapSRN, particularly for vehicles near the image border where bicubic interpolation introduces ringing artifacts. On VisDrone, the overhead perspective introduces extreme scale variation between pedestrians in the foreground and vehicles in the background; YOLO-Flex maintains consistent reconstruction quality across both scales, whereas SRGAN and ESRGAN-DP tend to over-sharpen high-contrast regions while under-sharpening low-contrast background areas. On DOTA, the oriented object challenge is most visible, with aircraft and ship boundaries exhibiting characteristic blurring in bicubic outputs that YOLO-Flex substantially reduces. Across all three datasets, the detection bounding boxes overlaid in column C confirm that the super-resolved outputs preserve sufficient geometric accuracy for localization, with bounding box centers aligning closely with ground-truth object positions even at scale factor ×4 degradation.

While all the object detectors perform similarly well in detecting objects in high-resolution (HR) images, our proposed method consistently achieves the highest Average Precision (AP) values as the scale factor increases.

These statistics illustrate an enhancement in the overall detection performance. The parameter count and computational cost (GFLOPs) of the YOLO-Flex network are substantially reduced, reflecting a more efficient architecture in both the model’s parameter count and computational demands, making it much more accessible for deployment on low-end workstations and compact mobile devices. Furthermore, YOLO-Flex’s increased speed in low-pixel-count object recognition, as evidenced by the decreased inference time (ms), enables it to process a greater number of images and video frames per unit time.

4.4 Ablation Studies

In this subsection,we undertake a series of experiments and ablation analyses to demonstrate the contribution of each proposed module. We begin experimentation with a baseline model and consecutively implement all proposed modules building up to our final proposed architecture. The baseline result is shown in row 1 of Table 5. Consequently, we iteratively conduct the implementation of each module in combination with the other modules in order to evaluate the improvement of each module on the baseline. All experimentation for ablation studies in this paper is conducted on the VisDrone dataset.

Firstly, the significance of incorporating a clustering module at the end of the residual blocks to prevent the loss of vital feature information is evaluated. As a result, the RFCN cluster block is appended to the baseline network, resulting in a 1.8% increase in mAP for super resolution. Next, the output of the baseline EDSR network is utilized in the reduced version of our detector to create a lighter network. The backbone reduction (BR) process is integrated, enhancing detection speed and accuracy by focusing more resources on small objects. By implementing detector optimization techniques, integrating the Squeeze & Excitation Module (SEAM), modifying the feature fusion path network, and utilizing the Fast Spatial Pyramid Pooling (SPPF) between the neck and detection head, a measurable increase in precision is achieved compared to the baseline network. Finally, the discriminator loss function (ARD) is introduced to further enhance the mAP. These experimental results validate the hypothesis that residual feature clustering plays a significant role in image super-resolution for small objects.

To provide a formal complexity analysis, Table 6 presents a module-level breakdown of the parameter count, computational cost in GFLOPs, and storage footprint for each component of the YOLO-Flex framework. All detector subnetwork values were measured directly on a single 640×640 input tensor. The SR module figures are derived from the 32-block RFCN architecture operating on 128×128 feature maps. This breakdown clarifies that the dominant computational cost of the full pipeline resides in the RFCN super-resolution generator (51.3G FLOPs), while the YOLO-Flex detector subnetwork requires only 8.0 GFLOPs per inference pass. The detector-only cost of 8.0 GFLOPs is internally consistent with the measured parameter count of 7.05M, resolving the apparent discrepancy between detector-only parameters and full-pipeline FLOPs reported in earlier versions of the comparison tables. All inference timings were measured on an NVIDIA A100-SXM4-40 GB GPU with a batch size of 1 to reflect real-world single-image deployment conditions.

The detector-only row most clearly illustrates the efficiency advantage of YOLO-Flex: 7.05M parameters and 8.0 GFLOPs represent a 6.0× reduction in computational cost compared to YOLOv5m (21.4M parameters, 48.0 GFLOPs) at comparable mAP@0.5 performance on VisDrone2019-DET. For resource-constrained UAV deployment scenarios where real-time SR preprocessing is not feasible, the YOLO-Flex detector may be deployed independently at 8.0 GFLOPs, while the full RFCN-enhanced pipeline is recommended for accuracy-critical applications where latency constraints permit. Additionally, Table 7 presents the ablation results for different reconstruction loss configurations. Although the MSE (L2) loss achieves the highest PSNR value, its detection performance remains inferior due to the smoothing effect on fine structural details. In contrast, the L1 loss preserves sharper object boundaries and local textures, resulting in improved detection accuracy, particularly for small objects. The integration of the Average Relativistic Discriminator (ARD) further enhances perceptual fidelity and contextual realism, leading to notable gains in APS and recall. When the detector loss is jointly optimized with the super-resolution and adversarial objectives, the proposed YOLO-Flex framework achieves the best overall performance, confirming the effectiveness of task-aware end-to-end optimization.

Table 8 shows that the ×4 scale factor provides the best overall performance. Although ×8 offers higher magnification, it introduces reconstruction artifacts and increases computational overhead, which negatively affects downstream detection performance. Conversely, ×2 provides limited structural enhancement for extremely small targets. Therefore, ×4 was selected as the default scale factor for all quantitative experiments.

Table 9 shows that simple concatenation without dimensionality control leads to parameter growth and limited efficiency gains. In contrast, the proposed RFCN achieves a superior $mAP@0.5$ performance of 50.3 combining feature diversity preservation with adaptive channel compression. This demonstrates that controlled feature aggregation provides a more effective representation for super-resolution and downstream detection tasks. From a representational perspective, element-wise addition can be interpreted as a linear projection that compresses multiple feature responses into a shared subspace, whereas concatenation preserves feature independence prior to fusion. This allows the network to learn richer combinations of local structures before dimensionality reduction.

5  Discussion

The detection results obtained from our methodology demonstrate that our end-to-end SR detector network significantly enhances accuracy when compared to various other techniques. Specifically, our approach has shown an increased performance over leading standalone methods, especially when applied to resolution-impaired remote sensing images. The integration of a unified framework for super-resolution and detection, exemplified by YOLO-Flex, represents a major step forward in optimizing the detection of small objects in spatially degraded image contexts. By employing a GAN-based strategy through the Residual Feature Cluster Network (RFCN) derived from the EDSR baseline, we effectively tackle the limitations faced by traditional super-resolution techniques that often incur substantial computational costs. Our experiments indicated that the YOLO-Flex detector outperformed other approaches, with the cluster network contributing to enhanced detection precision. Additionally, we observed that precision improved with increased image resolution. The average precision (AP) values for the COWC dataset were lower compared to those for the VisDrone dataset, likely due to VisDrone having a broader range of classes and more variability in object sizes and colors than the car-focused dataset.

YOLO-Flex differs from prior super-resolution and detection frameworks by adopting joint optimization rather than treating both stages independently. Existing approaches train the super-resolution module solely for visual quality, which creates a mismatch since detection performance is not considered during training. In contrast, YOLO-Flex integrates detection loss into the super-resolution training process, allowing the model to generate images that preserve spatial details critical for small object localization. This design leads to superior reconstruction quality, as reflected by higher PSNR results, and improves detection accuracy. The consistent performance gains observed across ablation studies further confirm that each component contributes meaningfully, demonstrating a coherent and task-driven integration strategy rather than a simple combination of modules.

Our system not only enhances images but also preserves vital object features necessary for effective detection. Fig. 12 presents a qualitative visualisation of YOLO-Flex super-resolution and detection outputs across three datasets. Our findings revealed that improved loss functions within the GAN framework reduced the differences between enhanced images and their real counterparts, which is crucial for ensuring accurate input for the YOLO-Flex detection module. This adjustment enhances feature preservation during image enhancement, leading to stronger object detection outcomes and potentially lowering false-negative rates significantly. While the combination of ESRGAN and the EfficientDet detector yielded the best mean average precision (mAP at 0.95), it required longer inference times than our YOLO-Flex detector. From a rigorous relevant literature review, we also observed that for large-area detection needs, YOLO models are preferable even at the expense of some accuracy.

Figure 12: Detection result on our super-resolved images.

The foundational components and baseline model of our strategy typically demand considerable computational power for both training and inference, which becomes particularly intensive when processing high-resolution images or extensive datasets. Consequently, we conducted our research on a randomly selected subset of a more extensive dataset featuring diverse scenes. We believe that utilizing additional data from various regions and seasons could further enhance the robustness and accuracy of our approach, representing a limitation in our current experimental design. Another limitation concerns the datasets used, which are primarily aerial vehicle scenes with limited class diversity, primarily comprising car scenes with limited variation relevant to our specific application. We intend to investigate our method’s performance across a wider array of object types and landscapes from different satellite data sources in future work.

Furthermore, our novel data augmentation technique significantly enhances the efficacy of the YOLO-Flex model by enriching the training dataset with simulations of diverse environmental conditions that UAV imagery may encounter. This augmentation includes manipulations such as rotations, flips, and synthetic noise applications, enabling the model to generalize better to unseen data while reducing the overfitting risk. Analysis has shown that this augmentation-based approach leads to significant gains in precision and recall metrics during detection tasks.

Our architecture was trained using pairs of LR and HR images, with the LR images generated artificially from the HR versions. To our knowledge, a publicly available satellite dataset featuring genuine HR and LR image pairs along with ground truth bounding boxes for detecting small objects does not exist. Therefore, the artificially created LR images may not correlate completely with authentic LR images. Nonetheless, enhancing resolution through deep learning consistently improves detection performance on remote sensing images, both artificial and genuine low-resolution samples.

In summary, by combining GAN-enhanced super-resolution with a well-organized augmentation strategy, the YOLO-Flex framework not only improves the visibility of small objects in spatially degraded UAV imagery but also significantly boosts detection performance. This advancement opens up opportunities for more effective applications in fields such as surveillance and environmental monitoring.

6  Conclusions & Future Work

This paper presents YOLO-Flex, an integrated framework for detecting small objects in low-resolution aerial imagery through the co-design of a super-resolution network and a task-adapted object detection network. The framework introduces the Residual Feature Cluster Network as the GAN generator, trained jointly with the detection network through a unified loss function that propagates detection gradients into super-resolution optimization. The YOLO-Flex detector incorporates principled backbone reduction, a stride-4 detection head, SEAM channel attention, and a trimmed PBi-FPN feature fusion network. The super-resolution module achieves PSNR of 31.852 dB on the DOTA dataset, surpassing published methods including SPSR at 31.575 dB and ESRGAN-DP at 31.520 dB. The detector subnetwork contains 7.05 million parameters, requires 8.0 GFLOPs per inference, and occupies 54.3 MB of storage, representing computational reductions of 6.0, 6.0, and 3.0 times respectively compared to YOLOv5m. These efficiency characteristics make YOLO-Flex suitable for deployment on resource-constrained platforms including embedded UAV systems and edge computing devices.

However, we acknowledge certain limitations in our research process. We explore the strengths and weaknesses of our methodology, particularly focusing on the challenges associated with integrating super-resolution techniques into fine-grained object detection models. The complex landscape of deep learning solutions for the detection of low-pixel-count objects highlights the difficulty in achieving an optimal balance between real-time performance and computational demands. Therefore, in our research, we faced the computational challenges linked with the YOLO-Flex super-resolution approach. Although the substantial computational resources needed for our experiments were somewhat manageable, they still posed limitations on its practicality, especially within our resource-constrained environment.

Future work will focus on full convergence training on complete dataset splits, integration of attention mechanisms into the SR module, and extension to video-based small object tracking. Also, practical steps will focus on comprehensive training of both sub-networks, with the aim of further simplifying the architecture and reducing inference times, which is particularly important for deployment on mobile and edge devices. These directions reflect a proactive approach to addressing existing challenges and performance enhancement of SOD and tracking methods.

Acknowledgement: The authors would like to thank the Software College of Northeastern University and the Software College Artificial Intelligence Laboratory for providing the computational resources used in conducting the experiments reported in this study.

Funding Statement: This work is supported by the National Natural Science Foundation of China (62072094), the Liaoning Revitalization Talents Program (XLYC2005001).

Author Contributions: The authors confirm contribution to the paper as follows: Conceptualization, Abdulhamid Victor Ibrahim; methodology, Abdulhamid Victor Ibrahim; validation, Haoyuan Li; investigation, Abdulhamid Victor Ibrahim; resources, Bingyang Guo; software, Abdulhamid Victor Ibrahim; data curation, Haoyuan Li; writing—original draft preparation, Abdulhamid Victor Ibrahim; writing—review and editing, Bingyang Guo; visualization, Abdulhamid Victor Ibrahim; supervision, Ruiyun Yu; project administration, Ruiyun Yu. All authors reviewed and approved the final version of the manuscript.

Availability of Data and Materials: The datasets used in this study are publicly available. The VisDrone2019-DET dataset is maintained by the AISKYEYE Team at Tianjin University and can be accessed at https://github.com/VisDrone/VisDrone-Dataset. The COWC (Cars Overhead With Context) dataset is maintained by Lawrence Livermore National Laboratory and is available at https://gdo152.llnl.gov/cowc/. No proprietary or restricted datasets were used in this study.

Ethics Approval: Not applicable.

Conflicts of Interest: The authors declare no conflict of interest.

References

1. Yang J, Wright J, Huang TS, Ma Y. Image super-resolution via sparse representation. IEEE Trans Image Process. 2010;19(11):2861–73. [Google Scholar] [PubMed]

2. Dong C, Loy CC, He K, Tang X. Image super-resolution using deep convolutional networks. IEEE Trans Pattern Anal Mach Intell. 2015;38(2):295–307. doi:10.1109/tpami.2015.2439281. [Google Scholar] [PubMed] [CrossRef]

3. Ledig C, Theis L, Huszár F, Caballero J, Cunningham A, Acosta A, et al. Photo-realistic single image super-resolution using a generative adversarial network. In: 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2017. p. 4681–90. [Google Scholar]

4. Jocher G, Stoken A, Borovec J, Chaurasia A, Tao X, Liu C, et al. ultralytics/yolov5: v5. 0-YOLOv5-P6 1280 models, AWS, Supervise.ly and YouTube integrations. Zenodo. 2021. doi:10.5281/zenodo.3908559. [Google Scholar] [CrossRef]

5. Ren S, He K, Girshick R, Sun J. Faster R-CNN: towards real-time object detection with region proposal networks. arXiv:1506.01497. 2015. [Google Scholar]

6. Cao C, Wang B, Zhang W, Zeng X, Yan X, Feng Z, et al. An improved faster R-CNN for small object detection. IEEE Access. 2019;7:106838–46. doi:10.1109/ACCESS.2019.2932731. [Google Scholar] [CrossRef]

7. Cao G, Xie X, Yang W, Liao Q, Shi G, Wu J. Feature-fused SSD: fast detection for small objects. In: Proceedings of the International Conference on Graph and Image Processing (ICGIP 2018). Piscataway, NJ, USA: IEEE; 2018. p. 381–8. [Google Scholar]

8. Cui L, Ma R, Lv P, Jiang X, Gao Z, Zhou B, et al. MDSSD: multi-scale deconvolutional single shot detector for small objects. arXiv:1805.07009. 2018. [Google Scholar]

9. Guan L, Wu Y, Zhao J. SCAN: semantic context aware network for accurate small object detection. Int J Comput Intell Syst. 2018;11(1):951–61. doi:10.2991/ijcis.11.1.72. [Google Scholar] [CrossRef]

10. Zhang S, Wen L, Bian X, Lei Z, Li SZ. Single-shot refinement neural network for object detection. In: 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2018. p. 4203–12. [Google Scholar]

11. Yan J, Wang H, Yan M, Diao W, Sun X, Li H. IoU-adaptive deformable R-CNN for object detection in remote sensing imagery. Remote Sens. 2019;11(3):286. [Google Scholar]

12. Zhang W, Wang S, Thachan S, Chen J, Qian Y. Deconv R-CNN for small object detection on remote sensing images. In: IGARSS 2018—2018 IEEE International Geoscience and Remote Sensing Symposium. Piscataway, NJ, USA: IEEE; 2018. p. 2483–6. [Google Scholar]

13. Ren Y, Zhu C, Xiao S. Small object detection in optical remote sensing images via modified Faster R-CNN. Appl Sci. 2018;8(5):813. doi:10.3390/app8050813. [Google Scholar] [CrossRef]

14. Qureshi A, Khan M, Ali Z, Raza S. Semantic segmentation and YOLO detector over aerial vehicle images. Comput Mat Cont. 2024;80(2):3315–32. doi:10.32604/cmc.2024.052582. [Google Scholar] [CrossRef]

15. Liu M, Wang X, Zhou A, Fu X, Ma Y, Piao C. UAV-YOLO: small object detection in UAV imagery. Sensors. 2020;20(8):2238. [Google Scholar] [PubMed]

16. Pham MT, Courtrai L, Friguet C, Lefevre S, Baussard A. YOLO-Fine: one-stage detector for small objects in remote sensing images. Remote Sens. 2020;12(15):2501. doi:10.3390/rs12152501. [Google Scholar] [CrossRef]

17. Zhao K, Ren X. Small aircraft detection in remote sensing images based on YOLOv3. IOP Conf Ser Mater Sci Eng. 2019;533:012056. [Google Scholar]

18. Nina W, Condori W, Machaca V, Villegas J, Castro E. Small ship detection on optical satellite imagery with YOLO and YOLT. In: Advances in information and communication. Cham, Switzerland: Springer; 2020. p. 664–77. [Google Scholar]

19. Van Etten A. You only look twice: rapid multi-scale object detection in satellite imagery. arXiv:1805.09512. 2018. [Google Scholar]

20. Xie Y, Cai J, Bhojwani R, Shekhar S, Knight J. Locally-constrained YOLO for detecting small building footprints. Int J Geogr Inf Sci. 2020;34(4):777–801. doi:10.1080/13658816.2019.1624761. [Google Scholar] [CrossRef]

21. Wang J, Lin Y, Guo J, Zhuang L. SSS-YOLO: detection for small ships in SAR images. Remote Sens Lett. 2021;12(2):93–102. [Google Scholar]

22. Lamichhane BR, Srijuntongsiri G, Horanont T. CNN based 2D object detection techniques: a review. Front Comput Sci. 2025;7:1437664. doi:10.3389/fcomp.2025.1437664. [Google Scholar] [CrossRef]

23. Zhu P, Wen L, Du D, Bian X, Fan H, Hu Q, et al. Detection and tracking meet drones challenge. IEEE Trans Pattern Anal Mach Intell. 2021;44(11):7380–99. doi:10.1109/tpami.2021.3119563. [Google Scholar] [PubMed] [CrossRef]

24. Goodfellow I, Pouget-Abadie J, Mirza M, Xu B, Warde-Farley D, Ozair S, et al. Generative adversarial networks. Commun ACM. 2020;63(11):139–44. [Google Scholar]

25. Lim B, Son S, Kim H, Nah S, Lee KM. Enhanced deep residual networks for single image super-resolution. In: 2017 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2017. p. 136–44. [Google Scholar]

26. Sajjadi MSM, Schölkopf B, Hirsch M. EnhanceNet: single image super-resolution via texture synthesis. In: Proceedings of the 2017 IEEE International Conference on Computer Vision. Piscataway, NJ, USA: IEEE; 2017. p. 4491–500. [Google Scholar]

27. Lai WS, Huang JB, Ahuja N, Yang MH. Deep Laplacian pyramid networks for super-resolution. In: 2017 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2017. p. 624–32. [Google Scholar]

28. Hitawala S, Li Y, Wang X, Yang D. Image super-resolution using VDSR-ResNeXt and SRCGAN. arXiv:1810.05731. 2018. [Google Scholar]

29. Li Z, Yang J, Liu Z, Yang X, Jeon G, Wu W. Feedback network for image super-resolution. In: 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2019. p. 3867–76. [Google Scholar]

30. Dai T, Cai J, Zhang Y, Xia ST, Zhang L. Second-order attention network for image super-resolution. In: 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2019. p. 11065–74. [Google Scholar]

31. Xu YS, Tseng SY, Tseng Y, Kuo HK, Tsai YM. Unified dynamic convolutional network for super-resolution. In: 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2020. p. 12496–505. [Google Scholar]

32. Ferdous SN, Mostofa M, Nasrabadi NM. Super-resolution-assisted aerial vehicle detection. In: Proceedings of SPIE 11006, Artificial Intelligence and Machine Learning for Multi-Domain Operations Applications. Bellingham, WA, USA: SPIE; 2019. p. 432–43. [Google Scholar]

33. Bashir SMA, Wang Y. Small object detection with super-resolution and feature aggregation. Remote Sens. 2021;13(9):1854. [Google Scholar]

34. Rabbi J, Ray N, Schubert M, Chowdhury S, Chao D. Small object detection with edge-enhanced GAN. Remote Sens. 2020;12(9):1432. [Google Scholar]

35. Wang X, Yu K, Wu S, Gu J, Liu Y, Dong C, et al. ESRGAN: enhanced super-resolution GAN. In: Computer Vision—ECCV 2018 Workshops. Cham, Switzerland: Springer; 2018. p. 63–79. [Google Scholar]

36. Jiang K, Wang Z, Yi P, Wang G, Lu T, Jiang J. Edge-enhanced GAN for remote sensing image super-resolution. IEEE Trans Geosci Remote Sens. 2019;57(8):5799–812. doi:10.1109/tgrs.2019.2902431. [Google Scholar] [CrossRef]

37. Zhang Y, Tian Y, Kong Y, Zhong B, Fu Y. Residual dense network for image super-resolution. In: Proceedings of the 2018 IEEE Conference on Computer Vision and Pattern Recognition. Piscataway, NJ, USA: IEEE; 2018. p. 2472–81. [Google Scholar]

38. Arjovsky M, Chintala S, Bottou L. Wasserstein generative adversarial networks. In: Proceedings of the 34th International Conference on Machine Learning (ICML 2017). Cambridge, MA, USA: PMLR; 2017. p. 214–23. [Google Scholar]

39. Jolicoeur-Martineau A. The relativistic discriminator: a key element missing from standard GAN. arXiv:1807.00734. 2018. [Google Scholar]

40. Hu J, Shen L, Sun G. Squeeze-and-excitation networks. In: 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2018. p. 7132–41. [Google Scholar]

41. Lin TY, Dollár P, Girshick R, He K, Hariharan B, Belongie S. Feature pyramid networks for object detection. In: 2017 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2017. p. 2117–25. [Google Scholar]

42. Liu S, Qi L, Qin H, Shi J, Jia J. Path aggregation network for instance segmentation. In: 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2018. p. 8759–68. [Google Scholar]

43. Tan M, Pang R, Le QV. Efficientdet: scalable and efficient object detection. In: 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). Piscataway, NJ, USA: IEEE; 2020. p. 10781–90. [Google Scholar]

44. Redmon J, Farhadi A. YOLOv3: an incremental improvement. arXiv:1804.02767. 2018. [Google Scholar]

45. Bochkovskiy A, Wang CY, Liao HYM. YOLOv4: optimal speed and accuracy of object detection. arXiv:2004.10934. 2020. [Google Scholar]

46. Wang CY, Bochkovskiy A, Liao HY. YOLOv7: trainable bag-of-freebies sets new state-of-the-art for real-time object detectors. In: Proceedings of the 2023 IEEE/CVF Conference on Computer Vision and Pattern Recognition. Piscataway, NJ, USA: IEEE; 2023. p. 7464–75. [Google Scholar]

47. Jocher G, Chaurasia A, Qiu J. YOLOv8: ultralytics official release [Internet]. Ultralytics. 2023 [cited 2026 Jun 2]. Available from: https://github.com/ultralytics/ultralytics. [Google Scholar]

48. Jocher G, Qiu J. Ultralytics YOLO11 [Internet]. Ultralytics. 2024 [cited 2026 Jun 2]. Available from: https://github.com/ultralytics/ultralytics. [Google Scholar]

49. Wang CY, Yeh IH, Mark Liao HY. Yolov9: learning what you want to learn using programmable gradient information. In: Computer Vision—ECCV 2024 (ECCV 2024). Cham, Switzerland: Springer Nature; 2024. p. 1–21. [Google Scholar]

50. Wang A, Chen H, Liu L, Chen K, Lin Z, Han J, et al. Yolov10: real-time end-to-end object detection. Adv Neural Inform Process Syst. 2024;37:107984–8011. [Google Scholar]

51. Zhu X, Lyu S, Wang X, Zhao Q. TPH-YOLOv5: improved YOLOv5 based on transformer prediction head for object detection on drone-captured scenarios. In: Proceedings of the 2021 IEEE/CVF International Conference on Computer Vision. Piscataway, NJ, USA: IEEE; 2021. p. 2778–88. [Google Scholar]

52. Xu X, Jiang Y, Chen W, Huang Y, Zhang Y, Sun X. Damo-yolo: a report on real-time object detection design. arXiv:2211.15444. 2022. [Google Scholar]

53. Li C, Li L, Jiang H, Weng K, Geng Y, Li L, et al. YOLOv6: a single-stage object detection framework for industrial applications. arXiv:2209.02976. 2022. [Google Scholar]

54. Wang C, He W, Nie Y, Guo J, Liu C, Wang Y, et al. Gold-YOLO: efficient object detector via gather-and-distribute mechanism. Adv Neural Inform Process Syst. 2023;36:51094–112. [Google Scholar]

55. Chen Y, Yuan X, Wang J, Wu R, Li X, Hou Q, et al. Rethinking multi-scale representation learning for real-time object detection. IEEE Trans Pattern Anal Mach Intell. 2025;47(6):4240–52. doi:10.1109/tpami.2025.3538473. [Google Scholar] [PubMed] [CrossRef]