Link to this sectionОбъяснение архитектуры YOLO: от YOLOv3 до YOLO26#

Каждая модель Ultralytics YOLO строится из трех этапов: backbone (магистраль), которая извлекает признаки, neck (шея), которая объединяет их на разных масштабах, и head (голова), которая предсказывает границы и классы. В этом руководстве описаны модули, составляющие каждый этап, и то, как они изменились с YOLOv3 до YOLO26, с отслеживанием каждого компонента до его определения в файлах конфигурации в ultralytics/cfg/models/ и классах модулей в ultralytics/nn/modules/.

Каждая модель определяется декларативно в YAML-файле как упорядоченный список слоев, где каждый слой следует формату [from, repeats, module, args]: какие слои подают в него данные, сколько раз повторяется модуль, класс слоя (Conv, C3k2, SPPF, Detect, …) и его аргументы конструктора. Руководство по конфигурации YAML модели документирует этот формат — включая то, как repeats и args масштабируются с глубиной и шириной варианта, — а также систему разрешения модулей в полном объеме. Это руководство сосредоточено на самих модулях и их изменениях от версии к версии.

Link to this sectionТри этапа#

Каждая модель Ultralytics YOLO направляет изображение через три последовательных этапа, каждый из которых выполняет свою задачу:

Фундаментальной единицей является блок Conv (определен в conv.py): 2D-свертка, batch normalization и активация SiLU, применяемые последовательно. Каждый более крупный модуль ниже построен путем комбинирования блоков Conv.

Link to this sectionДиаграммы архитектуры#

Каждая версия сохраняет один и тот же скелет backbone → neck → head и изменяет конкретные этапы. Вкладки ниже показывают структуру по версиям: этапы backbone и neck следуют конфигурациям в ultralytics/cfg/models/, в то время как головы YOLOv3 и YOLOv5 нарисованы в их исходной форме на основе якорей (anchor-based), а не в их anchor-free u-варианте, с которым фактически поставляются их конфигурации пакета. Переключение между вкладками показывает, что добавило каждое поколение. Вкратце, прогресс таков: YOLOv3 — это детектор только на базе FPN с использованием якорей; YOLOv5 добавляет восходящий путь PAN и SPPF; YOLOv8 переключается на блок C2f с головой anchor-free и DFL; YOLO11 вставляет внимание C2PSA и блок C3k2; а YOLO26 добавляет остаточный SPPF и делает голову свободной от NMS и DFL. Цвета узлов следуют условным обозначениям диаграмм документации: зеленый — вход, синий — backbone, серо-синий — пространственное объединение и внимание, оранжевый — neck, фиолетовый — head и выход.

flowchart TD
    IN[Input 640x640]:::start --> ST[Conv stem<br/>5x stride-2 down to P1-P5]:::proc
    ST --> BB[Darknet-53 backbone<br/>stacked Bottleneck]:::proc
    BB --> FPN[Neck FPN only<br/>top-down Upsample + Concat]:::decide
    FPN --> HD[Detect head<br/>3 scales, anchor-based]:::out
    HD --> O[Predictions + NMS]:::out
    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff

На диаграммах YOLOv3 и YOLOv5 показана исходная anchor-based голова. Пакет ultralytics поставляет конфигурации YOLOv3u и YOLOv5u без использования якорей — те же самые backbone Darknet-53 и C3 с головой Detect из YOLOv8, — описанные в разделе Detection Head.

Link to this sectionБлоки Backbone: Bottleneck → C3 → C2f → C3k2#

Backbone содержит повторяющийся блок CSP (Cross-Stage Partial) между слоями понижающей дискретизации Conv с шагом 2. Этот повторяющийся блок — то, что больше всего менялось от версии к версии. Все блоки ниже находятся в block.py; c1/c2 — это входные/выходные каналы, а c = 0.5 * c2 — скрытая ширина.

Link to this sectionBottleneck (YOLOv3)#

Базовый элемент — Bottleneck: два слоя Conv (по умолчанию ядра (3, 3)) с опциональным добавлением остатка (residual), когда shortcut=True и c1 == c2. Backbone Darknet-53 в YOLOv3 укладывает их напрямую без разделения CSP и обнаруживает на трех масштабах (шаг 8, 16, 32).

Link to this sectionC3 (YOLOv5)#

