The Evolution and Advancement of YOLO Algorithms in Object Detection: From Real-Time Breakthroughs to Modern Architectures

1. Introduction

The ability of machines to see and comprehend their surroundings by recognizing and locating objects within images or video streams, referred to as object detection, is fundamental in modern Artificial Intelligence (AI) [1]. In the rapidly advancing field of computer vision, object detection has emerged as a cornerstone task with significant implications across numerous domains, from autonomous driving and surveillance to healthcare and robotics [2]. The central goal of object detection is to accurately locate and classify objects within an image or video stream, a task once dominated by computationally intensive algorithms dependent on handcrafted features [3].

In its early stages, object detection relied heavily on feature-engineering techniques such as Scale-Invariant Feature Transform (SIFT) and Histogram of Oriented Gradients (HOG), paired with classical classifiers like Support Vector Machines (SVMs) [4]. These methods struggled with common challenges such as occlusion, scale variation, background clutter, and lighting changes. Despite incremental improvements, the pipeline remained modular, involving distinct stages for region proposal, feature extraction, and classification, each contributing to inefficiency and latency. The advent of deep learning, and particularly Convolutional Neural networks (CNNs), marked a turning point. End-to-end models such as R-CNN, Fast R-CNN, and Faster R-CNN significantly enhanced accuracy and learning capability by leveraging CNNs for automatic feature extraction and joint optimization [5,6]. However, these region proposal-based approaches still involved computationally intensive steps that limited their suitability for real-time applications.

A paradigm shift occurred with the introduction of the “You Only Look Once” (YOLO) framework by [7] – a watershed moment for real-time object detection. Unlike its predecessors, YOLO approached detection as a regression problem, unifying object classification and localization into a single neural network. The model divided the image into a grid, where each cell was responsible for predicting bounding boxes and class probabilities. This elegant single-stage architecture eliminated the costly region proposal step and enabled real-time inference speeds, achieving up to 45 frames per second on benchmarks like PASCAL VOC—without compromising significantly on accuracy [7]. YOLO’s real-time capability quickly positioned it as a preferred choice for latency-sensitive domains, such as autonomous navigation, drone vision, and live surveillance. Its architectural simplicity and speed-performance trade-off inspired further innovations that gradually enhanced robustness, accuracy, and scalability.

Over time, the YOLO framework evolved through a series of meticulously engineered upgrades. YOLOv2 and YOLOv3 tackled scale variance and feature resolution with multi-scale predictions and residual connections [8]. YOLOv4 and YOLOv5 introduced CSPDarknet and novel data augmentation strategies like Mosaic, pushing the envelope of performance and generalization. Further advancements in YOLOv6 and YOLOv7 incorporated deeper backbones, quantization-aware training, and Transformer-inspired components, enhancing detection robustness and hardware adaptability [8]. With YOLOv8, the architecture adopted an anchor-free design, integrated a more efficient CSPNet backbone, and utilized a FPN+PAN neck to bolster multi-scale detection [9]. The innovation continued with YOLOv9, which addressed information loss in deep networks via Programmable Gradient Information (PGI) and the lightweight yet powerful GELAN backbone [10]. YOLOv10 advanced efficiency on edge devices by eliminating the need for non-maximum suppression (NMS) through dual-consistent assignments, while embracing a holistic, unified architecture [11].

Most recently, YOLOv12 represents the cutting edge in the series. Integrating attention mechanisms, Transformer-CNN hybrids, and cross-scale fusion, YOLOv12 achieves a delicate balance between precision and speed. It excels in small-object detection, improves dynamic label assignment, and pushes the limits of real-time detection capabilities, demonstrating how far YOLO has come from its origins [12,13].

This review aims to provide a comprehensive exploration of the YOLO algorithm’s journey, beginning with its foundational design principles and traversing through its evolution up to the state-of-the-art YOLOv12. In addition to dissecting architectural advancements, we will analyze comparative benchmarks, latency-accuracy trade-offs, and practical deployments in real-world settings. By reflecting on the trajectory from YOLOv1 to YOLOv12, this article not only chronicles a technological evolution but also highlights the underlying scientific innovations that continue to drive forward the capabilities of real-time object detection. The literature indicates that YOLO’s sustained prominence in academic and industrial domains stems from its balance between architectural simplicity and performance sophistication. Whether used for pedestrian detection in autonomous vehicles or embedded within mobile applications for precision agriculture, YOLO continues to demonstrate versatility and robustness across diverse contexts.

This review article comprehensively examines the evolution and advancement of the YOLO algorithms. We begin by establishing the fundamentals of object detection and the context of traditional models that preceded the deep learning revolution in Section 2. We then, in Section 3, delve into the core principles that define the YOLO approach. The heart of the review traces the detailed evolution of the YOLO family, analyzing the key architectural innovations, training methodologies, and performance improvements introduced in each major version from YOLOv1 to the latest YOLOv12 in Section 4. Finally, we explore the vast landscape of real-world applications where YOLO algorithms are driving tangible impact, demonstrating how this once-novel approach has become an indispensable tool for enabling machines to perceive and interact with the world in real-time in Section 6. A concluding remark, including our goal is provided in Section 7 for both a technical and contextual understanding of how YOLO has evolved into a benchmark framework that encapsulates the aspirations of real-time computer vision systems.

2. Object Detection Fundamentals

The evolution of object detection in the last two decades is widely conceptualized in the academic literature as a bifurcated paradigm shift, denoted by the advent of deep learning methodologies Figure 1. This progression is broadly categorized into two epochs: the traditional era (pre$-2014$), characterized by handcrafted feature engineering and heuristic-driven methods, and the deep learning revolution (post$-2014$), marked by data-driven, end-to-end learning frameworks that redefined performance benchmarks and scalability [14].

During the traditional era, foundational approaches relied on manually engineered features such as Haar-like cascades [15], Histogram of Oriented Gradients [16], and Scale-Invariant Feature Transform [17], combined with sliding-window detection pipelines. These methods, though theoretically interpretable, were constrained by their computational inefficiency, limited scale, and occlusion robustness, and dependence on domain-specific expertise for feature design. Detection frameworks like Deformable Part Models [18] exemplified iterative refinements within this paradigm but struggled to generalize across diverse real-world scenarios.

The deep learning revolution, catalyzed by breakthroughs in convolutional neural networks [19], precipitated a tectonic shift. Architectures such as Region-based CNNs [20], Faster R-CNN [21], and Single Shot MultiBox Detectors [22] introduced end-to-end trainable systems that autonomously learned hierarchical feature representations. The introduction of You Only Look Once (YOLO) [7] further democratized real-time detection by unifying localization and classification into a singular regression task. These models achieved unprecedented gains in accuracy, speed, and adaptability, driven by scalable optimization on large annotated datasets (e.g., ImageNet, COCO) and hardware acceleration (e.g., GPUs). Critically, this era redefined the role of human intervention, transitioning from feature engineering to architectural innovation and loss function design.

Academic discourse attributes this paradigm shift to the confluence of algorithmic advancements, data availability, and computational infrastructure. The post-2014 landscape has since been shaped by iterative refinements in attention mechanisms, transformer-based architectures [23], and self-supervised learning, further solidifying deep learning’s dominance in both theoretical and applied contexts. This transition underscores a broader trend in computer vision: the ascendancy of data-centric, learnable systems over heuristic-driven methodologies.

2.1. Traditional Object Detection Models

The development of real-time object detection frameworks underwent significant advancements in the early 2000s. Viola and Jones (2001) pioneered a breakthrough in real-time face detection by introducing a cascaded classifier architecture that eliminated reliance on restrictive heuristics such as skin-color segmentation. Their algorithm, optimized for a 700 MHz Pentium III processor, demonstrated computational efficiency surpassing contemporary methods by orders of magnitude while maintaining competitive accuracy. This innovation marked a paradigm shift in real-time detection, balancing computational tractability with robust performance despite the hardware constraints of the era [15].

Subsequent work by Dalal and Triggs (2005) introduced the Histogram of Oriented Gradients (HOG) descriptor, which employed overlapping contrast normalization and a dense grid of cells to achieve invariance to geometric transformations (e.g., translation, scaling). HOG’s focus on pedestrian detection popularized multi-scale detection pipelines, where images were resampled while maintaining fixed window sizes to localize objects across varying scales. This approach became a cornerstone of traditional detection frameworks due to its robustness and reproducibility [16].

