Source-linked AI summary
YOLOv8 to YOLO11: A Comprehensive Architecture In-depth Comparative Review
Priyanto Hidayatullah, Nurjannah Syakrani, Muhammad Rizqi Sholahuddin, Trisna Gelar, Refdinal Tubagus
TL;DR
Recent YOLO versions are difficult to understand because some lack scholarly publications, official diagrams, and sufficiently detailed reviews. This study compares YOLOv8 through YOLO11 using literature, documentation, and source-code analysis, finding architectural and feature-extraction improvements alongside unchanged blocks and an attention-layer trend beginning with YOLOv10.
Problem
Some YOLO versions lack scholarly publications or official architectural diagrams, while existing reviews insufficiently detail recent architectures.
Method
The study compares YOLOv8 through YOLO11 by examining academic papers, technical documentation, configuration files, and source-code implementations.
Results
The analysis found architectural and feature-extraction enhancements across versions, some blocks unchanged from predecessors, and attention layers incorporated beginning with YOLOv10.
Takeaways & Limitations
The study provides a focused architectural comparison intended to improve understanding of recent YOLO models and their differences.
Takeaways & Limitations
The YOLO11l illustration was selected because YOLO11 lacks an official architectural diagram and published paper.
Abstract
from arXiv · showhide
Note: This is a preliminary version of the manuscript. The final, peer-reviewed, and substantially revised version has been published in Jurnal RESTI. Readers are encouraged to access and cite the published version: DOI: https://doi.org/10.29207/resti.v10i2.6598 In the field of deep learning-based computer vision, YOLO is revolutionary. With respect to deep learning models, YOLO is also the one that is evolving the most rapidly. Unfortunately, not every YOLO model possesses scholarly publications. Moreover, there exists a YOLO model that lacks a publicly accessible official architectural diagram. Naturally, this engenders challenges, such as complicating the understanding of how the model operates in practice. Furthermore, the review articles that are presently available do not investigate the specifics of each model. The objective of this study is to present a comprehensive and in-depth architecture comparison of the four most recent YOLO models, specifically YOLOv8 through YOLO11, thereby enabling readers to quickly grasp not only how each model functions, but also the distinctions between them. To analyze each YOLO version's architecture, we meticulously examined the relevant academic papers, documentation, and scrutinized the source code. The analysis reveals that while each version of YOLO has improvements in architecture and feature extraction, certain blocks remain unchanged. The lack of scholarly publications and official diagrams presents challenges for understanding the model's functionality and future enhancement. Future developers are encouraged to provide these resources.
1 Introduction
YOLO's rapid evolution has outpaced the availability of scholarly publications, official architectural diagrams, and detailed reviews. This study addresses the gap through a comprehensive comparison of YOLOv8 to YOLO11.
- YOLO has developed from YOLOv1 in 2015 to its 11th version in use by 2024.
- Some YOLO versions lack academic publications or comprehensive architectural diagrams, forcing reliance on secondary sources and empirical analysis.
- Existing reviews often provide limited architectural detail, leaving the functionality and distinct improvements of recent YOLO models insufficiently explained.
- The study offers a comprehensive and systematic comparison of YOLOv8 through YOLO11 to clarify each model's operation and progression.
2 Literatur Review
Prior reviews cover different portions or applications of the YOLO family, but often do not deeply compare the latest architectures. This study focuses on architectural differences and changes from YOLOv8 to YOLO11.
- YOLOv8 introduced anchor-free detection and a unified framework supporting detection, segmentation, and classification tasks.
- YOLOv9 introduced PGI and GELAN to address information bottlenecks and improve lightweight-model accuracy.
- YOLOv10 introduced NMS-free training, decoupled downsampling, and large-kernel convolutions to improve deployment, computational efficiency, accuracy, and latency.
- YOLO11 added C3k2, SPPF, and C2PSA components, while reviews still lacked detailed examination of recent architectural parts and their effects.
- YOLO reviews have examined historical development, speed-accuracy trade-offs, application needs, and versions ranging from YOLOv1 to YOLOv11.
- This study analyzes architectural details and source code to clarify the differences and recent improvements between YOLOv8 and YOLO11.
3 Research Methods
The researchers combined relevant literature, technical documentation, and source-code analysis to reconstruct each YOLO version's overall architecture and component diagrams.
- The study examined corresponding literature but also analyzed every version's source code because literature alone was insufficient for comprehensive architectural understanding.
- YOLO .yaml files supplied overall architecture blocks, while Python modules supplied the implementations of those blocks.
- The researchers cloned each version's GitHub repository, inspected version-specific configuration and module files, and created overall-architecture and block diagrams.
4 Results and Discussions
The results and discussion section presents each YOLO version's overall architecture and component blocks using the corresponding papers, source code, and technical documentation.
- The section elaborates on every YOLO version's overall architecture and blocks based on its paper, source code, and technical documentation.
4.1 YOLO Overall Architecture
YOLO architectures comprise feature-extracting and prediction components whose detailed blocks vary across versions. From YOLOv8 through YOLO11, the models retain multi-scale processing while introducing version-specific training, feature, and efficiency designs.
- Overall architecture: YOLO generally consists of a stem, downsampling layers, stages with building blocks, and a head that processes progressively abstract features.The stem processes raw input, downsampling reduces spatial resolution, and stages operate at different resolutions to produce higher-level representations.
- YOLOv8: YOLOv8 uses C2f stages, stride-2 convolution for downsampling, SPPF for multi-scale representation, and nearest-neighbor upsampling in the neck.Its eight stages use shortcuts in the backbone but not in the neck, based on empirical trial-and-error results.
- YOLOv9: YOLOv9 adds an auxiliary training section, uses RepNCSPELAN4 stages with ADown downsampling, and includes SPPELAN, upsampling, and concatenation in the neck.The auxiliary section can be removed during inference, while three additional heads detect small, medium, and large objects.
- YOLOv10: YOLOv10 builds on YOLOv8 and uses C2f or C2fCIB stages, replacing bottlenecks with Compact Inverted Blocks at high-redundancy stages.The l variant uses C2fCIB in blocks 8, 13, 19, and 22 under rank-guided block design.
- YOLO11: YOLO11 retains YOLOv8’s stem and variant parameters but employs C3k2 stages, whose c3k setting selects C3k or Bottleneck implementations.The C3k2 block is described as an advancement of C2f with fewer parameters; source-code analysis found settings not documented in YOLO11 documentation.
4.2 YOLO Architecture Blocks
YOLOv8 through YOLO11 share core convolutional processing but differ in resizing, downsampling, and newly introduced YOLO11 convolutional blocks.
- Input Image Resizing: YOLOv8 through YOLO11 resize inputs while preserving aspect ratio by padding non-square images with gray pixels.Square images are resized without padding.
- Convolutional Block: The standard convolutional block fuses 2-dimensional convolution, batch normalization, and SILU activation.YOLO11 additionally introduces a convolutional block without activation and a depthwise convolutional block.
- Downsampling: YOLOv8 and YOLO11 use traditional 3×3 stride-2 convolution for downsampling, whereas YOLOv9 and YOLOv10 use ADown and SCDown, respectively.The traditional approach is described as resource-intensive; SCDown separates channel adjustment from spatial reduction, while ADown combines average and max pooling.
- Downsampling: SCDown changes channels with 1×1 pointwise convolution before reducing spatial resolution with depthwise convolution.This separation reduces computational cost and parameter count.
- Downsampling: ADown performs downsampling with average pooling and max pooling, which contain no parameters.Consequently, its parameter count is comparatively lower.
4.2.4 Bottleneck
Bottleneck-related blocks support deeper feature extraction, while YOLOv10 replaces selected C2f bottlenecks with CIB according to intrinsic redundancy and rank.
- Bottleneck: Bottlenecks resemble ResNet blocks and appear in YOLOv8, YOLOv10, and YOLO11.Stacking bottlenecks enables deeper networks with little additional computing cost, with some variants using shortcuts.
- C2f: C2f is a faster CSP Bottleneck implementation used for feature extraction throughout YOLOv8 and YOLOv10.Its feature-vector switching and multilayer convolution learn multiscale features and broaden receptive fields.
- C2fCIB and CIB: YOLOv10 introduces C2fCIB through rank-guided block design, adapting block complexity at each stage using intrinsic rank analysis.Intrinsic rank counts significant singular values in a basic block’s final convolution.
- C2fCIB and CIB: At highly redundant deeper stages, YOLOv10 replaces C2f bottlenecks with CIB to form C2fCIB.In YOLOv10l, this occurs in blocks 8, 13, 19, and 22, improving training speed compared with YOLOv8.
- C2fCIB and CIB: CIB uses a sequence of depthwise convolution, convolution, depthwise convolution, convolution, and depthwise convolution.Some CIB variants include shortcuts and others do not.
- RepVGGDW: YOLOv10 uses large-kernel convolution only in deep stages by replacing CIB’s second depthwise convolution with RepVGGDW.RepVGGDW combines depthwise convolutions with kernel sizes three and seven.
4.2.7 C3k2 Block
YOLO11 introduces C3k2 as a C2f replacement, while the YOLO family uses SPPF or SPPELAN for multiscale representation and attention blocks for feature relationships.
- C3k2 Block: C3k2 is newly introduced in YOLO11 as a replacement for the C2f block.Its first version is congruent with C2f, while its second replaces bottlenecks with one C3k block.
- C3k2 Block: C3k contains three convolution blocks and several bottlenecks, with shortcut and non-shortcut bottleneck variants.C3k2 is described as suitable for capturing complex features from objects of varying sizes.
- SPPF and SPPELAN: SPPF represents feature maps across multiple scales through pooling at varying scales and was introduced in YOLOv8 before adaptation in YOLOv10 and YOLO11.YOLOv9 uses the analogous SPPELAN block.
- SPPF and SPPELAN: SPPF uses a max-pooling kernel size of 5 instead of SPP’s sizes 3, 5, and 9, reducing floating-point operations relative to SPP.SPPELAN has analogous structure and function in some YOLOv9 blocks.
- C2PSA and PSABlock: YOLOv10 uses PSA, while YOLO11 uses the more complex C2PSA, which contains multiple PSA blocks and iteratively performs partial self-attention.C2PSA splits inputs into shortcut and deep-processing pathways, capturing deeper feature relationships without additional time expenditure.
4.2.10 Detect Block
YOLOv8 and YOLOv9 use similar classification and regression heads, while YOLOv10 introduces NMS-free dual assignment and YOLO11 retains a lightweight classification head with a new DWConv block.
- YOLOv8 and YOLOv9: YOLOv8 and YOLOv9 detect blocks contain separate classification and regression heads, each built from two convolutional blocks followed by a 2-dimensional convolution.The classification head predicts class probabilities and the regression head predicts bounding-box coordinates.
- YOLOv10: YOLOv10 gives the classification and regression heads distinct architectures because their computational costs differ, with the classification head potentially twice as large.Depthwise convolutions make the classification head lighter and reduce model parameters.
- YOLOv10: YOLOv10’s Consistent Dual Assignment trains one head with one-to-many matching and another with one-to-one matching.Inference uses only the one-to-one head, eliminating the need for NMS while maintaining performance according to the cited description.
- YOLO11: YOLO11’s detect block uses depthwise convolutions in its classification head, closely resembling YOLOv10, and adds a novel DWConv block.Figure 20 illustrates the YOLO11 detect block.
4.3 An Illustration of How the Architecture Processes an Image
The YOLO11l illustration traces image processing from convolutional downsampling through backbone feature extraction, SPPF and C2PSA processing, feature fusion, and scale-specific detection. Spatial resolution decreases for deeper features and is later restored through upsampling to support detection at multiple object sizes.
- Input and model configuration: YOLO11l processes a 640 x 640 x 3 image using depth_multiple 1, width_multiple 1, and max_channels 512.The model variant is selected as the architectural demonstration, with these configuration values listed in Table 3.
- Backbone: Initial convolutional blocks reduce resolution from 640 x 640 to 320 x 320 and then 160 x 160 while adjusting feature channels.Block 0 uses a 3 × 3 convolution with stride 2, followed by another stride-2 convolution in Block 1.
- Backbone: The backbone progressively reduces spatial size to 80 x 80, 40 x 40, and 20 x 20 while using C3k2 blocks for deeper feature extraction.C3k2 blocks at Blocks 4, 6, and 8 connect backbone outputs to the neck.
- Neck: At the 20 x 20 stage, SPPF integrates spatial information and C2PSA applies processing exclusively at the lowest resolution to limit self-attention computation.Both blocks preserve the 20 x 20 x 512 feature-map dimensions.
- Feature fusion: The neck upsamples features and concatenates them with backbone outputs, implementing an FPN that combines varying resolutions and abstraction levels.The first fusion produces 40 x 40 x 1024, while a later fusion produces 80 x 80 x 1024.
- Detection heads: The detection heads use 80 x 80, 40 x 40, and 20 x 20 feature maps for relatively small, medium-sized, and big objects, respectively.Higher spatial resolution retains more detail for small objects, whereas lower resolution provides more compact representations for larger objects.
5 Conclusion
The analysis finds that YOLO versions refine architecture and feature extraction while retaining some blocks from earlier versions. Missing scholarly publications and official architecture diagrams hinder understanding and future enhancement, and the authors recommend that future developers provide both resources.
- Each YOLO version includes architectural and feature-extraction enhancements, although some architectural blocks remain unchanged from previous versions.
- The absence of scholarly publications and official architecture diagrams makes YOLO functionality harder for researchers and practitioners to understand.
- The analysis identifies an evolutionary trend in YOLO toward incorporating an attention layer beginning with YOLOv10.
- Future YOLO developers are urged to provide architectural diagrams and scholarly publications to support model comprehension and enhancement.