Receita de Treinamento do YOLO26
Introdução
Este guia documenta a receita exata de treinamento usada para produzir os checkpoints pré-treinados oficiais do YOLO26 no COCO. Cada hiperparâmetro aqui exibido já está incorporado nos pesos .pt lançados e pode ser inspecionado programaticamente.
Compreender como os modelos base foram treinados ajuda você a tomar decisões melhores durante o fine-tuning: quais aumentações de dados manter, quais pesos da função de perda ajustar e quais configurações de otimizador funcionam melhor para o tamanho do seu conjunto de dados.
Este guia é para profissionais que desejam entender o que compôs os checkpoints oficiais do YOLO26 — não apenas a arquitetura, mas os cronogramas de taxa de aprendizado, pipelines de aumentação e pesos de perda que moldaram seu desempenho. Use essas informações para fazer escolhas informadas ao realizar o fine-tuning nos seus próprios dados.
Inspecionando Argumentos de Treinamento
Cada checkpoint da Ultralytics armazena a configuração de treinamento completa usada para produzi-lo. Você pode inspecionar essas configurações a qualquer momento:
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
print(model.ckpt["train_args"])Isso funciona para qualquer checkpoint .pt — tanto para lançamentos oficiais quanto para seus próprios modelos fine-tuned. Para a lista completa de argumentos de treinamento configuráveis, veja a referência de configuração de treinamento.
Visão Geral do Treinamento
Todos os modelos base YOLO26 foram treinados no COCO com resolução 640x640 usando o otimizador MuSGD com tamanho de lote (batch size) 128. Os modelos foram inicializados a partir de pesos pré-treinados intermediários e refinados com hiperparâmetros encontrados via busca evolucionária. Logs completos de treinamento e métricas para cada tamanho de modelo estão disponíveis na Plataforma Ultralytics:
Principais escolhas de design em todos os tamanhos:
- Treinamento ponta a ponta (
end2end=True) com cabeça um-para-um sem NMS - Otimizador MuSGD combinando SGD com atualizações ortogonalizadas estilo Muon para pesos de convolução
- Aumentação mosaic pesada (probabilidade ~0.9-1.0) desativada nos últimos 10 epochs (
close_mosaic=10) - Aumentação de escala agressiva (0.56-0.95) para lidar com objetos em diferentes tamanhos
- Rotação/cisalhamento mínimos para a maioria dos tamanhos, mantendo a distorção geométrica baixa
Hiperparâmetros por Tamanho de Modelo
Otimizador e Taxa de Aprendizado
| 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). Isso reflete as diferentes dinâmicas de convergência de modelos menores versus maiores — modelos menores precisam de atualizações mais agressivas para aprender efetivamente.
Pesos de Perda
| 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 a perda DFL, enquanto os modelos S/M/L/X deslocam a ênfase para a regressão de bounding box. A perda de classificação permanece relativamente consistente em todos os tamanhos.
Pipeline de Aumentação
Para uma explicação detalhada de cada técnica, veja o guia de Aumentação de Dados YOLO.
| 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 |
Modelos maiores usam uma aumentação mais agressiva no geral (maior mixup, copy-paste e scale), já que possuem mais capacidade e se beneficiam de uma regularização mais forte. O modelo N é o único tamanho com aumentação significativa de rotação, cisalhamento e BGR.
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 no 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 interna | 2.74 | 3.48 | 3.48 | 3.48 | 3.48 |
o2m | Peso da perda do cabeçote um-para-muitos | 1.0 | 0.705 | 0.705 | 0.705 | 0.705 |
topk | Atribuição de rótulo Top-k | 8 | 5 | 5 | 5 | 5 |
Estes são registrados para reprodutibilidade, mas não precisam ser definidos ao realizar o ajuste fino. Veja o FAQ para mais detalhes.
Orientação para Ajuste Fino
Ao realizar o ajuste fino do YOLO26 em seu próprio conjunto de dados, você não precisa replicar a receita completa de pré-treinamento. Os pesos pré-treinados já codificam o conhecimento de aumento e otimização do treinamento no COCO. Para práticas recomendadas de treinamento mais gerais, veja Dicas para Treinamento de Modelos.
Comece Simples
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)Realizar o ajuste fino com os valores padrão é uma base sólida. Ajuste os hiperparâmetros apenas se tiver um motivo específico para isso.
Quando Ajustar
Conjuntos de dados pequenos (< 1.000 imagens):
- Reduza a intensidade do aumento:
mosaic=0.5,mixup=0.0,copy_paste=0.0 - Reduza a taxa de aprendizagem:
lr0=0.001 - Use menos épocas com patience:
epochs=50,patience=20 - Considere congelar as camadas da backbone:
freeze=10
Conjuntos de dados grandes (> 50.000 imagens):
- Siga mais rigorosamente a receita de pré-treinamento
- Considere
optimizer=MuSGDpara execuções mais longas - Aumente o aumento:
mosaic=1.0,mixup=0.3,scale=0.9
Imagens específicas de domínio (aéreas, médicas, subaquáticas):
- Aumente
flipud=0.5se a orientação vertical variar - Aumente
degreesse os objetos aparecerem em rotações arbitrárias - Ajuste
hsv_sehsv_vse as condições de iluminação diferirem significativamente do COCO
Para otimização automatizada de hiperparâmetros, veja o guia de Ajuste de Hiperparâmetros.
Escolhendo um tamanho de modelo
| Modelo | Ideal Para | Orientação sobre o Tamanho do Lote (Batch Size) |
|---|---|---|
| YOLO26n | Dispositivos de borda, móveis, tempo real na CPU | Lotes grandes (64-128) em GPUs de consumo |
| YOLO26s | Velocidade e precisão equilibradas | Lotes médios (32-64) |
| YOLO26m | Maior precisão com processamento moderado | Lotes menores (16-32) |
| YOLO26l | Alta precisão quando a GPU está disponível | Lotes pequenos (8-16) ou multi-GPU |
| YOLO26x | Precisão máxima, implantação em servidor | Lotes pequenos (4-8) ou multi-GPU |
Para opções de exportação e implantação, veja o guia de Exportação e as Opções de Implantação de Modelo.
FAQ
Como vejo os hiperparâmetros exatos usados para qualquer checkpoint?
Carregue o checkpoint com torch.load() e acesse a chave train_args, ou use model.ckpt["train_args"] com a API da Ultralytics. Veja Inspeção de Argumentos de Treinamento para exemplos completos.
Por que as contagens de épocas são diferentes para cada tamanho de modelo?
Modelos maiores convergem mais rápido no COCO porque têm mais capacidade. O modelo N precisou de 245 épocas, enquanto o modelo X precisou de apenas 40. Ao realizar o ajuste fino em seu próprio conjunto de dados, o número ideal de épocas depende do tamanho e complexidade do seu conjunto de dados, não do tamanho do modelo. Use a parada antecipada (patience) para encontrar o ponto de parada correto automaticamente.
Devo usar MuSGD para ajuste fino?
Quando optimizer=auto (o padrão), a Ultralytics seleciona automaticamente MuSGD para execuções de treinamento mais longas (>10.000 iterações) e AdamW para as mais curtas. Você pode definir explicitamente optimizer=MuSGD se preferir. Para mais informações sobre a seleção de otimizador, veja a documentação de treinamento.
O que são muon_w, sgd_w, cls_w, o2m e topk no checkpoint?
Estes são parâmetros internos do pipeline de treinamento que produziu os checkpoints base. Eles são armazenados para reprodutibilidade, mas não são configurações configuráveis pelo usuário em default.yaml. Você não precisa defini-los ao realizar o ajuste fino. Veja Parâmetros de Treinamento Internos para detalhes.
Posso replicar o pré-treinamento exato do zero?
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 o2m configuráveis e cls_w). Você pode obter resultados muito próximos usando os hiperparâmetros documentados nesta página com o pacote público da Ultralytics, mas uma reprodução exata requer o branch interno.