Further advancements emerged with Deformable Part Models (DPM), a hierarchical, sliding-window framework proposed by Felzenszwalb et al. (2010). DPM decomposed detection into modular stages: (1) extraction of fixed feature representations (e.g., HOG), (2) classification of candidate regions using latent SVM, and (3) refinement of bounding boxes through spatial constraints on part-based components. While DPM achieved state-of-the-art performance on benchmarks such as PASCAL VOC, its reliance on handcrafted features and multi-stage optimization limited scalability [18].

2.2. Deep Learning Revolutions

Following the stagnation of handcrafted feature-based methods after 2010 (Zou et al., 2023) [14], the advent of convolutional neural networks (CNNs) (Krizhevsky et al., 2012) [19] catalyzed a paradigm shift in object detection. This era bifurcated detectors into two-stage and one-stage architectures, each addressing distinct trade-offs between accuracy and computational efficiency.

2.2.1. Two-Stage Architectures

Two-stage frameworks, exemplified by R-CNN [20], Fast R-CNN [6], Faster R-CNN [21], and Feature Pyramid Networks (FPN) [24], decompose detection into sequential stages: (1) generating region proposals and (2) refining classification and localization.

• R-CNN (Girshick et al., 2014) pioneered the use of region proposals [20] (via Selective Search; Uijlings et al., 2013) [25] and CNN-based feature extraction. However, its multi-stage pipeline—combining CNNs, SVMs, and bounding-box regression—suffered from inefficiency ($40$s/image) and calibration complexity.
• Fast R-CNN (Girshick, 2015) streamlined computation by introducing RoI pooling, enabling shared feature extraction and reducing inference time by $9x$ [6].
• Faster R-CNN (Ren et al., 2015) unified proposal generation and refinement via a Region Proposal Network (RPN), achieving near real-time performance (17 FPS) while maintaining high accuracy ($73.2$% mAP on PASCAL VOC) [21].
• FPN (Lin et al., 2017) enhanced multi-scale detection through a top-down architecture with lateral connections, boosting Faster R-CNN’s COCO mAP to $59.1$% by leveraging hierarchical feature fusion [24].

While two-stage detectors excel in accuracy, particularly for small objects, their sequential pipelines incur computational latency and limit real-time applicability [21]. Hence, the necessity of an alternative architecture, such as One-stage, arises to overcome the limitations from the perspective of practical applications.

2.2.2. One-Stage Architectures

One-stage detectors, such as SSD [22] and YOLO [7], prioritize speed by unifying localization and classification into a single forward pass.

• SSD (Liu et al., 2016) introduced multi-scale feature map predictions, enabling efficient detection across object sizes without region proposals [22].
• YOLO (Redmon et al., 2016) redefined real-time detection by processing entire images in a single pass, achieving 45 FPS with $63.4$% mAP [7]. Its grid-based design traded marginal accuracy for unprecedented speed, outperforming traditional methods like DPM (Sadeghi et al., 2014), which achieved only $26.1$% mAP at 30 FPS [26].

YOLO’s efficiency (e.g., Fast YOLO: 155 FPS, $52.7$% mAP) made it ideal for latency-sensitive applications like autonomous driving, though its accuracy lagged behind two-stage counterparts [14].

3. The YOLO Algorithm: An Overview

Convolutional Neural Networks (CNNs), a class of deep learning models optimized for grid-structured data [27], revolutionized computer vision through hierarchical feature extraction. By preserving spatial relationships via convolutional operations, CNNs autonomously learn low-to-high-level features, enabling breakthroughs in tasks like object detection [28]. Among CNN-based detectors, You Only Look Once (YOLO) [7] redefined real-time performance by framing detection as a unified regression problem.

A CNN processes input tensors (e.g., $\mathbf{X}\in {\mathbb{R}}^{H\times W\times C}$) through convolutional layers that apply learnable filters $\mathbf{K}$ via:

$$\mathbf{Y}(i,j)=\sum _{m=0}^{k_h-1}\sum _{n=0}^{k_w-1}\mathbf{X}(i+m,j+n)·\mathbf{K}(m,n)$$

(1)

where $k_h\times k_w$ defines the kernel size. Non-linear activations (e.g., ReLU [29]), pooling layers, and fully connected (FC) layers follow, culminating in task-specific outputs [30].

Neural networks minimize loss functions (e.g., cross-entropy $\mathcal{L}=-{\sum }_{i=1}^N{y}_{i}log\left({\widehat{y}}_i\right)$) via backpropagation [31]. Regularization techniques like dropout [32] mitigate overfitting by randomly deactivating neurons during training.

YOLO [7] partitions input images into $S\times S$ grids, where each cell predicts B bounding boxes with confidence scores $\mathrm{Pr}\left(\mathrm{Object}\right)\times {\mathrm{IOU}}_{\mathrm{pred}}^{\mathrm{truth}}$ and C class probabilities. The final output tensor $\mathbf{T}\in {\mathbb{R}}^{S\times S\times (5B+C)}$ combines localization and classification:

$$\mathrm{Class}-\mathrm{Specific}\mathrm{Confidence}=\mathrm{Pr}\left({\mathrm{Class}}_i\right|\mathrm{Object})\times {\mathrm{IOU}}_{\mathrm{pred}}^{\mathrm{truth}}$$

(2)

where IOU refers to Intersection Over Union.

Figure 2. YOLO’s grid-based detection workflow. Each cell predicts bounding boxes and class probabilities conditioned on object presence.

Figure 2. YOLO’s grid-based detection workflow. Each cell predicts bounding boxes and class probabilities conditioned on object presence.

On PASCAL VOC [33], YOLOv1 achieved $63.4$% mAP at 45 FPS, outperforming DPM ($26.1$% mAP at 30 FPS) while leveraging global context to halve background errors compared to region-based methods like Fast R-CNN. Its compact architecture (24 convolutional + 2 FC layers) enables real-time inference on GPUs, critical for autonomous systems [7].

YOLO’s regression-based approach eliminates multi-stage pipelines, achieving 150 FPS on optimized variants. However, its spatial grid constraints limit accuracy for small objects and dense scenes. Subsequent iterations (e.g., YOLOv2–YOLOv8) address these via anchor boxes and multi-scale predictions [14].

4. Evolution of YOLO: From YOLOv1 to YOLOv12

4.1. YOLOv1 (2015)

YOLOv1, a unified framework for real-time object detection,[7], introduced in 2016, revolutionized object detection by reformulating it as a unified regression task, eliminating the computational bottlenecks of multi-stage pipelines like R-CNN [20]. By processing the entire image in a single forward pass, YOLOv1 achieved real-time inference speeds while leveraging global contextual information, significantly reducing background false positives compared to region-based methods. Its regression-based design also enhanced generalizability, enabling robust performance across diverse domains.

According to the architecture and methodology,

• Grid-Based Detection: YOLOv1 partitions input images into an $S\times S$ grid ($S=7$ for PASCAL VOC [33]), where each cell predicts B bounding boxes (coordinates $x,y,w,h$) and confidence scores $\mathrm{Pr}\left(\mathrm{Object}\right)\times {\mathrm{IOU}}_{\mathrm{pred}}^{\mathrm{truth}}$. Class probabilities $\mathrm{Pr}\left({\mathrm{Class}}_i\right|\mathrm{Object})$ are conditioned on object presence, yielding a final output tensor $\mathbf{T}\in {\mathbb{R}}^{7\times 7\times 30}$ for 20-class VOC detection.

  $$\mathrm{Confidence}\mathrm{Score}=\underset{\mathrm{Objectness}}{\underbrace{\mathrm{Pr}\left(\mathrm{Object}\right)}}\times \underset{\mathrm{Localization}\mathrm{Accuracy}}{\underbrace{{\mathrm{IOU}}_{\mathrm{pred}}^{\mathrm{truth}}}}$$

  (3)
• Network Design: The architecture comprises 24 convolutional layers for hierarchical feature extraction, followed by 2 fully connected layers for regression (Figure 3). Inspired by GoogLeNet, it employs $1\times 1$ reduction layers to minimize computational overhead.

Limitations and trade-offs are, despite its speed (45 FPS on a Titan × GPU), YOLOv1 exhibited three key limitations:

• Spatial Coarseness: The $7\times 7$ grid struggled with small objects and dense scenes due to limited spatial resolution.
• Localization Errors: The squared error loss equally penalizes misalignments in large/small boxes, impairing precise localization.
• Scale Sensitivity: Fixed grid cells hindered the detection of objects with extreme aspect ratios.

According to the Fast YOLO: Optimized for Speed, to further accelerate inference, Fast YOLO [7] reduced the original network to 9 convolutional layers, achieving 155 FPS with marginal accuracy loss ($52.7$% mAP vs. $63.4$% for YOLOv1 on PASCAL VOC). This trade-off prioritized latency-critical applications like video surveillance.

4.2. YOLOv2 (2016)

YOLOv2, an incremental improvements for scalable real-time detection, [34] systematically addressed limitations of YOLOv1 through four key innovations while maintaining real-time efficiency:

According to the batch normalization and high-resolution fine-tuning, layer-wise batch normalization [35] stabilized training by reducing internal covariate shift:

$${\widehat{x}}^{\left(k\right)}={\displaystyle \frac{x^{\left(k\right)}-E\left[x^{\left(k\right)}\right]}{\sqrt{\mathrm{Var}\left[x^{\left(k\right)}\right]+ϵ}}}·{\gamma }^{\left(k\right)}+{\beta }^{\left(k\right)}$$

(4)

This eliminated dropout while improving mean Average Precision (mAP) by $2.4\%$ on PASCAL VOC [33]. Subsequent fine-tuning at $448\times 448$ resolution boosted mAP by $3.7\%$ through enhanced spatial reasoning.

According to anchor boxes and feature fusion, YOLOv2 replaced fully connected layers with anchor boxes [21], predicting $1,845$ boxes per image versus YOLOv1’s 98. A passthrough layer fused fine-grained features $(26\times 26)$ with semantic abstractions $(13\times 13)$:

$${\mathbf{F}}_{\mathrm{fused}}=\mathrm{Concat}({\mathbf{F}}_{26\times 26},\mathrm{Downsample}\left({\mathbf{F}}_{13\times 13}\right))$$

(5)

This increased recall from 81% to 88% while maintaining 67 FPS.

According to the multi-scale training, dynamic input scaling (320–608px) every 10 batches enhanced robustness. At $416\times 416$ resolution, YOLOv2 achieved $76.8$% mAP on VOC 2007 while processing images at 67 FPS [34].

Figure 4. YOLOv2 architecture (Normal).

Figure 4. YOLOv2 architecture (Normal).

4.2.1. Faster YOLOv2: Darknet 19

The Darknet$-19$ backbone, efficient backbones for multi-scale learning, [34] reduced computational complexity to $5.58$ billion FLOPS compared to GoogLeNet’s $8.52$ billion [36] through:

$${\mathcal{C}}_{\mathrm{Darknet}}=\sum _{l=1}^{19}(k_l^2·c_l^{\mathrm{in}}·c_l^{\mathrm{out}})+\sum _{p=1}^5{\mathcal{O}}_{\mathrm{pool}}$$

(6)

where $k_l$ = kernel size, $c_l^{\mathrm{in}/\mathrm{out}}$ = input/output channels, and ${\mathcal{O}}_{\mathrm{pool}}$ = max-pooling overhead. Global average pooling replaced FC layers, reducing parameters by 92% versus VGG-16 [37].

According to the multi-phase training,

• Classification Pretraining: $224\times 224$ ImageNet [38] initialization (1000 classes)
• Resolution Fine-Tuning: $448\times 448$ adaptation (10 epochs)
• Detection Finetuning: Anchor box adaptation with added conv layers (Figure 5)

According to the YOLO9000: Hierarchical multi-task learning,

• WordTree Taxonomy: YOLO9000 [34] combines detection (COCO [39]) and classification (ImageNet) datasets via WordTree, a hierarchical softmax:

  $$P\left({\mathrm{Class}}_i\right)=\prod _{n\in \mathrm{Path}\left(i\right)}P\left(n\right|\mathrm{parent}\left(n\right))$$

  (7)

  where $\mathrm{Path}\left(i\right)$ denotes the taxonomy path from root to class i.
• Joint Optimization: The multi-task loss combines detection (${\mathcal{L}}_{\det }$) and classification (${\mathcal{L}}_{\mathrm{cls}}$) objectives:

  $$\mathcal{L}={\lambda }_{\mathrm{coord}}\sum {\mathcal{L}}_{\mathrm{bbox}}+{\lambda }_{\mathrm{obj}}{\mathcal{L}}_{\mathrm{conf}}+{\lambda }_{\mathrm{cls}}{\mathcal{L}}_{\mathrm{cls}}$$

  (8)
  Enabling detection across $9,000$ categories with $19.7$ mAP on ImageNet detection.

4.3. YOLOv3 (2018)

YOLOv3, an evolutionary leap in multi-scale real-time detection,[40] introduced Darknet$-53$, a 53-layer network leveraging residual connections [41] and strided convolutions, achieving $1.5$× higher FPS than ResNet$-152$[41] with comparable accuracy. Batch normalization [35] and Leaky ReLU activations ($\alpha =0.1$) stabilize training:

$$\mathrm{LeakyReLU}\left(x\right)=\left\{\begin{array}{cc}x,\hfill & \mathrm{if}x>0\hfill \\ 0.1x,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(9)

According to the multi-scale detection, YOLOv3 employs three detection heads (52×52, 26×26, 13×13) with anchor boxes clustered via k-means ($k=9$) [40]:

$$\mathrm{Distance}(w,h)=1-\mathrm{IOU}((w_p,h_p),(w_t,h_t))$$

(10)

Each head predicts 3 anchors, enabling detection across 9 scale/aspect ratio combinations (Figure 6).

Performance and limitations are on MS COCO [39], YOLOv3 achieved $36.2\%$ AP and $60.6\%$ ${\mathrm{AP}}_{50}$ at 20 FPS, outperforming SSD [22] by 3× in speed with comparable accuracy. However, RetinaNet [42] retained higher precision ($39.1\%$ AP) at lower speeds (5 FPS). The multi-scale design improved small-object recall by $18\%$ versus YOLOv2 [34], though medium/large object localization errors persisted.

Variants and adaptations are

• Enhanced Precision Variant: Triki et al. [43] modified YOLOv3’s spatial pyramid pooling (SPP) [44] layer, increasing DHS dataset mAP by $4.2\%$ through feature map upsampling:

  $${\mathbf{F}}_{\mathrm{upscaled}}=\mathrm{Deconv}({\mathbf{F}}_{\mathrm{low}-\mathrm{res}},k=3,s=2)$$

  (11)
• YOLOv3-Tiny: Adarsh et al. [45] pruned Darknet$-53$ to 23 layers, achieving 140 FPS on embedded devices with $28.7\%$ COCO AP:

  $${\mathcal{L}}_{\mathrm{Tiny}}={\lambda }_{\mathrm{coord}}\sum \mathrm{MSE}+{\lambda }_{\mathrm{obj}}{\mathcal{L}}_{\mathrm{BCE}}$$

  (12)

4.4. YOLOv4 (2020)

YOLOv4, the optimal speed-accuracy tradeoff for production-grade detectors,[46] introduces CSPDarknet53 with cross-stage partial (CSP) connections [47]:

$${\mathbf{F}}_{\mathrm{out}}=\mathcal{H}\left({\mathbf{F}}_{\mathrm{in}}\right)\oplus {\mathbf{F}}_{\mathrm{in}}$$

(13)

where $\mathcal{H}$ represents dense block operations and ⊕ denotes channel-wise concatenation. This reduces computation by 20% while maintaining $27.6$M parameters.

According to neck and head enhancements, the neck combines spatial pyramid pooling (SPP) [44] with path aggregation network (PANet) [48]:

$${\mathbf{F}}_{\mathrm{pan}}=\mathrm{Upsample}\left({\mathbf{F}}_{\mathrm{top}}\right)\otimes \mathrm{Conv}\left({\mathbf{F}}_{\mathrm{bot}}\right)$$

(14)

The head employs complete-IoU loss [49]:

$${\mathcal{L}}_{\mathrm{CIoU}}=1-\mathrm{IoU}+{\displaystyle \frac{{\rho }^2(b,b^{gt})}{c^2}}+\alpha v$$

(15)

where $\rho$ is center distance, c diagonal length, and v aspect ratio consistency term.

Figure 7. YOLOv4 architecture with CSPDarknet53 backbone, SPP-PANet neck, and CIoU-optimized head.

Figure 7. YOLOv4 architecture with CSPDarknet53 backbone, SPP-PANet neck, and CIoU-optimized head.

According to the training methodology, it follows the following two types of training:

• Bag of Freebies (BoF)
  • Mosaic augmentation [46]: $4-$image mosaic with random scaling
  • DropBlock [50]: Structured channel dropout
  • CIoU-aware label smoothing [49]
• Bag of Specials (BoS)
  • Mish activation [51]: $f\left(x\right)=x·tanh(ln(1+e^x))$
  • Modified SAM [46]: Spatial attention module
  • DIoU-NMS [49]: Distance-aware suppression

According to performance analysis, on MS COCO [39], the achievement of YOLOv4 is shown in Table 1.

The YOLOv4 achieves $10\%$ AP improvement over YOLOv3 with $12\%$ faster inference [46].

According to YOLOv4-Tiny for edge deployment, the tiny variant [52] employs:

• CSPDarknet53-Tiny: 12 CSP layers with LeakyReLU
• Simplified PANet: Single-scale feature fusion
• Anchor pruning: 3 anchors per scale vs. 9 in full version

and achieves 270 FPS on Jetson Xavier with $38.1$ mAP.

4.4.1. Scaled YOLOv4 (2021)

Scaled YOLOv4, a compound scaling for optimal object detection, [53] introduces a principled scaling approach optimizing depth (d), width (w), resolution (r), and structure through:

$$\underset{d,w,r}{max}\mathcal{P}(d,w,r)\mathrm{s}.\mathrm{t}.\mathcal{C}(d,w,r)\le {\mathcal{C}}_{\max }$$

(16)

where $\mathcal{P}$ denotes performance metric (AP) and $\mathcal{C}$ computational complexity. This compound scaling outperforms EfficientDet’s [54] neural architecture search (NAS) through:

• Depth scaling via CSPDarknet blocks [47]
• Width scaling through channel expansion factors ($\varphi \in \{0.5,1.0,1.5\}$)
• Resolution scaling ($384-1536$px) with aspect ratio preservation

The following architectural innovations are explored as per the literature:

• CSP-PAN with Mish Activation: The neck combines cross-stage partial connections with Mish activation [51]:

  $${\mathbf{F}}_{\mathrm{csp}-\mathrm{pan}}=\mathcal{M}\left(\mathrm{Concat}({\mathbf{F}}_{\mathrm{up}},\mathrm{CSP}\left({\mathbf{F}}_{\mathrm{low}}\right)\right)$$

  (17)

  where $\mathcal{M}\left(x\right)=x·tanh(ln(1+e^x))$ enhances gradient flow.
• Unified Multi-Resolution Training: Contrary to single-scale paradigms, Scaled YOLOv4 employs resolution-agnostic weights:

  $${\mathcal{L}}_{\mathrm{total}}=\sum _{s\in \mathcal{S}}{\lambda }_s{\mathcal{L}}_{\mathrm{CIoU}}^{\left(s\right)}+\gamma {\mathcal{L}}_{\mathrm{DFL}}$$

  (18)

  where $\mathcal{S}$ = 384, 512, 768, 1024 and DFL = dynamic focal loss.

As per the performance analysis, benchmark comparisons are as shown in Table 2:

As per efficiency gains,

• $3.2$× faster training convergence vs YOLOv4
• $12\%$ higher AP/layer than EfficientDet at comparable FPS
• $4.9$× FPS improvement for tiny variant with TensorRT

4.4.2. PP-YOLO (2020)

PP-YOLO, a pragmatic enhancement of YOLOv3 for industrial applications, [55] refines YOLOv3 through systematic integration of production-oriented enhancements while maintaining real-time efficiency:

According to backbone modifications,

• ResNet50-vd-dc backbone with deformable convolutions [56] in final stage:

  $${\mathbf{F}}_{\mathrm{def}}=\sum _{k=1}^K{w}_k·\mathbf{F}(p_0+p_k+\Delta p_k)$$

  (19)

  where $\Delta p_k$ are learned offset vectors.
• Depth-wise separable convolutions for reduced computation

According to detection head enhancements,

• IoU-aware loss branch [57]:

  $${\mathcal{L}}_{\mathrm{IoU}}=-log\left(\mathrm{IoU}(b_{pred},b_{gt})\right)$$

  (20)
• CoordConv [58] spatial encoding:

  $${\mathbf{F}}_{\mathrm{coord}}=\mathrm{Concat}(\mathbf{F},{\mathbf{X}}_{\mathrm{mesh}},{\mathbf{Y}}_{\mathrm{mesh}})$$

  (21)
• Matrix NMS [57] for parallel suppression:

  $$s_i^{\prime }=s_i\prod _{j:s_j>s_i}(1-\mathrm{IoU}(b_i,b_j))$$

  (22)

According to training methodology, built on PaddlePaddle framework [59], PP-YOLO employs:

• $8-$GPU synchronous training with $24-$img/GPU batches
• AutoAugment [60] policy optimization
• Model distillation from Cascade R-CNN [61]
• EMA weight averaging with $\beta =0.9999$

As per performance analysis, on MS COCO [39] test-dev shown in Table 3:

Here the key advantages are

• $5.5\%$ higher AP than YOLOv4 with $17.7\%$ faster inference
• $2.9$× FPS advantage over RetinaNet$-101$
• $44.3$ M parameters vs YOLOv4’s $63.5$ M

4.5. YOLOv5 (2020)

YOLOv5, a PyTorch-based Paradigm for accessible real-time detection [62], transitions from Darknet to PyTorch, enabling:

• CSPDarknet53 backbone with SiLU activation [63]:

  $$\mathrm{SiLU}\left(x\right)=x·\sigma \left(x\right),\sigma \left(x\right)={\displaystyle \frac{1}{1+e^{-x}}}$$

  (23)
• SPPF layer with parallel max-pooling:

  $${\mathbf{F}}_{\mathrm{sppf}}=\mathrm{Concat}({\mathrm{MaxPool}}_5\left(\mathbf{F}\right),{\mathrm{MaxPool}}_9\left(\mathbf{F}\right),{\mathrm{MaxPool}}_{13}\left(\mathbf{F}\right))$$

  (24)
• Scalable variants (n,s,m,l,x) via compound scaling [64]

As per the optimized detection head,

• AutoAnchor genetic optimization [62]:

  $$\mathrm{Fitness}=0.9\times \mathrm{AP}+0.1\times \mathrm{CIoU}$$

  (25)
• CSP-PANet neck with reduced cross-layer connections
• Grid sensitivity stabilization via bounded predictions

Figure 8. YOLOv5 architecture featuring modified CSPDarknet53 backbone, SPPF layer, and AutoAnchor-optimized detection head.

Figure 8. YOLOv5 architecture featuring modified CSPDarknet53 backbone, SPPF layer, and AutoAnchor-optimized detection head.

According to the training methodology for the data augmentation pipeline,

• Mosaic augmentation: $4-$image composition with random scaling
• MixUp [65] interpolation:

  $${\mathbf{x}}_{\mathrm{mix}}=\lambda {\mathbf{x}}_a+(1-\lambda ){\mathbf{x}}_b$$

  (26)
• Copy-Paste [66] instance transplantation
• HSV color jittering ($\pm 15\%$ saturation/value)

As per the optimization strategy,

• Hyperparameter evolution with $300-$generation search
• EMA weight averaging ($\beta =0.999$)
• Multi-scale training ($480-736$px) with $10\%$ probability

According to the performance analysis, MS COCO Benchmarks as below

Table 4. Performance comparison at 640px resolution (batch=32).

Model	AP	AP50	FPS (V100)
YOLOv5n	28.4	46.7	1426
YOLOv5s	37.4	56.8	869
YOLOv5m	45.4	64.1	365
YOLOv5l	49.0	67.3	204
YOLOv5x	50.7	68.9	140
YOLOv4 [46]	43.5	65.7	62
EfficientDet-D2 [54]	43.0	62.3	56

Table 4. Performance comparison at 640px resolution (batch=32).

Model	AP	AP50	FPS (V100)
YOLOv5n	28.4	46.7	1426
YOLOv5s	37.4	56.8	869
YOLOv5m	45.4	64.1	365
YOLOv5l	49.0	67.3	204
YOLOv5x	50.7	68.9	140
YOLOv4 [46]	43.5	65.7	62
EfficientDet-D2 [54]	43.0	62.3	56

According to the deployment flexibility,

• $58\%$ reduction in ONNX [67] model size vs YOLOv4
• TensorRT acceleration achieving $2.1$ms latency on Jetson Xavier
• CoreML [68] conversion for Apple Silicon

The limitations and considerations are

• Initial absence of peer-reviewed publication [69]
• $47\%$ accuracy drop from YOLOv$5\times$ to YOLOv$5n$
• $83\%$ FPS variance across hardware platforms

4.5.1. PP-YOLOE (2022)

PP-YOLOE, an enhanced anchor-free detection via task-aligned learning, [70] introduces RepResBlocks combining residual and dense connections from TreeNet [71]:

$${\mathbf{F}}_{\mathrm{out}}=\mathcal{C}\left({\mathbf{F}}_{\mathrm{in}}\right)+\sum _{i=1}^n{\mathcal{R}}_i\left({\mathbf{F}}_{\mathrm{in}}\right)$$

(27)

where $\mathcal{C}$ denotes compressed residual path and ${\mathcal{R}}_i$ parallel residual branches.

According to the task-aligned learning, the ET-head employs task-alignment learning [72] with dynamic label assignment:

$$t=\mathrm{sigmoid}({\mathcal{S}}_{\mathrm{cls}}·{\mathcal{S}}_{\mathrm{reg}}^{\gamma })$$

(28)

where ${\mathcal{S}}_{\mathrm{cls}/\mathrm{reg}}$ are classification/regression scores and $\gamma$ balance factor.

The loss formulation combines Varifocal Loss [73] and Distribution Focal Loss [74]:

$$\mathcal{L}={\lambda }_{\mathrm{vfl}}{\mathcal{L}}_{\mathrm{vfl}}+{\lambda }_{\mathrm{dfl}}{\mathcal{L}}_{\mathrm{dfl}}+{\lambda }_{\mathrm{diou}}{\mathcal{L}}_{\mathrm{diou}}$$

(29)

$${\mathcal{L}}_{\mathrm{vfl}}=-{|y-\sigma \left(p\right)|}^{\beta }·ylog\left(p\right)$$

(30)

The scalable architecture design as follows in Table 5:

According to the performance analysis, based-on MS COCO [39] test-dev in Table 6:

The key advantages are

• $12.3$% faster than YOLOX-X with equivalent accuracy
• $3.9$% AP improvement over PP-YOLOv2
• 45% reduction in training iterations vs anchor-based variants

4.5.2. YOLO-NAS (2023)

YOLO-NAS, a hardware-aware neural architecture search for quantization-robust object detection, [77] employs Deci’s Automated Neural Architecture Construction (AutoNAC) [78] to optimize the Pareto frontier between accuracy and latency:

$${\mathcal{A}}^{*}=\underset{\mathcal{A}}{\mathrm{argmax}}\left[\mathrm{AP}\left(\mathcal{A}\right)-\lambda ·\mathrm{Latency}(\mathcal{A},\mathcal{H})\right]$$

(31)

where $\mathcal{H}$ denotes target hardware constraints and $\lambda$ tradeoff coefficient.

According ot the quantization-Aware Building Blocks,

• Quantization-Scale Propagation (QSP) blocks [79]:

  $${\mathbf{F}}_{\mathrm{out}}=\alpha ·\mathrm{Conv}\left({\mathbf{F}}_{\mathrm{in}}\right)+\beta$$

  (32)
• Quantization-Centric Initialization (QCI) [79]
• RepVGG [80] structural re-parameterization:

  $${\mathbf{W}}_{\mathrm{merged}}={\mathbf{W}}^{(3\times 3)}+\sum _{i=1}^n{\mathbf{W}}_i^{(1\times 1)}$$

  (33)

As per the training methodology for the multi-stage learning,

• Phase 1: Objects365 [81] pretraining ($1.7$M images)
• Phase 2: COCO [39] fine-tuning with hybrid quantization:

  $${\mathcal{L}}_{\mathrm{QAT}}={\mathcal{L}}_{\det }+\gamma {\parallel {\mathbf{W}}_{FP32}-Q^{-1}\left(Q\left({\mathbf{W}}_{INT8}\right)\right)\parallel }_2$$

  (34)
• Phase 3: Per-tensor AdaRound [82] optimization

According to the performance analysis in the quantization robustness shown in Table 7,

Its comparative benchmarking is as below in Table 8:

4.6. YOLOv6 (2022)

YOLOv6, a hardware-oriented architecture design for efficient object detection, [84] employs RepBlocks during training with structural re-parameterization for inference:

$${\mathbf{W}}_{\mathrm{rep}}={\mathbf{W}}^{(3\times 3)}+{\mathbf{W}}^{(1\times 1)}+{\mathbf{W}}^{\left(\mathrm{identity}\right)}$$

(35)

Large models use CSPStackRep blocks [85] combining cross-stage partial connections:

$${\mathbf{F}}_{\mathrm{out}}=\mathrm{Concat}({\mathbf{F}}_{\mathrm{res}},\mathrm{CSP}\left({\mathbf{F}}_{\mathrm{in}}\right))$$

(36)

According to the decoupled head optimization, the hybrid-channel head reduces parameters through depth pruning:

$${\mathcal{P}}_{\mathrm{head}}={\displaystyle \frac{3}{4}}{C}_{\mathrm{in}}\times (K_{\mathrm{cls}}+K_{\mathrm{reg}})$$

(37)

where $K_{\mathrm{cls}/\mathrm{reg}}$ are classification/regression kernels.

Figure 9. YOLOv6 architecture with EfficientRep backbone and decoupled head design.

Figure 9. YOLOv6 architecture with EfficientRep backbone and decoupled head design.

According to the training methodology for the Loss Formulation combines Task-aligned learning [72] with SIoU [86]:

$$\mathcal{L}={\lambda }_{\mathrm{vfl}}{\mathcal{L}}_{\mathrm{vfl}}+{\lambda }_{\mathrm{siou}}{\mathcal{L}}_{\mathrm{siou}}+{\lambda }_{\mathrm{df}}{\mathcal{L}}_{\mathrm{df}}$$

(38)

where ${\mathcal{L}}_{\mathrm{siou}}=1-\mathrm{IoU}+{\displaystyle \frac{{\Delta }_{\mathrm{angle}}}{\pi }}+{\displaystyle \frac{{\Delta }_{\mathrm{shape}}}{{\sigma }^2}}$.

The quantization strategy is as below:

• RepOptimizer [87]: Gradient reparameterization
• Channel-wise distillation [88]:

  $${\mathcal{L}}_{\mathrm{KD}}={\parallel {\mathbf{F}}_{\mathrm{tea}}-{\mathbf{F}}_{\mathrm{stu}}\parallel }_2^2$$

  (39)

According to the performance analysis shown in Table 9,

The limitations are:

• $22\%$ latency variance across GPU architectures
• $1:2.3$ AP:FPS ratio degradation from N to L6 variants
• Requires per-hardware fine-tuning for optimal quantization

4.7. YOLOv7 (2022)

YOLOv7, an extended-ELAN architecture with compound scaling for state-of-the-art object detection [89] extends ELAN through controlled cardinality expansion:

$${\mathbf{F}}_{\mathrm{out}}=\mathcal{G}\left(\underset{k=1}{\overset{K}{⨁}}{\mathcal{T}}_k\left({\mathbf{F}}_{\mathrm{in}}\right)\right)$$

(40)

where ${\mathcal{T}}_k$ are parallel computation branches and $\mathcal{G}$ gradient-preserving aggregation.

According to the compound scaling strategy, balanced width/depth scaling maintains channel equilibrium:

$$(d^{\prime },w^{\prime })=\left(\alpha d,\beta w\right)\mathrm{s}.\mathrm{t}.{\displaystyle \frac{w^{\prime }}{d^{\prime }}}={\displaystyle \frac{w}{d}}$$

(41)

According to the trainable bag-of-freebies,

• RepConvN: Pruned re-parameterization [80]
• Coarse-to-fine label assignment:

  $$p_{\mathrm{assign}}=\sigma (\mathrm{IoU}·\mathrm{Confidence}·{\mathcal{W}}_{\mathrm{head}})$$

  (42)
• Implicit knowledge integration from YOLOR [90]

Figure 10. YOLOv7 architecture featuring E-ELAN backbone and compound-scaled detection heads.

Figure 10. YOLOv7 architecture featuring E-ELAN backbone and compound-scaled detection heads.

As per the performance analysis on MS COCO benchmarks in Table 10,

The following efficiency gains are observed

• 36% fewer FLOPS vs YOLOv4 at $1.5$% higher AP
• 43% parameter reduction vs YOLOR with $0.4\%$ AP gain
• 15% computation reduction in tiny variant

The limitations and considerations of this version are

• $2.3$× longer training time vs YOLOv5
• 18% AP variance across GPU architectures
• $1:1.8$ AP:FPS ratio degradation for X variant
• Requires $5.7$× more tuning for INT8 quantization

4.8. YOLOv8 (2023)

YOLOv8, a unified architecture for multi-task visual perception, [83] enhances CSPDarknet$-53$ through Contextual Cross-Fusion (C2f) blocks:

$${\mathbf{F}}_{\mathrm{out}}=\mathrm{Conv}\left(\mathrm{Concat}({\mathbf{F}}_{\mathrm{skip}},\underset{i=1}{\overset{n}{⨁}}{\mathcal{B}}_i\left({\mathbf{F}}_{\mathrm{in}}\right))\right)$$

(43)

where ${\mathcal{B}}_i$ are bottleneck blocks with residual connections.

According to the decoupled anchor-free head,

• Task-specific branches for classification/regression:

  $${\mathcal{H}}_{\mathrm{decoupled}}=\{{\mathcal{H}}_{\mathrm{obj}},{\mathcal{H}}_{\mathrm{cls}},{\mathcal{H}}_{\mathrm{reg}}\}$$

  (44)
• Distribution Focal Loss [74]:

  $${\mathcal{L}}_{\mathrm{DFL}}=-\sum _{i=1}^N{y}_{i}log\left(p_i\right)+(1-y_i)log(1-p_i)$$

  (45)

From the multi-task extensions, YOLOv8-seg introduces dual segmentation heads:

$${\mathbf{M}}_{\mathrm{seg}}={\mathcal{H}}_{\mathrm{mask}}\left(\mathrm{Concat}({\mathbf{F}}_{\mathrm{high}},{\mathbf{F}}_{\mathrm{low}})\right)$$

(46)

According to the performance analysis, the MS COCO benchmarks are as follows

Table 11. Object detection performance on COCO val2017 [39].

Model	AP	AP50	FPS (A100)
YOLOv8n	37.3	53.2	1230
YOLOv8x	53.9	70.4	280
YOLOv5x [62]	50.7	68.9	140
YOLOv7-X [89]	51.2	69.7	110
EfficientDet-D7 [54]	52.2	70.4	23

Table 11. Object detection performance on COCO val2017 [39].

Model	AP	AP50	FPS (A100)
YOLOv8n	37.3	53.2	1230
YOLOv8x	53.9	70.4	280
YOLOv5x [62]	50.7	68.9	140
YOLOv7-X [89]	51.2	69.7	110
EfficientDet-D7 [54]	52.2	70.4	23

According to the segmentation capabilities,

• $48.7$% mask AP on COCO with YOLOv8x-Seg
• $2.1$× faster inference than Mask R-CNN [91] at comparable accuracy

The limitations and considerations of this version are

• $22\%$ latency variance across GPU architectures
• $1:2.5$ AP:FPS ratio degradation from nano to x variants
• Requires $3.8$× more tuning for INT8 quantization vs YOLOv5
• Sparse documentation for novel C2f modules

Figure 11. YOLOv8 architecture with C2f backbone and decoupled task heads.

Figure 11. YOLOv8 architecture with C2f backbone and decoupled task heads.

4.9. Yolov9 (2024)

YOLOv9, a lightweight object detector via programmable gradient information and generalized efficient layer aggregator,[10] introduces PGI to mitigate information bottlenecks in deep networks:

$${\mathcal{G}}_{\mathrm{PGI}}=\sum _{l=1}^L{\alpha }_l·\nabla {\mathcal{L}}_l\left(\mathbf{W}\right)\oplus \beta ·{\mathcal{M}}_{\mathrm{aux}}$$

(47)

where ${\alpha }_l$ controls gradient contribution from layer l, ${\mathcal{M}}_{\mathrm{aux}}$ is the auxiliary supervision mask, and ⊕ denotes programmable fusion.

Generalized Efficient Layer Aggregation (GELAN) enables dynamic feature fusion across heterogeneous computation blocks are:

$${\mathbf{F}}_{\mathrm{gelan}}=\mathcal{A}\left(\underset{k=1}{\overset{K}{⨂}}{\varphi }_k\left({\mathbf{F}}_{\mathrm{in}}\right);{\theta }_{\mathrm{agg}}\right)$$

(48)

where ${\varphi }_k$ represents diverse computation branches and $\mathcal{A}$ is the adaptive aggregation operator.

The performance analysis based on MS COCO benchmarks are

Table 12. Performance comparison on COCO val2017 [39].

Model	AP	Params (M)	FLOPS (B)
YOLOv9-Nano	39.1	2.1	4.3
YOLOv9-Lite	46.7	5.8	12.1
YOLOv8-Nano [83]	38.5	3.2	8.7
EfficientDet-Lite3 [54]	40.3	4.9	15.6

Table 12. Performance comparison on COCO val2017 [39].

Model	AP	Params (M)	FLOPS (B)
YOLOv9-Nano	39.1	2.1	4.3
YOLOv9-Lite	46.7	5.8	12.1
YOLOv8-Nano [83]	38.5	3.2	8.7
EfficientDet-Lite3 [54]	40.3	4.9	15.6

According to the efficiency gains,

• $0.6$% AP improvement over YOLOv8 with $34\%$ fewer parameters
• $51\%$ reduction in FLOPS vs EfficientDet at comparable accuracy
• $2.8$× faster inference on Jetson Nano vs YOLOv8

The limitations of this network are

• $18\%$ accuracy variance across ARM-based edge devices
• Requires $2.5$× more training iterations than YOLOv8
• Limited support for ultra-high resolution (4K+) inputs
• Early-stage quantization support (INT8 accuracy drop: $2.1\%$)

Figure 12. YOLOv9 architecture with PGI framework and GELAN feature pyramid.

Figure 12. YOLOv9 architecture with PGI framework and GELAN feature pyramid.

4.10. Yolov10 (2024)

YOLOv10, an NMS-free architecture for real-time edge applicator,[11] eliminates post-processing dependency through dual assignment supervision:

$${\mathcal{L}}_{\mathrm{dual}}=\underset{\mathrm{Primary}\mathrm{Head}}{\underbrace{{\lambda }_{\mathrm{main}}{\mathcal{L}}_{\mathrm{cls}+\mathrm{reg}}}}+\underset{\mathrm{Rank}\mathrm{Guidance}}{\underbrace{{\lambda }_{\mathrm{aux}}{\mathcal{L}}_{\mathrm{rank}}}}$$

(49)

where ${\mathcal{L}}_{\mathrm{rank}}$ optimizes prediction confidence ordering without NMS.

Spatial-channel decoupled downsampling shows

$${\mathbf{F}}_{\mathrm{ds}}=\mathrm{DSConv}\left({\mathbf{F}}_{\mathrm{in}}\right)\oplus \mathrm{ChannelSplit}\left({\mathbf{F}}_{\mathrm{in}}\right))$$

(50)

Rank-guided block design is

$${\mathbf{F}}_{\mathrm{out}}=\mathcal{G}\left({\mathbf{W}}_{\mathrm{low}-\mathrm{rank}}{\mathbf{F}}_{\mathrm{in}}\right)\otimes \sigma \left({\mathbf{W}}_{\mathrm{gate}}{\mathbf{F}}_{\mathrm{in}}\right))$$