YOLOv5's C3 splits the input across two 1x1 convolutions: cv1 feeds n sequential Bottleneck blocks (kernels (1, 1) then (3, 3)), cv2 bypasses them. The two paths are concatenated and fused by a third 1x1 Conv:

def forward(self, x):
    # C3: bottleneck path m(cv1(x)) concatenated with bypass cv2(x), then fused by cv3
    return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))

Только итоговый выход bottleneck достигает свертки слияния, поэтому cv3 видит 2 карты признаков.

Link to this sectionC2f (YOLOv8)#

YOLOv8's C2f ("CSP Bottleneck with 2 convolutions, faster") changes which features reach the fusion conv:

1. cv1 = Conv(c1, 2 * c, 1), затем chunk(2) разделяет выход на два тензора с каналами c.
2. n блоков Bottleneck(c, c) (ядра (3, 3), (3, 3)) работают последовательно, каждый питается выходом предыдущего блока.
3. Все n + 2 промежуточных тензора конкатенируются и объединяются с помощью cv2 = Conv((2 + n) * c, c2, 1).

Там, где C3 передает 2 карты признаков в свою свертку слияния, C2f передает n + 2 — каждый промежуточный выход bottleneck повторно используется.

Link to this sectionC3k2 (YOLO11 и YOLO26)#

YOLO11 и YOLO26 используют C3k2, подкласс C2f, который заменяет повторяющийся блок. Каждый из n блоков становится, в зависимости от флагов конструктора:

• обычным Bottleneck (по умолчанию, c3k=False),
• блоком C3k (c3k=True) — вариантом C3 с настраиваемым размером ядра, или
• парой Bottleneck + PSABlock (attn=True).

Второй YAML-аргумент устанавливает c3k; например, [-1, 2, C3k2, [512, True]] создает один модуль C3k2 на 512 выходных каналов, внутренние блоки которого являются C3k (так как c3k=True). Для модулей CSP поле repeats — здесь 2, до того как оно масштабируется множителем глубины варианта — становится внутренним числом повторений блока вместо стекирования отдельных модулей.

Link to this sectionПространственное объединение: SPP → SPPF#

В конце backbone блок пространственно-пирамидального объединения расширяет рецептивное поле. В YOLOv5 исходный многоядерный SPP был заменен на SPPF (Spatial Pyramid Pooling - Fast): один MaxPool2d(kernel_size=5, stride=1, padding=2), примененный n = 3 раза последовательно, причем вход и все три выхода объединяются и сливаются 1x1 Conv. Это математически эквивалентно SPP(k=(5, 9, 13)), но дешевле, так как цепочка из пулов 5x5 покрывает рецептивные поля больших ядер.

YOLO26 передает флаг shortcut (SPPF, [1024, 5, 3, True]); поскольку c1 == c2 == 1024 на самом глубоком слое, SPPF добавляет остаточное соединение (return y + x).

Link to this sectionПространственное внимание: C2PSA (YOLO11+)#

YOLO11 добавил C2PSA после SPPF. Это CSP-блок, активная ветвь которого представляет собой стек из n модулей PSABlock (внимание с учетом позиции): cv1 = Conv(c1, 2 * c, 1) разделяет признаки, одна половина проходит через стек PSABlock, а cv2 = Conv(2 * c, c1, 1) объединяет конкатенацию. Каждый PSABlock применяет многоголовое внимание, за которым следует двухслойная полносвязная сеть (Conv(c, 2 * c, 1) → Conv(2 * c, c, 1)), каждая с остаточным соединением. YOLO26 сохраняет тот же backbone C3k2 + C2PSA.

Link to this sectionNeck: FPN + PAN#

Neck объединяет карты признаков P3/P4/P5 от backbone с помощью нисходящей Feature Pyramid Network (FPN), за которой следует восходящая Path Aggregation Network (PAN). В разделе YAML-головы FPN — это nn.Upsample + Concat (перенос семантической информации вниз к более высоким разрешениям), а PAN — это Conv с шагом 2 + Concat (перенос информации о локализации обратно вверх):

# YOLO11 head (FPN top-down, then PAN bottom-up)
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
- [-1, 2, C3k2, [512, False]] # 13
# ... second upsample + concat to P3 ...
- [-1, 1, Conv, [256, 3, 2]]
- [[-1, 13], 1, Concat, [1]] # cat head P4 (PAN)
- [-1, 2, C3k2, [512, False]] # 19

