YOLOv11

Before 2015, detection was a two-stage affair: propose candidate regions, then classify each one. Redmon et al.'s You Only Look Once collapsed that into a single pass — one convolutional network regresses bounding boxes and class probabilities for the whole image at once. Framing detection as regression is what made real-time detection practical, and every YOLO since has been an argument about how to keep that single pass while closing the accuracy gap to slower detectors.

The paper's Table 1 traces that argument version by version. YOLOv2 added multi-scale training and dimension-clustered anchors; YOLOv3 brought the Darknet-53 backbone, multi-scale prediction and an SPP block; YOLOv4 moved to CSPDarknet-53 with Mish activations. YOLOv5 marked the jump from Darknet to PyTorch, and with YOLOv8 (2023) Ultralytics settled on the anchor-free, multi-task design YOLO11 extends. 2024 alone produced three releases: YOLOv9 (Programmable Gradient Information and GELAN), YOLOv10 (consistent dual assignments for NMS-free training) and YOLO11.

The table is a compressed summary and some of its one-line attributions are loose — YOLOv5's official detector, for instance, is anchor-based, and anchor-free heads became the Ultralytics default with YOLOv8. What matters for YOLO11 is the immediate parent: it is an evolution of YOLOv8, not of YOLOv10. It keeps YOLOv8's backbone/neck/head topology and task heads, swaps C2f for C3k2, and borrows the idea of a lightweight attention block at the coarsest scale — an idea YOLOv10 had also used in its PSA module.

Every YOLO has the same three-stage shape, and YOLO11 does not change it. The backbone is a stack of strided convolutions and specialised blocks that turns a raw image into feature maps at several resolutions. The neck aggregates those maps across scales — upsampling coarse, semantic features and concatenating them with fine, spatially precise ones. The head turns each fused map into predictions.

Because the whole network is one differentiable graph, box regression and classification are trained end-to-end — the property that separated YOLO from two-stage detectors in the first place. What YOLO11 changes is which blocks fill the stages. In the backbone, initial strided convolutions downsample the image while widening channels, and the C3k2 block replaces YOLOv8's C2f. At the bottom of the backbone the SPPF block is retained and a new C2PSA block follows it. In the neck, C3k2 again replaces C2f after each upsample-and-concatenate step. And in the head, multiple C3k2 blocks and CBS (Conv-BatchNorm-SiLU) layers refine features before the final Conv2D branches.

The paper's Figure 1 compresses this into one picture: three key modules — SPPF, C2PSA, C3k2 — feeding one model that serves six task types. The scale structure is worth internalising concretely. With the standard 640×640 input, the head reads features at strides 8, 16 and 32 — grids of 80×80, 40×40 and 20×20 — so small objects are predicted from the fine map and large objects from the coarse one. C2PSA sits on that coarsest 20×20 map, which is exactly where attention is affordable.

The workhorse of YOLO11 is the C3k2 block, and it appears everywhere: backbone, neck and head. It replaces YOLOv8's C2f, and both are descendants of the Cross Stage Partial (CSP) idea — split the channels, send only part of them through the expensive transformation, and merge everything back at the end. The untouched part keeps a cheap gradient path and avoids recomputing redundant features; the transformed part does the real work.

The paper describes C3k2 as a more computationally efficient CSP bottleneck that uses two smaller convolutions instead of one large convolution. That trade is classic: two stacked 3×3 convolutions cover the same 5×5 receptive field as one 5×5 convolution, with fewer weights and an extra non-linearity in between. The paper reads the "k2" in the name as signalling this smaller-kernel design, and attributes C3k2's speed to it.

The interesting part is the c3k switch. With c3k = False, C3k2 behaves like C2f: its inner units are standard bottlenecks. With c3k = True, each inner bottleneck is replaced by a C3k module — a C3-style block whose kernel size is customisable — allowing deeper, more complex feature extraction. In the Ultralytics configuration, the shallow, high-resolution stages run the cheap variant and the deeper stages turn C3k on, spending capacity where the feature maps are small. Under the hood (Ultralytics implementation), C3k2 inherits C2f's "split and keep every intermediate" wiring: a 1×1 conv produces two halves, each inner module's output is appended to the running list, and a final 1×1 conv fuses the concatenation.

At the bottom of the backbone the feature map is small (20×20 for a 640 input) but each cell must reason about objects that may span most of the image. Spatial Pyramid Pooling solves this by max-pooling the same map at several window sizes and concatenating the results, so every position carries summaries of its neighbourhood at multiple scales. YOLOv3 brought an SPP block into the series; YOLO11 retains the fast variant, SPPF, from previous versions.

The "fast" part is a neat identity. The original SPP block pools the input in parallel with 5×5, 9×9 and 13×13 windows. But stride-1 max-pooling composes: pooling a 5×5-pooled map again with a 5×5 window is exactly a 9×9 max-pool, and doing it a third time gives 13×13. So SPPF runs one 5×5 max-pool three times in sequence and concatenates the input with all three intermediate outputs — the same multi-scale features, computed by reusing work instead of re-scanning large windows.