(51)

where $\mathcal{G}$ denotes grouped convolution and $\sigma$ sigmoid gating.

The performance analysis based on MS COCO benchmarks is provided in Table 13

The technical advancements are

• $34\%$ faster inference than YOLOv9 at comparable accuracy
• $56\%$ parameter reduction vs YOLO$v8$-nano
• $0.9$ms end-to-end latency for 640px inputs
• $4.8$× energy efficiency improvement on edge TPUs

The limitations are

• $18\%$ accuracy variance across ARM architectures
• $25\%$ longer training convergence time
• Limited to 1280px input resolution
• Requires custom TensorRT plugins for deployment

Figure 13. YOLOv10 architecture with NMS-free dual-head design and rank-guided blocks.

Figure 13. YOLOv10 architecture with NMS-free dual-head design and rank-guided blocks.

4.11. Yolov11 (2024)

YOLOv11, a unified architecture for multi-task vision with enhanced spatial attention,[92] introduces compressed C3k2 blocks replacing C2f modules:

$${\mathbf{F}}_{\mathrm{c}3\mathrm{k}2}={\mathrm{Conv}}_{1\times 1}\left(\mathrm{Concat}(\mathrm{DWConv}\left({\mathbf{F}}_{\mathrm{in}}\right),{\mathrm{Conv}}_{3\times 3}\left({\mathbf{F}}_{\mathrm{in}}\right))\right)$$