Neck повторно использует блок backbone своего поколения — C3 в YOLOv5, C2f в YOLOv8, C3k2 в YOLO11 и YOLO26, — поэтому каждая точка слияния запускает тот же модуль, который использует backbone. Три объединенных выхода питают голову. YOLOv3 — исключение: его neck — это только нисходящий FPN (в его YAML-голове нет понижающей дискретизации с шагом 2) без восходящего пути PAN, который появился в YOLOv5.

Link to this sectionDetection Head: Anchor-Based → Anchor-Free → NMS-Free#

Голова превращает три объединенных карты признаков в предсказания для задачи обнаружения. Ее дизайн менялся от версии к версии: от anchor-based к anchor-free и к NMS-free.

Link to this sectionAnchor-free, decoupled Detect#

В исходных YOLOv3 и YOLOv5 использовалась anchor-based, связанная голова: заранее определенные рамки привязки (якоря) и общая ветвь для предсказания рамок и классов. Автономные репозитории ultralytics/yolov3 и ultralytics/yolov5 сохраняют этот anchor-based дизайн. Основной пакет ultralytics вместо этого поставляет anchor-free варианты YOLOv3u и YOLOv5u — те же самые backbone Darknet-53 и C3 с головой Detect из YOLOv8, — а конфигурации yolov3.yaml и yolov5.yaml, документированные здесь, являются этими u-вариантами, а не историческим дизайном.

Голова Detect (head.py) является anchor-free и разделенной: для каждого уровня пирамиды она запускает две параллельные ветви и предсказывает непосредственно по точкам сетки, а не по рамкам привязки.

• Ветвь границ (cv2): Conv(x, c2, 3) → Conv(c2, c2, 3) → Conv2d(c2, 4 * reg_max, 1).
• Ветвь классов (cv3): в YOLO11 и YOLO26 — два блока с разделением по глубине (DWConv + 1x1 Conv) → Conv2d(c3, nc, 1); YOLOv8 использует устаревший вариант, два слоя 3x3 Conv → Conv2d(c3, nc, 1).

Каждая точка привязки поэтому выдает no = nc + 4 * reg_max выходов. Удаление заранее определенных якорей избавляет от гиперпараметров размеров и соотношений сторон якорных рамок, которые приходилось настраивать.

Link to this sectionDistribution Focal Loss (DFL)#

YOLOv8 и YOLO11 регрессируют каждую из 4 координат рамки как распределение по reg_max = 16 корзинам (бин) вместо одного скаляра (интегральная форма из Generalized Focal Loss). Модуль DFL изменяет размер каналов рамки 4 * reg_max на (4, reg_max), применяет softmax по reg_max корзинам и берет ожидаемый индекс корзины — индекс каждой корзины, взвешенный ее вероятностью softmax, а затем суммированный — как предсказанную координату. Это реализовано как фиксированная свертка 1x1, весами которой являются индексы корзин arange(reg_max), поэтому взвешенная сумма является единственным скалярным произведением.

Link to this sectionYOLO26: NMS-free, DFL-free#

YOLO26 устанавливает два YAML-параметра, которые считывает голова:

• end2end: True — Detect делает глубокую копию своих ветвей в голову один-к-одному (one2one_cv2/one2one_cv3), которая выдает одно предсказание на объект, устраняя шаг постобработки Non-Maximum Suppression (NMS). См. руководство по сквозному обнаружению для получения подробностей об экспорте и миграции.
• reg_max: 1 — с одной корзиной self.dfl становится nn.Identity(), а no = nc + 4; голова регрессирует координаты напрямую, и никакая операция DFL не появляется в экспортированном графе ONNX.

Во всех своих пяти размерах (n/s/m/l/x) YOLO26 достигает 40.9-57.5 mAP на COCO при задержке 1.7-11.8 мс на TensorRT T4, как сообщается в статье о YOLO26.

Link to this sectionСводка по версиям#

Подробности по моделям, таблицы производительности и примеры использования см. на отдельных страницах для YOLOv3, YOLOv5, YOLOv8, YOLO11 и YOLO26.

Link to this sectionИзучите архитектуру самостоятельно#

Метод model.info() выводит сводку по слоям, параметрам и FLOPs, а разобранный список модулей доступен в model.model.model.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo11n.pt")

# Fuse Conv + BatchNorm layers so counts match the published specs
model.fuse()

# Print a summary: layers, parameters, gradients, GFLOPs
model.info()

