YOLO26 Training Recipe

Introduction

This guide documents the exact training recipe used to produce the official YOLO26 pretrained checkpoints on COCO. Every hyperparameter shown here is already embedded in the released .pt weights and can be inspected programmatically.

Understanding how the base models were trained helps you make better decisions when fine-tuning: which data augmentations to keep, which loss function weights to adjust, and what optimizer settings work best for your dataset size.

Inspecting Training Args

Every Ultralytics checkpoint stores the full training configuration used to produce it. You can inspect these settings at any time:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
print(model.ckpt["train_args"])

import torch

# Load any official checkpoint
ckpt = torch.load("yolo26n.pt", map_location="cpu", weights_only=False)

# Print all training arguments
for k, v in sorted(ckpt["train_args"].items()):
    print(f"{k}: {v}")

This works for any .pt checkpoint — official releases and your own fine-tuned models alike. For the full list of configurable training arguments, see the training configuration reference.

Training Overview

All YOLO26 base models were trained on COCO at 640x640 resolution using the MuSGD optimizer with batch size 128. Models were initialized from intermediate pretrained weights and refined with hyperparameters found via evolutionary search. Full training logs and metrics for every model size are available on Ultralytics Platform:

Key design choices across all sizes:

• End-to-end training (end2end=True) with NMS-free one-to-one head
• MuSGD optimizer combining SGD with Muon-style orthogonalized updates for conv weights
• Heavy mosaic augmentation (~0.9-1.0 probability) disabled in the last 10 epochs (close_mosaic=10)
• Aggressive scale augmentation (0.56-0.95) to handle objects at different sizes
• Minimal rotation/shear for most sizes, keeping geometric distortion low

Hyperparameters per Model Size

Optimizer and Learning Rate

Loss Weights

The N model prioritizes DFL loss, while S/M/L/X models shift emphasis to bounding box regression. Classification loss remains relatively consistent across all sizes.

Augmentation Pipeline

For a detailed explanation of each technique, see the YOLO Data Augmentation guide.

Larger models use more aggressive augmentation overall (higher mixup, copy-paste, and scale), since they have more capacity and benefit from stronger regularization. The N model is the only size with meaningful rotation, shear, and BGR augmentation.

Internal Training Parameters

Fine-Tuning Guidance

When fine-tuning YOLO26 on your own dataset, you don't need to replicate the full pretraining recipe. The pretrained weights already encode the augmentation and optimization knowledge from COCO training. For more general training best practices, see Tips for Model Training.

Start Simple

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)

yolo train model=yolo26n.pt data=your-dataset.yaml epochs=100 imgsz=640

Fine-tuning with defaults is a strong baseline. Only adjust hyperparameters if you have a specific reason to.

When to Adjust

Small datasets (< 1,000 images):

• Reduce augmentation strength: mosaic=0.5, mixup=0.0, copy_paste=0.0
• Lower learning rate: lr0=0.001
• Use fewer epochs with patience: epochs=50, patience=20
• Consider freezing backbone layers: freeze=10

Large datasets (> 50,000 images):

• Match the pretraining recipe more closely
• Consider optimizer=MuSGD for longer runs
• Increase augmentation: mosaic=1.0, mixup=0.3, scale=0.9

Domain-specific imagery (aerial, medical, underwater):

• Increase flipud=0.5 if vertical orientation varies
• Increase degrees if objects appear at arbitrary rotations
• Adjust hsv_s and hsv_v if lighting conditions differ significantly from COCO

For automated hyperparameter optimization, see the Hyperparameter Tuning guide.

Choosing a Model Size

For export and deployment options, see the Export guide and Model Deployment Options.

FAQ

How do I see the exact hyperparameters used for any checkpoint?

Load the checkpoint with torch.load() and access the train_args key, or use model.ckpt["train_args"] with the Ultralytics API. See Inspecting Training Args for complete examples.

Why are the epoch counts different for each model size?

Larger models converge faster on COCO because they have more capacity. The N model needed 245 epochs while the X model only needed 40. When fine-tuning on your own dataset, the optimal number of epochs depends on your dataset size and complexity, not the model size. Use early stopping (patience) to find the right stopping point automatically.

Should I use MuSGD for fine-tuning?

When optimizer=auto (the default), Ultralytics automatically selects MuSGD for longer training runs (>10,000 iterations) and AdamW for shorter ones. You can explicitly set optimizer=MuSGD if you prefer. For more on optimizer selection, see the training documentation.

What are muon_w, sgd_w, cls_w, o2m, and topk in the checkpoint?

These are internal parameters from the training pipeline that produced the base checkpoints. They are stored for reproducibility but are not user-configurable settings in default.yaml. You do not need to set them when fine-tuning. See Internal Training Parameters for details.

Can I replicate the exact pretraining from scratch?

The checkpoints were produced using an internal training branch with additional features not in the public codebase (like configurable o2m weights and cls_w). You can get very close results using the hyperparameters documented on this page with the public Ultralytics package, but an exact reproduction requires the internal branch.

📅 Created 0 days ago ✏️ Updated 0 days ago

Comments