(52)

SPPF variant uses parallel max-pooling with kernel progression $(5,9,13)$.

C2PSA attention mechanism is

$${\mathbf{F}}_{\mathrm{psa}}=\sigma \left({\mathbf{W}}_{\mathrm{channel}}\right)\otimes \mathrm{Conv}\left({\mathbf{F}}_{\mathrm{in}}\right)+\sigma \left({\mathbf{W}}_{\mathrm{spatial}}\right)\otimes {\mathbf{F}}_{\mathrm{in}}$$

(53)

where $\sigma$ denotes sigmoid activation for attention gating.

Figure 14. YOLOv11 architecture with C3k2 backbone and C2PSA-enhanced neck.

Figure 14. YOLOv11 architecture with C3k2 backbone and C2PSA-enhanced neck.

The performance analysis based on multi-task benchmarking and the efficiency gains are as follow

• Multi-Task Benchmarking is shown in Table 14
• Efficiency Gains are

  -

  $22\%$ parameter reduction vs YOLOv8m ($41.2M$→$32.1$M)

  -

  $18\%$ faster inference than YOLOv10-S at equivalent accuracy

  -

  $37\%$ lower VRAM consumption during training

The limitations are

• $25\%$ longer training convergence vs YOLO$v10$
• $15\%$ accuracy variance across edge AI accelerators
• Requires CUDA $12.1+$ for optimal performance
• Limited documentation for OBB extensions

