YOLOv11: An Overview of the Key Architectural Enhancements

In plain words

YOLO is a family of object detectors that look at a whole image once and report every object they find, with a box and a label. This paper describes the eleventh generation of that family, YOLOv11, and walks through what changed compared with earlier versions.

The changes are mostly inside the network. Some of its building blocks were swapped for cheaper ones, and one new block adds a step where the network focuses on the important parts of the picture. The same design comes in five sizes, from very small to very large, and is meant to be used for several vision jobs, not just finding boxes.

The authors do not run their own experiments. They summarise performance figures that other people published, so the numbers show the family's advertised trade-offs rather than results the authors measured. Treat the architecture description as an overview, not as a blueprint to build from.

TL;DR

• YOLOv11 is the 2024 Ultralytics release in the YOLO series, described here as a review §1 §4.
• Its main architectural changes are the C3k2 block in place of C2f and a C2PSA attention block after SPPF §4.1.1 §4.1.2.
• One model family covers five sizes and five tasks: detection, instance segmentation, pose, oriented boxes and classification tab. 2.
• The paper runs no experiments; its performance claims are secondary and the text gives no layer-level specification.
• Use it for orientation. The paper gives no exact layer settings, and no code is linked (see Paper vs code).

Problem

The paper sets out to explain what changed in YOLOv11 relative to YOLOv8, the previous model it names as its base §4, and to check claimed gains in accuracy, speed and parameter count against earlier versions §1 §6. It does not state a formal problem or a target metric beyond mAP and computational efficiency §1. Its scope is architecture and reported performance; there is no training study and no ablation §4 §6.

Method

The paper gives a prose overview, no algorithm box and no equations. It divides the detector into backbone, neck and head §4 and describes the changes block by block. Cited section numbers follow the compiled paper's numbering.

Backbone §4.1. Initial convolutional layers downsample the image while increasing channel count §4.1.1. The C3k2 block takes the place of C2f from earlier versions and is described as a cheaper Cross Stage Partial bottleneck built from two smaller convolutions §4.1.1. After the SPPF block, which is kept from earlier versions, a C2PSA block is added §4.1.2.

Neck §4.2. The neck combines features from several scales by upsampling and concatenation. The paper says C3k2 replaces C2f here too §4.2.1. It adds C2PSA-based spatial attention, which it contrasts with YOLOv8 §4.2.2.

Head §4.3. Several C3k2 blocks refine the multi-scale maps §4.3.1. The c3k flag selects the inner unit: with c3k = False the block acts like C2f with a standard bottleneck, with c3k = True the bottleneck is replaced by a C3 module §4.3.1. Each C3k2 stage is followed by CBS layers (convolution, batch normalisation, SiLU) §4.3.2. Each detection branch ends with Conv2D layers, and a Detect layer outputs box coordinates, objectness scores and class scores §4.3.3.

# YOLOv11 forward pass, as the text describes it. The paper gives no
# algorithm box; the names below are descriptive, not the official ones.
# Input: image (B, 3, H, W)
# Output: boxes, objectness and class scores per detection branch
def yolo11_forward(image):
    # Backbone: convolutions that downsample, plus C3k2 blocks  [§4.1.1]
    features = backbone(image)
    # SPPF, kept from earlier versions  [§4.1.2]
    features = sppf(features)
    # C2PSA spatial attention after SPPF  [§4.1.2]
    features = c2psa(features)
    # Neck: upsample and concatenate across scales, C3k2 blocks  [§4.2] [§4.2.1]
    maps = neck(features)
    # Head: C3k2 blocks, then CBS layers per branch  [§4.3.1] [§4.3.2]
    maps = head_c3k2_and_cbs(maps)
    # Conv2D per branch, then the Detect layer  [§4.3.3]
    boxes, objectness, class_scores = detect(maps)
    return boxes, objectness, class_scores

Variants and tasks §5 tab. 2. The paper lists five sizes (nano, small, medium, large, xlarge) and five task families. Table 2 of the paper, reproduced here, marks each family as supporting inference, validation, training and export:

The text also lists object tracking as a task §5, but Table 2 has no tracking row. The paper writes "yolo1-medium-obb" in Table 2; the pattern of the other rows suggests yolo11-medium-obb, but the paper does not say so.

No equations and no algorithms appear in the paper §4 §5.

Hyperparameters

The paper has no training section, so most values are not stated.

Results

The paper reports no experiments of its own. The figures below are its text's summary of published material. The dataset is COCO; hardware and baseline latency settings are not stated.

The exact values come from a chart (Figure 2), which the caption credits to a third-party source [modelandtasksyolov11]. The paper gives them as approximations. The text also says that the YOLOv11m accuracy matches larger models from earlier generations at lower latency §6; no table backs this.

Paper vs code

No official code. The paper links no repository and no project page, and its abstract and metadata carry no code link. A GitHub search for "yolov11 khanam" returned nothing, and a search for "yolov11" returned only third-party forks and wrappers. The reference list does cite github.com/ultralytics/ultralytics (AGPL-3.0) as the YOLO11 software [yolo11_ultralytics]. That repository belongs to Ultralytics, not to the paper's authors, so it is not used here. Its licence also rules out quoting its code.

Pitfalls

• No independent measurements. Every performance number is secondary. Figure 2's caption attributes it to Ultralytics documentation [modelandtasksyolov11] §6. Do not present these numbers as this paper's findings.
• No layer specification. The paper gives no channel counts, depths, strides, kernel sizes or block counts per stage, and says only that C3k2 blocks sit "in several pathways" of the head §4.3.1. An implementation from this card alone would be a guess.
• Inconsistent C3k2 placement. Section 4.1.1 says C3k2 replaces C2f in the convolutional layers, section 4.2.1 says it replaces C2f in the neck, and section 4.3.1 adds C3k2 blocks in the head. The text does not say whether these are the same kind of block.
• C2PSA expansion differs. The abstract spells C2PSA as "Convolutional block with Parallel Spatial Attention", while section 4.1.2 writes "Cross Stage Partial with Spatial Attention". The attention mechanism is described only as pooling features spatially and focusing on regions §4.1.2; no formula is given.
• "k2" and "c3k" are overloaded. Section 4.1.1 reads "k2" as a smaller kernel size. Section 4.3.1 says the C3k module allows customisable kernel sizes, but does not say whether the C3k2 kernel changes with c3k.
• Efficiency claims are unmeasured. Faster processing and parameter efficiency for C3k2 §4.3.1 are stated without a benchmark, and the paper does not report the parameter count of any YOLOv11 variant.
• Objectness output is unverified. The Detect layer is said to output objectness scores §4.3.3. Without the paper's loss or assignment rules, or code, an implementer cannot confirm how these scores are trained or used.
• Latency hardware missing. The 13 ms and 2 to 6 ms latency figures §6 name no device, batch size or precision.
• Figure 1 is not reproduced. Its caption says it shows the key architectural modules fig. 1; the card has no image, so read the paper for the block layout.

Lineage

• Builds on: YOLOv8 (the base the paper extends §4, cited via Solawetz 2023 [Solawetz2023yolov8]); YOLOv9 and YOLOv10, named as predecessors §6.
• Compared against: YOLOv5 through YOLOv10 in the benchmark discussion §6 fig. 2. YOLOv5 is cited through the authors' own review khanam2024yolov5, arXiv:2407.20892.