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.

Knowing what went into the official checkpoints — not just the architecture, but the learning rate schedules, augmentation pipelines, and loss weights that shaped their performance — 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.

Training Overview#

All YOLO26 base models were trained on COCO at 640x640 resolution using the MuSGD optimizer with batch size 128. Rather than starting from random weights in a single run, 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 weight matrices (2D linear weights and 4D conv filters, which are reshaped to 2D)
• 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

Inspecting YOLO26 Checkpoint Training Args#

Every Ultralytics checkpoint stores the full training configuration used to produce it, so you can verify each number on this page yourself:

from ultralytics import YOLO

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

The output lists the full configuration of over 100 entries, including every recipe value documented on this page. An excerpt for 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: MuSGD

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.

YOLO26 Training Hyperparameters per Model Size#

The tables below group the recipe by category — optimizer and schedule, loss weights, and augmentation. Every value comes straight from the train_args embedded in the released checkpoints.

Optimizer and Learning Rate#

These optimizer and schedule settings drove COCO pretraining for each size; note how the N model stands apart from the rest:

Loss Weights#

Loss weights balance the three components of the detection loss — bounding box IoU regression (box), classification (cls), and a box-distance regression term (dfl). Note that DFL-free YOLO26 repurposes the dfl gain to weight an L1 loss on normalized box distances rather than distribution focal loss:

The N model prioritizes the dfl distance-regression term, while S/M/L/X models shift emphasis to IoU-based 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.

Values shown as ~0 are below 0.01 in the actual checkpoints (for example, degrees=0.00012 for the S model) — the augmentation is effectively disabled.

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 YOLO26 on Your Own Dataset#

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.

Fine-Tune with Default Settings#

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.train(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 YOLO26 Hyperparameters#

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.

Choose a Model Size#

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

Conclusion#

The YOLO26 checkpoints ship with their full training recipe embedded, so the exact hyperparameters behind every model size are always one train_args lookup away. Start fine-tuning from the defaults, adjust deliberately using the tables on this page, and verify every change against your own validation set. If questions come up along the way, ask the community on the Ultralytics GitHub repository or the Ultralytics Discord server.

FAQ#