4.12. Yolov12 (2025)

YOLOv12, an attention-optimized real-time detector via area attention and residual ELAN,[93] introduces area attention with linear complexity:

$$\mathcal{A}(\mathbf{Q},\mathbf{K},\mathbf{V})=\mathrm{Softmax}\left({\displaystyle \frac{\mathbf{Q}{\mathbf{W}}_a{\mathbf{K}}^{\top }}{\sqrt{d}}}\right)\mathbf{V}$$

(54)

where ${\mathbf{W}}_a\in {\mathbb{R}}^{k\times k}$ is learnable area projection ($k\ll h,w$).

Residual ELAN (R-ELAN) is

$${\mathbf{F}}_{\mathrm{relan}}={\mathbf{F}}_{\mathrm{in}}+{\mathrm{Conv}}_{1\times 1}\left(\underset{i=1}{\overset{4}{⨁}}{\mathcal{B}}_i\left({\mathbf{F}}_{\mathrm{in}}\right)\right)$$

(55)

where ${\mathcal{B}}_i$ are bottleneck blocks with depthwise separables.

Figure 15. YOLOv12 architecture featuring area attention and R-ELAN blocks.

Figure 15. YOLOv12 architecture featuring area attention and R-ELAN blocks.

The performance analysis based on MS COCO benchmarks is shown in Table 15

The technical advancements are

• $42\%$ faster than RT-DETR-R18 with $+2.7\%$ mAP
• $36\%$ FLOPs reduction vs YOLOv11-S
• $58\%$ fewer memory accesses than vanilla attention
• $4.3$× speedup from FlashAttention [95]

The limitations are

• Requires Turing/Ampere GPUs for optimal performance
• $28\%$ longer training time vs YOLOv11
• $18\%$ mAP variance across ARM Mali GPUs
• No official TensorRT support for area attention

5. Comparative Analysis of the YOLO Models Till Date

The YOLO (You Only Look Once) architecture has undergone significant evolution since its inception. The original YOLOv1 [7] revolutionized real-time object detection through a unified CNN approach with 24 convolutional layers, achieving $63.4$ mAP on PASCAL VOC at 45 FPS. YOLOv2 [34] advanced this foundation with Darknet$-19$ and anchor boxes, boosting performance to $78.6$ mAP. Subsequent iterations introduced critical innovations: YOLOv3 [40] implemented multi-scale predictions via Darknet$-53$ and FPN, while YOLOv4 [46] combined CSPDarknet53 with SPP/PANet modules and BoF techniques to reach $57.2$ AP on COCO. The PyTorch-based YOLOv5 [62] introduced auto-anchor generation and C3 blocks, achieving 280 FPS on A100 GPUs. Industrial-focused YOLOv6 [84] optimized hardware performance through Rep-PAN neck designs, matching YOLOv4’s accuracy with 22% fewer parameters. YOLOv7 [89] further enhanced multi-scale detection through E-ELAN architectures and coarse-to-fine labeling. Current versions demonstrate expanding capabilities - YOLOv8[83] supports multi-task learning with $53.9$ AP, while YOLOv9 [10] implements programmable gradient information for enhanced feature preservation. Cutting-edge developments include YOLOv10’s [11] NMS-free architecture ($1.64$ms latency) and YOLOv11’s [92] C2PSA attention modules for multi-task learning. The latest YOLOv12[93] pioneers attention optimization through Area Attention mechanisms and FlashAttention integration, achieving $55.2$ AP with $40\%$ fewer memory operations than transformers. A summarized view of YOLO evolution, and its architectural changes and performance metrics are shown in Table 16.

6. Applications and Use Cases Of YOLO Algorithms in Real World Scenarios

The YOLO family of object detection algorithms has moved from academic promise to practical deployment across a diverse range of domains (SMI) Section 7 due to its inception. Its hallmark real-time speed, combined with respectable accuracy and efficiency, has made it a go-to solution in critical, real-world settings where time, power, and precision all matter.

6.1. Autonomous Vehicles and Advanced Driver-Assistance Systems (Adas)

In the realm of self-driving cars and driver-assistance systems, YOLO’s speed-accuracy trade-off is pivotal. Modern perception stacks use YOLO models to interpret video feeds from monocular, stereo, and surround-view cameras in real-time, detecting road users, vehicles, traffic signs, lane markings, and obstacles [96]. Since YOLOv3, improvements in small object detection and overall robustness have made the algorithm suitable for ADAS features such as automatic emergency braking (AEB), lane keeping assist, and adaptive cruise control [97,98]. Meta-analyses demonstrate consistent outperformance of YOLOv5 and YOLOv8 in vehicle and pedestrian detection tasks, striking an excellent balance of speed, precision, and recall [99]. YOLO’s mAP for vehicles, pedestrians, and traffic signs steadily improved—from $63\%$ in early versions to over $80\%$ in lightweight configurations like YOLOv8n and YOLOv10—while maintaining inference speeds exceeding 100 FPS [100]. HR-YOLO is optimized for foggy conditions, integrating defogging networks and attention modules to detect vehicles with mAPs up to $79.8\%$, improving robustness in adverse weather [101]. Some study refers YOLOv9 as for offering a balanced tradeoff between speed and accuracy in urban ADAS deployments [102].

6.2. Intelligent Surveillance and Public Safety

YOLO algorithms have become cornerstone technologies in modern public safety systems, offering real-time object detection capabilities that enhance surveillance, crowd monitoring, threat detection, and anomaly recognition. From the earliest YOLO versions to the latest iterations (v8–v12), these solutions have significantly improved detection accuracy, latency, and deployment scalability on edge devices [103]. A key focus has been on threat identification in public spaces. For instance, a 2024 study demonstrated a YOLOv8-based weapon detection model capable of identifying firearms and edged weapons in video streams, yielding high precision, recall, and frame rates suitable for airports or schools [104]. The CMCA YOLO model integrates cross-attention and multi-spectral channel attention to detect small, overlapping targets like pedestrians in parking lots, achieving mAP $\approx 0.895$ and 143 fps, ensuring accuracy and speed in dense urban environments [105]. Integrations with DeepSORT tracking allow persistent monitoring across cameras, solving challenges like occlusion and thermal crossover in infrared footage [106,107]. When accelerated with tools like the NVIDIA DeepStream SDK, YOLO-based systems can achieve real-time performance—up to 21 fps per camera [108].

