Receita de Treinamento YOLO26#
Introdução#
Este guia documenta a receita de training exata usada para produzir os checkpoints pré-treinados oficiais do YOLO26 no COCO. Cada hyperparameter apresentado aqui já está embutido nos pesos lançados de .pt e pode ser inspecionado programaticamente.
Saber o que compôs os checkpoints oficiais — não apenas a arquitetura, mas os agendamentos de learning rate, os pipelines de aumento e os pesos de perda que moldaram o desempenho deles — ajuda-te a tomar melhores decisões durante o fine-tuning: quais data augmentations manter, quais pesos de loss function ajustar e quais configurações de otimizador funcionam melhor para o tamanho do teu conjunto de dados.
Visão Geral do Treinamento#
Todos os modelos base do YOLO26 foram treinados no COCO a uma resolução de 640x640 utilizando o otimizador MuSGD com um batch size de 128. Em vez de começar a partir de pesos aleatórios numa única execução, os modelos foram inicializados a partir de pesos pré-treinados intermediários e refinados com hiperparâmetros encontrados através de evolutionary search. Os registos de treino completos e as métricas para cada tamanho de modelo estão disponíveis na Ultralytics Platform.
Principais escolhas de design em todos os tamanhos:
- Treinamento de ponta a ponta (
end2end=True) com cabeça um para um sem NMS - MuSGD optimizer combinando SGD com atualizações ortogonalizadas estilo Muon para matrizes de peso (pesos lineares 2D e filtros de convolução 4D, que são remodelados para 2D)
- Aumento de mosaico pesado (probabilidade de ~0,9-1,0) desativado nas últimas 10 épocas (
close_mosaic=10) - Aumento de escala agressivo (0.56-0.95) para lidar com objetos em diferentes tamanhos
- Rotação/cisalhamento mínimo para a maioria dos tamanhos, mantendo a distorção geométrica baixa
Inspecionando Argumentos de Treinamento do Checkpoint YOLO26#
Todo checkpoint Ultralytics armazena a configuração de treinamento completa usada para produzi-lo, então você pode verificar cada número nesta página por si mesmo:
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
print(model.ckpt["train_args"])A saída lista a configuração completa de mais de 100 entradas, incluindo cada valor de receita documentado nesta página. Um trecho para yolo26n.pt:
batch: 128
...
box: 5.62767
...
close_mosaic: 10
cls: 0.56099
...
dfl: 9.03871
...
epochs: 245
...
lr0: 0.0054
lrf: 0.04952
...
optimizer: MuSGDIsto funciona para qualquer checkpoint de .pt — lançamentos oficiais e os teus próprios modelos ajustados. Para ver a lista completa de argumentos de treinamento configuráveis, consulta a training configuration reference.
Hiperparâmetros de Treinamento do YOLO26 por Tamanho de Modelo#
As tabelas abaixo agrupam a receita por categoria — otimizador e cronograma, pesos de perda e aumento. Cada valor vem diretamente do train_args embutido nos checkpoints lançados.
Otimizador e Taxa de Aprendizado#
Estas configurações de otimizador e cronograma impulsionaram o pré-treinamento COCO para cada tamanho; note como o modelo N se destaca dos demais:
| Configuração | N | S | M | L | X |
|---|---|---|---|---|---|
optimizer | MuSGD | MuSGD | MuSGD | MuSGD | MuSGD |
lr0 | 0.0054 | 0.00038 | 0.00038 | 0.00038 | 0.00038 |
lrf | 0.0495 | 0.882 | 0.882 | 0.882 | 0.882 |
momentum | 0.947 | 0.948 | 0.948 | 0.948 | 0.948 |
weight_decay | 0.00064 | 0.00027 | 0.00027 | 0.00027 | 0.00027 |
warmup_epochs | 0.98 | 0.99 | 0.99 | 0.99 | 0.99 |
epochs | 245 | 70 | 80 | 60 | 40 |
batch | 128 | 128 | 128 | 128 | 128 |
imgsz | 640 | 640 | 640 | 640 | 640 |
O modelo N usou uma taxa de aprendizado inicial mais alta com decaimento acentuado (lrf=0.0495), enquanto os modelos S/M/L/X usaram uma LR inicial muito menor com um cronograma mais suave (lrf=0.882). Isto reflete as diferentes dinâmicas de convergência de modelos menores versus maiores — modelos menores precisam de atualizações mais agressivas para aprender de forma eficaz.
Pesos de Perda#
Os pesos de perda equilibram os três componentes da perda de detecção — regressão de IoU de bounding box (box), classificação (cls) e um termo de regressão de distância de caixa (dfl). Nota que o YOLO26 sem DFL reutiliza o ganho de dfl para ponderar uma perda L1 em distâncias de caixa normalizadas em vez de perda focal de distribuição:
| Configuração | N | S | M | L | X |
|---|---|---|---|---|---|
box | 5.63 | 9.83 | 9.83 | 9.83 | 9.83 |
cls | 0.56 | 0.65 | 0.65 | 0.65 | 0.65 |
dfl | 9.04 | 0.96 | 0.96 | 0.96 | 0.96 |
O modelo N prioriza o termo de regressão de distância de dfl, enquanto os modelos S/M/L/X deslocam a ênfase para a regressão de caixa baseada em IoU. A perda de classificação permanece relativamente consistente em todos os tamanhos.
Pipeline de Aumento#
Para uma explicação detalhada de cada técnica, consulta o YOLO Data Augmentation guide.
| Configuração | N | S | M | L | X |
|---|---|---|---|---|---|
mosaic | 0.909 | 0.992 | 0.992 | 0.992 | 0.992 |
mixup | 0.012 | 0.05 | 0.427 | 0.427 | 0.427 |
copy_paste | 0.075 | 0.404 | 0.304 | 0.404 | 0.404 |
scale | 0.562 | 0.9 | 0.95 | 0.95 | 0.95 |
fliplr | 0.606 | 0.304 | 0.304 | 0.304 | 0.304 |
degrees | 1.11 | ~0 | ~0 | ~0 | ~0 |
shear | 1.46 | ~0 | ~0 | ~0 | ~0 |
translate | 0.071 | 0.275 | 0.275 | 0.275 | 0.275 |
hsv_h | 0.014 | 0.013 | 0.013 | 0.013 | 0.013 |
hsv_s | 0.645 | 0.353 | 0.353 | 0.353 | 0.353 |
hsv_v | 0.566 | 0.194 | 0.194 | 0.194 | 0.194 |
bgr | 0.106 | 0.0 | 0.0 | 0.0 | 0.0 |
Valores exibidos como ~0 estão abaixo de 0,01 nos checkpoints reais (por exemplo, degrees=0.00012 para o modelo S) — o aumento é efetivamente desativado.
Modelos maiores usam um aumento mais agressivo em geral (mixup, copy-paste e escala mais altos), pois têm maior capacidade e se beneficiam de uma regularization mais forte. O modelo N é o único tamanho com rotação, cisalhamento e aumento BGR significativos.
Parâmetros de Treinamento Internos#
Avançado: parâmetros internos de pipeline
Os checkpoints também contêm parâmetros que foram usados no pipeline de treinamento interno, mas não são expostos como configurações configuráveis pelo usuário em default.yaml:
| Configuração | Descrição | N | S | M | L | X |
|---|---|---|---|---|---|---|
muon_w | Peso de atualização Muon no MuSGD | 0.528 | 0.436 | 0.436 | 0.436 | 0.436 |
sgd_w | Peso de atualização SGD no MuSGD | 0.674 | 0.479 | 0.479 | 0.479 | 0.479 |
cls_w | Peso de classificação interno | 2.74 | 3.48 | 3.48 | 3.48 | 3.48 |
o2m | Peso da perda da head one-to-many | 1.0 | 0.705 | 0.705 | 0.705 | 0.705 |
topk | Atribuição de labels top-k | 8 | 5 | 5 | 5 | 5 |
Consulta a FAQ entry on these parameters para saberes o que significam ao fazer fine-tuning.
Fine-Tuning do YOLO26 no Seu Próprio Dataset#
Ao fazer o fine-tuning do YOLO26 no teu próprio conjunto de dados, não precisas de replicar a receita de pré-treinamento completa. Os pesos pré-treinados já codificam o conhecimento de aumento e otimização do treinamento COCO. Para práticas recomendadas de treinamento mais gerais, consulta Tips for Model Training.
Fine-Tune com Configurações Padrão#
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)O fine-tuning com padrões é uma base sólida. Ajuste hiperparâmetros apenas se tiver um motivo específico para isso.
Quando Ajustar os Hiperparâmetros do YOLO26#
Datasets pequenos (< 1.000 imagens):
- Reduzir a força do aumento:
mosaic=0.5,mixup=0.0,copy_paste=0.0 - Taxa de aprendizado mais baixa:
lr0=0.001 - Usar menos epochs com paciência:
epochs=50,patience=20 - Considerar o congelamento de camadas do backbone:
freeze=10
Datasets grandes (> 50.000 imagens):
- Siga mais de perto a receita de pré-treino
- Considerar
optimizer=MuSGDpara execuções mais longas - Aumentar o aumento:
mosaic=1.0,mixup=0.3,scale=0.9
Imagens específicas de domínio (aéreas, médicas, subaquáticas):
- Aumentar
flipud=0.5se a orientação vertical variar - Aumentar
degreesse os objetos aparecerem em rotações arbitrárias - Ajustar
hsv_sehsv_vse as condições de iluminação diferirem significativamente do COCO
Para otimização automatizada de hiperparâmetros, consulta o Hyperparameter Tuning guide.
Escolha um Tamanho de Modelo#
| Modelo | Melhor para | Orientação sobre Batch Size |
|---|---|---|
| YOLO26n | Dispositivos de borda, mobile, tempo real em CPU | Batches grandes (64-128) em GPUs de consumo |
| YOLO26s | Velocidade e precisão equilibradas | Batches médios (32-64) |
| YOLO26m | Maior precisão com processamento moderado | Batches menores (16-32) |
| YOLO26l | Alta precisão quando a GPU está disponível | Batches pequenos (8-16) ou multi-GPU |
| YOLO26x | Precisão máxima, deploy em servidor | Batches pequenos (4-8) ou multi-GPU |
Para opções de exportação e implantação, consulta o Export guide e as Model Deployment Options.
Conclusão#
Os checkpoints do YOLO26 vêm com a sua receita de treinamento completa embutida, portanto os hiperparâmetros exatos por trás de cada tamanho de modelo estão sempre a uma consulta de train_args de distância. Começa o fine-tuning a partir dos padrões, ajusta deliberadamente usando as tabelas nesta página e verifica cada alteração em relação ao teu próprio conjunto de validação. Se surgirem dúvidas ao longo do caminho, pergunta à comunidade no Ultralytics GitHub repository ou no Ultralytics Discord server.
FAQ#
Carrega o checkpoint com
torch.load()e acede à chavetrain_args, ou usamodel.ckpt["train_args"]com a Ultralytics API. Consulta Inspecting YOLO26 Checkpoint Training Args para exemplos completos.Modelos maiores geralmente precisaram de menos épocas no COCO porque a sua maior capacidade acelera a convergência — o modelo X foi treinado por 40 épocas em comparação com 245 para o N —, embora as contagens não sejam estritamente monotônicas (o S usou 70, o M usou 80). Ao fazer o fine-tuning no teu próprio conjunto de dados, o número ideal de épocas depende do tamanho e da complexidade do teu conjunto de dados, e não do tamanho do modelo. Usa a parada antecipada (
patience) para encontrar o ponto de parada correto automaticamente.Normalmente não precisas de escolher: com o
optimizer=autopadrão, o Ultralytics seleciona automaticamente MuSGD para execuções de treinamento mais longas (>10.000 iterações) e AdamW para as mais curtas. Podes definir explicitamenteoptimizer=MuSGDse preferires. Para mais informações sobre como o MuSGD funciona, consulta a training documentation.Estes são parâmetros internos do pipeline de treinamento que produziu os checkpoints base, gravados em
train_argspara reprodutibilidade. Eles não são configurações configuráveis pelo usuário emdefault.yaml, e passá-los paramodel.train()gera um erro de argumento inválido — o pacote público não os lê. Não precisas de os definir ao fazer o fine-tuning; consulta Internal Training Parameters para ver os seus valores por tamanho de modelo.Não exatamente — os checkpoints foram produzidos usando um branch de treinamento interno com recursos adicionais que não estão na base de código pública (como pesos de
o2mconfiguráveis ecls_w). Podes obter resultados muito próximos usando os hiperparâmetros documentados nesta página com o pacote público do Ultralytics, mas uma reprodução exata requer o branch interno.