Link to this sectionYOLO26 Training Recipe#

Link to this sectionIntroduction#

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.

Link to this sectionTraining 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 (parameters with ndim >= 2, such as conv and linear 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

Link to this sectionInspecting 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.

Link to this sectionYOLO26 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.

Link to this sectionOptimizer and Learning Rate#

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

Link to this sectionLoss 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.

Link to this sectionAugmentation 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.

Link to this sectionInternal Training Parameters#

Link to this sectionFine-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.

Link to this sectionFine-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.

Link to this sectionWhen 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.

Link to this sectionChoose a Model Size#

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

Link to this sectionConclusion#

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.

Link to this sectionFAQ#

Link to this sectionHow 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 YOLO26 Checkpoint Training Args for complete examples.

Link to this sectionWhy are the epoch counts different for each model size?#

Larger models generally needed fewer epochs on COCO because their greater capacity speeds up convergence — the X model trained for 40 epochs versus 245 for N — though the counts are not strictly monotonic (S used 70, M used 80). 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.

Link to this sectionShould I use MuSGD for fine-tuning?#

Usually you don't need to choose: with the default optimizer=auto, 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 how MuSGD works, see the training documentation.

Link to this sectionWhat 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, recorded in train_args for reproducibility. They are not user-configurable settings in default.yaml, and passing them to model.train() raises an invalid-argument error — the public package does not read them. You do not need to set them when fine-tuning; see Internal Training Parameters for their values per model size.

Link to this sectionCan I replicate the exact pretraining from scratch?#

Not exactly — 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.