6.3. Enhancing Healthcare and Medical Imaging

YOLO models have emerged as transformative tools in healthcare, offering real-time, high-precision object detection across various medical imaging domains, including ulcer staging, tumor identification, fracture detection, and organ localization. Over 124 peer-reviewed studies employed YOLO variants for lesion detection, skin lesion classification, retinal abnormality recognition, cardiac anomaly detection, brain tumour segmentation, and PPE monitoring in medical settings [109]. Though YOLO is not a replacement for high-precision CNNs used in radiology, it proves highly effective in real-time applications such as intraoperative tool tracking, anomaly detection in X-rays and MRIs, and edge-based mobile diagnostics [8,110]. Multiple YOLO versions (v5–v8) were benchmarked for detecting pediatric wrist fractures, with YOLOv8m achieving $0.95$ mAP and $0.92$ sensitivity, exceeding the performance of two-stage detectors such as Faster R-CNN [111]. YOLO helps surgeons navigate and ensures critical tools are visible and tracked on screen, potentially reducing errors and operation time [110]. Lightweight versions like YOLOv5 and YOLOv8 are increasingly used in edge medical platforms for tasks such as tumor identification, kidney stone detection, and Parkinson’s biomarker analysis [112]. In wound care, YOLOv5 was applied to pressure ulcer detection, achieving an average mAP of $76.9\%$ across five stages, with stage-specific mAPs ranging from $66\%$ to $99.5\%$[113]. In neuro-oncology, improved YOLOv8 variant achieved $0.91$ mAP on brain tumour MRI datasets—surpassing earlier YOLO models and region-based alternatives [114]. Research continues to expand its clinical viability, particularly across varied patient demographics.

6.4. Driving Sustainable Agriculture and Environmental Monitoring

Precision agriculture and ecological conservation benefit from automated, real-time visual analysis. The agricultural sector benefits from YOLO through precision farming, where drones equipped with YOLO-powered vision systems monitor crop health, detect weeds, and estimate yield [115]. Such applications not only enhance efficiency but also enable sustainable farming practices. YOLO’s integration into drone and satellite imagery allows for large-scale monitoring of deforestation, animal tracking, and environmental conservation efforts [116]. Real-time detection of crops, weeds, pests, and diseases using camera-equipped drones or ground robots, enabled by YOLO for targeted spraying and yield estimation, also supports fruit detection and counting for automated harvesting robots [117,118,119]. One of the earliest demonstrations, Ag YOLO, developed for onboard UAV systems, achieved $36$ fps and F1=$0.92$ using RGB imagery for crop-level detection, facilitating precise pesticide application to reduce chemical overuse [120]. The use of YOLO algorithms has extended to object detection using satellite and aerial imagery, and even to the determination of food authenticity [121,122]. YOLO contributes to sustainable agriculture, improved animal welfare, more efficient resource use, and enhanced capabilities for large-scale environmental protection efforts. YOLOv8m achieved an exceptional F1 score of $99.31\%$, marking a significant advancement in scalable plantation surveillance in monitoring oil palm health [123]. Novel models like YOLO IAPs (YOLOv9) specialize in detecting invasive plant species, vital for biodiversity conservation and ecological risk management [124].

6.5. Enabling Smart Manufacturing and Industrial Automation

Manufacturing and logistics demand high-speed, reliable visual inspection and robotic guidance. YOLO’s real-time performance is perfectly suited for these fast-paced environments. YOLO algorithms have demonstrated significant potential in industrial applications for real-time defect detection, product sorting, and worker safety [125,126]. A prominent example is YOLO-FIX, an enhanced YOLOv11 model with attention and multi-scale fusion modules engineered to detect glue-line defects on mobile phone frames. It achieved $95.2\%$$mA{P}_{50}$ and maintained a high inference rate of 189 FPS, representing an $8.6\%$ mAP improvement over vanilla YOLOv11 [127]. A study using YOLOv5 on high-mix low-volume (HMLV) production lines demonstrated precision and recall above $98\%$, with $mA{P}_{50}$ over $97\%$, showcasing robustness across changing products and lighting conditions - critical factors in flexible, small-batch manufacturing [128]. Studies have shown successful implementation of YOLO variants for partial depth estimation in robot arm control, warehouse robot detection for human safety, and object recognition for robotic arm manipulation [129,130]. [131] discusses the deployment of YOLO in smart factories where its ability to detect minute defects on fast-moving conveyor belts plays a crucial role in quality assurance. YOLO significantly boosts production efficiency, reduces waste from defects, lowers labor costs, and enables flexible automation. Moving forward, integrating these models with digital twins, robotic control, and federated learning will further accelerate the realization of fully autonomous, efficient, and adaptable smart factories.

6.6. Retail Analytics and Customer Experience

The retail sector leverages YOLO to gain insights into customer behavior, improve product placement, optimize operations and store layouts, as well as enhance inventory management [132]. Recent research has focused on automated systems for real-time detection of out-of-stock items, misplaced products, and planogram compliance in retail environments. These systems typically employ mobile robots or cameras to scan shelves, using deep learning object detection algorithms like YOLO to identify specific SKUs and their locations [133]. The use of Tiny-YOLO and its successors ensures that even embedded systems like digital signage and smart kiosks can run object detection algorithms effectively [134]. By combining YOLOv8 or YOLOv11 with object-tracking systems like BOT SORT, retailers can visualize queue lengths, wait times, and congestion zones in real time. YOLOv8+BOT SORT was used to track shoppers and derive dwell times and heatmaps, enabling efficient staffing and reduced wait times [135].

6.7. Emerging and Diverse Application

The diverse applications highlighted above underscore YOLO’s transformative role as a practical enabling technology. From saving lives on the road and in hospitals, to securing cities and optimizing global supply chains, to fostering sustainable agriculture and retail innovation, YOLO’s real-time object detection capability has moved from a research breakthrough to an indispensable tool embedded in the fabric of modern technological solutions. The versatility of YOLO has spurred innovations beyond the mainstream. It has been effectively used for face mask detection using has emerged as an effective approach to monitor mask usage during the COVID-19 pandemic [136]. Fine-tuned YOLOv8 models have been used to identify coral species and track marine fauna via drone or AUV imaging, fostering large-scale biodiversity assessments [137]. It has also been used in the microbial growth detection on food surfaces [2], fabric defect detection for textile applications [138], crack detection in historical constructions [139], human posture estimation [140], text detection in natural scenes [141], underwater water leak detection [142], and many more. A comprehensive summary of these applications is provided in Appendix Section 7.

7. Conclusions

The YOLO framework has fundamentally transformed real-time object detection through its continuous architectural evolution spanning twelve generations. From YOLOv1’s groundbreaking unification of localization and classification to YOLOv12’s attention-based cross-scale fusion, this review has documented how successive innovations systematically addressed core challenges: overcoming information loss via PGI (v9), eliminating NMS bottlenecks (v10), and enhancing small-object detection through transformer-CNN hybrids (v12). Benchmark analyses confirm YOLO’s dominance in balancing speed ($45-142$ FPS) and accuracy ($63.4-78.4\%$ AP on COCO), achieving 47× faster inference than region-based predecessors while maintaining competitive precision.

Our exploration reveals three critical success factors: 1) Architectural simplicity enabling hardware-aware optimizations, 2) Progressive feature hierarchy refinements for multi-scale robustness, and 3) Strategic adoption of attention mechanisms without compromising throughput. These advancements have propelled YOLO’s adoption across autonomous systems, medical diagnostics, industrial automation, and precision agriculture—domains where latency-accuracy tradeoffs are mission-critical.

Future research should prioritize: 1) Lightweight architectures for ultra-edge deployment, 2) Self-supervised adaptation to long-tail distributions, and 3) Unified frameworks for multimodal detection. As object detection evolves toward embodied AI applications, YOLO’s design philosophy—maximal performance through minimal computational complexity—remains an enduring blueprint for real-time perception systems. This review provides both technical reference and historical context to guide next-generation innovations building upon YOLO’s foundational legacy.