# Inspect the detection head (the last module in the network)
head = model.model.model[-1]
print(type(head).__name__, "| reg_max:", head.reg_max, "| end2end:", head.end2end)

Запуск этого фрагмента кода для трех поколений численно показывает изменения. Это реальные выходы fused-моделей из пакета ultralytics, соответствующие количеству параметров и FLOPs, опубликованным на каждой странице модели:

YOLO26n сообщает reg_max=1, end2end=True и слой DFL Identity — архитектурная подпись его NMS-free, DFL-free головы.

Link to this sectionЗаключение#

От версии к версии архитектура YOLO менялась поэтапно: backbone изменился с Darknet-53 на CSP-блоки C3, C2f и C3k2 с вниманием C2PSA; neck сохранил структуру FPN + PAN, а SPP стал SPPF; head изменился с anchor-based на anchor-free, а затем к end-to-end дизайну YOLO26 без NMS и DFL.

Чтобы определить пользовательские архитектуры, ознакомься с Руководством по конфигурации YAML модели или сравни модели на страницах моделей. Если возникнут вопросы, обращайся на GitHub или в Discord.

Link to this sectionFAQ#

Link to this sectionКаковы три стадии архитектуры YOLO?#

Модель YOLO имеет backbone, который извлекает признаки из изображения с шагами 8, 16 и 32, neck, который объединяет эти признаки по масштабам с помощью FPN и PAN, и head, который предсказывает ограничивающие рамки (bounding boxes) и оценки классов. Каждая модель Ultralytics YOLO от YOLOv3 до YOLO26 следует этому трехстадийному дизайну.

Link to this sectionВ чем разница между блоками C2f и C3k2?#

C2f (YOLOv8) — это CSP-блок, который конкатенирует выходы каждого внутреннего Bottleneck — n + 2 карт признаков — перед своей сверткой слияния, тогда как более старый C3 передает только 2. C3k2 (YOLO11 и YOLO26) — это подкласс C2f, который может заменять каждый Bottleneck на блок C3k (вариант C3 с настраиваемым размером ядра), когда установлен флаг c3k. Оба определены в block.py.

Link to this sectionЧто изменилось в архитектуре между YOLOv8 и YOLO11?#

YOLO11 вносит три структурных изменения в YOLOv8: он заменяет блок C2f в backbone и neck на C3k2, добавляет блок селф-аттеншн C2PSA после SPPF и переключает ветку классификации head на более легкие depthwise-separable свертки. Обе модели сохраняют тот же anchor-free, развязанный (decoupled) head Detect с регрессией DFL reg_max=16, поэтому изменения снижают количество параметров и FLOPs, повышая точность, а не переделывая интерфейс обнаружения.

Link to this sectionЯвляется ли YOLO anchor-free?#

Современные модели Ultralytics YOLO — это anchor-free. YOLOv8, YOLO11 и YOLO26 используют anchor-free, развязанный head Detect с отдельными ветками для регрессии рамок и классификации. Оригинальные YOLOv3 и YOLOv5 были anchor-based, но Ultralytics поставляет их как варианты YOLOv3u и YOLOv5u, конфигурации которых используют тот же anchor-free head, что и YOLOv8.

Link to this sectionУбрала ли YOLO26 NMS?#

Да — YOLO26 устанавливает end2end=True, что дает Detect head типа "один к одному", который создает одно предсказание на объект и удаляет шаг пост-обработки Non-Maximum Suppression, требовавшийся в более ранних моделях. Подробности см. в руководстве по End-to-End обнаружению.

Link to this sectionЧто такое Distribution Focal Loss (DFL) и почему YOLO26 его убрала?#

DFL регрессирует каждую координату рамки как softmax-распределение по reg_max ячейкам (по умолчанию 16 в YOLOv8 и YOLO11) и берет ожидаемое значение в качестве координаты, вместо предсказания одного скаляра. YOLO26 устанавливает reg_max=1, поэтому слой DFL становится операцией идентичности, head регрессирует координаты напрямую, и никакой операции DFL не появляется в экспортируемых графах ONNX или TensorRT.

Link to this sectionКак я могу увидеть архитектуру конкретной модели YOLO?#

Загрузи модель в Python и вызови model.info() для получения сводки по слоям, параметрам и GFLOPs. Разобранные слои находятся в model.model.model — например, model.model.model[-1] — это head Detect, раскрывающий атрибуты вроде reg_max и end2end. Полная архитектура определена в YAML-файле конфигурации модели.