Explicação da arquitetura YOLO: do YOLOv3 ao YOLO26#

Cada modelo do Ultralytics YOLO é construído a partir de três estágios: uma backbone que extrai características, uma neck que as funde em várias escalas e uma head que prediz caixas e classes. Este guia documenta os módulos que compõem cada estágio e como eles mudaram do YOLOv3 para o YOLO26, rastreando cada componente até sua definição nos arquivos de configuração em ultralytics/cfg/models/ e nas classes de módulos em ultralytics/nn/modules/.

Cada modelo é definido declarativamente em um arquivo YAML como uma lista ordenada de camadas, onde cada camada segue o formato [from, repeats, module, args]: qual(is) camada(s) a alimentam, quantas vezes o módulo se repete, a classe da camada (Conv, C3k2, SPPF, Detect, …) e seus argumentos de construtor. O Guia de Configuração YAML do Modelo documenta este formato — incluindo como repeats e args escalam com os múltiplos de profundidade e largura da variante — juntamente com o sistema de resolução de módulos por completo. Este guia foca nos módulos em si e em como eles mudaram de versão para versão.

Os Três Estágios#

Todo modelo Ultralytics YOLO roteia a imagem através de três estágios sequenciais, cada um com uma função distinta:

A unidade fundamental é o bloco Conv (definido em conv.py): uma convolução 2D, normalização em lote e uma ativação SiLU, aplicadas em sequência. Cada módulo maior abaixo é construído compondo blocos Conv.

Diagramas de Arquitetura#

Cada versão mantém o mesmo esqueleto backbone → neck → head e altera estágios específicos. As abas abaixo mostram a estrutura por versão: os estágios de backbone e neck seguem as configurações em ultralytics/cfg/models/, enquanto as heads do YOLOv3 e YOLOv5 são desenhadas em sua forma original baseada em âncoras, em vez da head variante sem âncoras u que as configurações do pacote realmente trazem. Passar pelas abas mostra o que cada geração adicionou. Em suma, a progressão é: o YOLOv3 é um detector baseado em âncoras apenas com FPN; o YOLOv5 adiciona o caminho PAN de baixo para cima e o SPPF; o YOLOv8 muda para o bloco C2f com uma head sem âncoras e baseada em DFL; o YOLO11 insere a atenção C2PSA e o bloco C3k2; e o YOLO26 adiciona um resíduo SPPF e torna a head livre de NMS e livre de DFL. As cores dos nós seguem a convenção de diagramas da documentação: entrada em verde, backbone em azul, pooling espacial e atenção em azul-acinzentado, neck em laranja, head e saída em roxo.

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

Os diagramas do YOLOv3 e YOLOv5 mostram a head original baseada em âncoras. O pacote ultralytics fornece as configurações sem âncoras YOLOv3u e YOLOv5u — os mesmos backbones Darknet-53 e C3 com a head Detect do YOLOv8 — descritos em Detection Head.

Blocos de Backbone: Bottleneck → C3 → C2f → C3k2#

O backbone empilha um bloco CSP (Cross-Stage Partial) repetitivo entre camadas de subamostragem Conv com stride 2. Esse bloco repetitivo foi o que mais mudou entre as versões. Todos os blocos abaixo estão em block.py; c1/c2 são os canais de entrada/saída e c = 0.5 * c2 é a largura oculta.

Bottleneck (YOLOv3)#

A unidade base é Bottleneck: duas camadas Conv (kernels padrão (3, 3)) com uma adição residual opcional quando shortcut=True e c1 == c2. O backbone Darknet-53 do YOLOv3 empilha estes diretamente, sem divisão CSP, e detecta em três escalas (strides 8, 16, 32).

C3 (YOLOv5)#

O C3 do YOLOv5 divide a entrada em duas convoluções 1x1: o cv1 alimenta blocos Bottleneck sequenciais do n (núcleos (1, 1) e depois (3, 3)), enquanto o cv2 os contorna. Os dois caminhos são concatenados e fundidos por um terceiro 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))

Apenas a saída do gargalo (final) chega à convolução de fusão, então cv3 vê 2 mapas de características.

C2f (YOLOv8)#

O C2f ("CSP Bottleneck with 2 convolutions, faster") do YOLOv8 altera quais características chegam à convolução de fusão:

1. cv1 = Conv(c1, 2 * c, 1), então chunk(2) divide a saída em dois tensores de canais c.
2. Os blocos n Bottleneck(c, c) (kernels (3, 3), (3, 3)) rodam sequencialmente, sendo cada um alimentado pela saída do bloco anterior.
3. Todos os tensores intermediários de n + 2 são concatenados e fundidos por cv2 = Conv((2 + n) * c, c2, 1).

Onde C3 passa 2 mapas de características para sua convolução de fusão, C2f passa n + 2 — cada saída de gargalo intermediária é reutilizada.

C3k2 (YOLO11 e YOLO26)#

YOLO11 e YOLO26 usam C3k2, uma subclasse de C2f que troca a unidade repetitiva. Cada um dos blocos n torna-se, dependendo das flags do construtor:

• um Bottleneck simples (padrão, c3k=False),
• um bloco C3k (c3k=True) — uma variante de C3 com um tamanho de kernel configurável, ou
• um par Bottleneck + PSABlock (attn=True).

O segundo argumento do YAML define c3k; por exemplo, [-1, 2, C3k2, [512, True]] constrói um módulo C3k2 com 512 canais de saída cujos blocos internos são C3k (já que c3k=True). Para módulos CSP, o campo repeats — aqui 2, antes de ser escalado pelo múltiplo de profundidade da variante — torna-se a contagem de repetições interna do bloco em vez de empilhar módulos separados.

Pooling Espacial: SPP → SPPF#

No final do backbone, um bloco de pooling de pirâmide espacial amplia o campo receptivo. O YOLOv5 substituiu o SPP multi-kernel original por SPPF (Spatial Pyramid Pooling - Fast): um único MaxPool2d(kernel_size=5, stride=1, padding=2) aplicado n = 3 vezes em sequência, com a entrada e todas as três saídas de pooling concatenadas e fundidas por um 1x1 Conv. Isso é matematicamente equivalente ao SPP(k=(5, 9, 13)), mas mais barato, porque os pools em cadeia de 5x5 cobrem os campos receptivos de kernels maiores.

YOLO26 passa uma flag de atalho (SPPF, [1024, 5, 3, True]); como c1 == c2 == 1024 está na camada mais profunda, SPPF adiciona uma conexão residual (return y + x).

Atenção Espacial: C2PSA (YOLO11+)#

O YOLO11 adicionou C2PSA após o SPPF. É um bloco CSP cujo ramo ativo é uma pilha de módulos n PSABlock (Position-Sensitive Attention): cv1 = Conv(c1, 2 * c, 1) divide as características, metade passa pela pilha PSABlock, e cv2 = Conv(2 * c, c1, 1) funde a concatenação. Cada PSABlock aplica atenção multi-head seguida por uma rede feed-forward de duas camadas (Conv(c, 2 * c, 1) → Conv(2 * c, c, 1)), cada uma com uma conexão residual. O YOLO26 mantém o mesmo backbone C3k2 + C2PSA.

Neck: FPN + PAN#

O neck funde os mapas de características P3/P4/P5 do backbone com uma Feature Pyramid Network (FPN) de cima para baixo, seguida por uma Path Aggregation Network (PAN) de baixo para cima. Na seção de head do YAML, a FPN é nn.Upsample + Concat (carregando informações semânticas para resoluções mais altas) e a PAN é Conv + Concat com stride 2 (carregando informações de localização de volta para cima):

# 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

O neck reutiliza o bloco de backbone de sua geração — C3 no YOLOv5, C2f no YOLOv8, C3k2 no YOLO11 e YOLO26 — de modo que cada ponto de junção executa o mesmo módulo que o backbone usa. As três saídas fundidas alimentam a head. O YOLOv3 é a exceção: seu neck é apenas FPN de cima para baixo (sua head no YAML não possui subamostragem com stride 2), sem o caminho PAN de baixo para cima que o YOLOv5 introduziu.

Detection Head: Baseado em Âncora → Sem Âncora → Livre de NMS#

A head transforma os três mapas de características fundidos em predições para a tarefa de detecção. Seu design mudou entre as versões, de baseado em âncoras para sem âncoras e para livre de NMS.

Sem âncoras, Detect desacoplada#