In YOLO11, SPPF is no longer the last word at the bottom of the backbone: its output feeds directly into the new C2PSA block. SPPF supplies fixed, hand-designed multi-scale context; C2PSA then adds learned, content-dependent context through attention.

Convolutions and pooling are local and content-blind: a 5×5 kernel weighs its neighbours the same way regardless of what is in the image. The genuinely new block in YOLO11 is C2PSA, which the paper describes as a Cross Stage Partial block with spatial attention (the abstract expands it as "Convolutional block with Parallel Spatial Attention"). It is inserted immediately after SPPF at the end of the backbone.

Its job, per the paper, is to let the model focus on important regions of the feature map. Attention computes, for every spatial position, a weighted mix of every other position, with weights derived from the content itself — so a cell on a partly occluded object can draw evidence from distant cells on the visible parts. The paper argues this is especially useful for smaller or partially occluded objects, and singles C2PSA out as a key difference from YOLOv8, which has no such mechanism.

Two design choices keep it real-time. First, placement: self-attention costs grow with the square of the number of positions, so the block lives on the coarsest map (20×20 = 400 positions at 640 input) rather than the 80×80 map. Second, the CSP wrapper — in the Ultralytics implementation the input is projected and split in two; only one half passes through the position-sensitive attention (PSA) blocks, each an attention layer followed by a feed-forward layer with residual connections, and the halves are concatenated and fused by a 1×1 conv. Half the channels see attention; the other half carry the SPPF features through untouched.

The head receives three fused maps from the neck and must turn each into concrete predictions. YOLO11 first refines them: multiple C3k2 blocks process the multi-scale features at different depths, followed by CBS layers — a convolution, then batch normalisation, then a SiLU activation.

Each piece of CBS has a distinct role in the paper's description. The convolution extracts the features relevant to detection; batch normalisation stabilises and normalises the data flow, keeping activations in a well-conditioned range so training is stable; and SiLU supplies the non-linearity. SiLU, $z\,\sigma(z)$, is smooth and non-monotonic — unlike ReLU it lets small negative values through, which tends to help deep detectors train.

Finally, each detection branch ends in a set of Conv2D layers that reduce the features to exactly the number of outputs required, and a Detect layer consolidates them. The paper lists three output types: bounding-box coordinates for localisation, objectness scores, and class scores. One caveat worth knowing when you read the Ultralytics code: since YOLOv8 the head is anchor-free and decoupled, with a box-regression branch and a classification branch, and no separate objectness output — the class scores themselves play that role. Every grid cell on every scale makes a prediction, so a 640×640 image yields 8,400 candidate boxes before post-processing.

The broadest change from earlier YOLOs is not a block but a product decision: YOLO11 is a family of task-specific models sharing one backbone and neck design. The paper's Table 2 lists five variants — YOLOv11 (detection), -seg (instance segmentation), -pose (pose/keypoints), -obb (oriented detection) and -cls (classification) — each available in nano, small, medium, large and extra-large sizes, and every one supporting inference, validation, training and export.

The tasks differ only in what the head emits. Detection outputs axis-aligned boxes and classes. Instance segmentation goes to pixel level, separating individual objects — the paper points to medical imaging and manufacturing defect inspection. Pose estimation predicts keypoints for movement tracking in fitness, sports and healthcare. Oriented object detection adds an angle to each box so rotated objects are tightly enclosed — valuable in aerial imagery, robotics and warehouses. Classification assigns one label to the whole image. Object tracking — the sixth capability in Figure 1 — links detections across video frames.

Why is this cheap? Because the expensive part — learning good multi-scale features — is shared. A segmentation or pose model is the same feature extractor with a different final layer, so architectural improvements like C3k2 and C2PSA lift every task at once. And the n-to-x size ladder lets the same design target an edge device or a GPU server.

The paper's evidence is Ultralytics' published benchmark (its reference [23]), reproduced as Figure 2: COCO mAP$^{50-95}$ against latency on a T4 GPU with TensorRT FP16, for YOLOv5 through YOLOv10, PP-YOLOE+ and YOLO11. The authors do not run new experiments, so these are the vendor's numbers — but the comparison is like-for-like on hardware and dataset.

The YOLO11 variants (11n, 11s, 11m, 11l, 11x) form a distinct frontier: at each latency point they reach a higher mAP than earlier versions. The paper highlights YOLO11x at roughly 54.5% mAP$^{50-95}$ and about 13 ms, above every previous YOLO, and YOLO11s at about 47% in the 2–6 ms low-latency regime — accuracy previously reserved for much slower models. YOLO11m reaches accuracy comparable to larger previous-generation models in significantly less time.

The cleanest single number is parameter efficiency: YOLO11m achieves higher COCO mAP than YOLOv8m with 22% fewer parameters. The paper ties this back to the architecture — C3k2's compact CSP design trims parameters, while C2PSA and SPPF improve feature quality. It also notes that the nano model, despite a slight increase in parameters over its predecessor, improves inference speed and FPS. The honest limitation is that no ablation isolates each block: the gains are measured for the whole model, so how much is due to C3k2, C2PSA or training changes is not separated.