O YOLOv3 e o YOLOv5 originais usavam uma head acoplada e baseada em âncoras: caixas de ancoragem predefinidas e um ramo compartilhado para predições de caixas e classes. Os repositórios independentes ultralytics/yolov3 e ultralytics/yolov5 mantêm esse design baseado em âncoras. Em vez disso, o pacote principal ultralytics fornece as variantes YOLOv3u e YOLOv5u sem âncoras — os mesmos backbones Darknet-53 e C3 com a head Detect sem âncoras do YOLOv8 — e as configurações yolov3.yaml e yolov5.yaml documentadas aqui são essas variantes u, e não o design histórico.

A head Detect (head.py) não tem âncoras e é desacoplada: por nível de pirâmide, ela executa dois ramos paralelos e prediz diretamente nos pontos da grade, em vez de usar caixas de ancoragem.

• Ramo de caixas (cv2): Conv(x, c2, 3) → Conv(c2, c2, 3) → Conv2d(c2, 4 * reg_max, 1).
• Ramo de classes (cv3): no YOLO11 e YOLO26, dois blocos separáveis em profundidade (DWConv + 1x1 Conv) → Conv2d(c3, nc, 1); o YOLOv8 usa a variante legada, duas camadas 3x3 Conv → Conv2d(c3, nc, 1).

Portanto, cada ponto de ancoragem emite saídas no = nc + 4 * reg_max. Remover as âncoras predefinidas elimina os tamanhos de caixas de ancoragem e proporções (aspect ratios) dos hiperparâmetros que precisam ser ajustados.

Distribution Focal Loss (DFL)#

O YOLOv8 e o YOLO11 regridem cada uma das 4 coordenadas da caixa como uma distribuição sobre bins de reg_max = 16 em vez de um único escalar (a forma integral do Generalized Focal Loss). O módulo DFL remodela os canais da caixa de 4 * reg_max para (4, reg_max), aplica um softmax sobre os bins de reg_max e toma o índice do bin esperado — cada índice de bin ponderado por sua probabilidade softmax, e então somado — como a coordenada predita. Isso é implementado como uma convolução fixa 1x1 cujos pesos são os índices dos bins arange(reg_max), de modo que a soma ponderada é um único produto escalar.

YOLO26: Livre de NMS, Livre de DFL#

YOLO26 define dois parâmetros YAML que a head lê diretamente:

• end2end: True — Detect copia profundamente seus ramos para uma head de um para um (one2one_cv2/one2one_cv3) que produz uma única predição por objeto, removendo a etapa de pós-processamento de Non-Maximum Suppression (NMS). Consulte o guia de Detecção de Ponta a Ponta (End-to-End) para detalhes de exportação e migração.
• reg_max: 1 — com um bin, self.dfl torna-se nn.Identity() e no = nc + 4; a head regride as coordenadas diretamente e nenhuma operação DFL aparece no gráfico ONNX exportado.

Em seus cinco tamanhos de modelo (n/s/m/l/x), o YOLO26 alcança 40,9-57,5 mAP no COCO com latência T4 TensorRT de 1,7-11,8 ms, conforme relatado no artigo do YOLO26.

Resumo Versão por Versão#

Para detalhes por modelo, tabelas de desempenho e exemplos de uso, consulte as páginas individuais para YOLOv3, YOLOv5, YOLOv8, YOLO11 e YOLO26.

Inspecione a Arquitetura Você Mesmo#

O método model.info() imprime um resumo de camadas, parâmetros e FLOPs, e a lista de módulos analisados está disponível em 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)

Executar o trecho ao longo de três gerações mostra as mudanças numericamente. Estas são saídas reais de modelos fundidos do pacote ultralytics, correspondendo às contagens de parâmetros e FLOPs publicadas em cada página do modelo:

O YOLO26n reporta reg_max=1, end2end=True e uma camada DFL Identity — a assinatura arquitetônica de sua head livre de NMS e de DFL.

Conclusão#

Entre as versões, a arquitetura YOLO mudou um estágio de cada vez: o backbone passou de Darknet-53 para blocos C3, C2f e C3k2 baseados em CSP com atenção C2PSA; o neck manteve sua estrutura FPN + PAN enquanto SPP se tornou SPPF; e a head passou de baseada em âncoras para sem âncoras, e depois para o design de ponta a ponta livre de NMS e livre de DFL do YOLO26.

Para definir arquiteturas personalizadas, consulte o Guia de Configuração YAML do Modelo ou compare modelos nas páginas de modelos. Em caso de dúvidas, entre em contato no GitHub ou Discord.

FAQ#