Train Your First Model

One Python call, sensible defaults, and a checkpoint at the end.

Now we train. Thanks to transfer learning from the pretrained weights, there's a real chance your first run beats the pretrained baseline by a wide margin — your dataset is narrower, the classes are familiar, and the Ultralytics YOLO default configuration is well-tuned. Don't overthink the config the first time. Run, look at the curves, then iterate.

Outcome

Train a model on your dataset, end-to-end, and save the best.pt checkpoint.

Fast Track

If you already know your way around, here's the short version.

model = YOLO('yolo26n.pt').
model.train(data='my_dataset/data.yaml', epochs=100, imgsz=640).
Watch the loss curves in the console.
Open runs/detect/train/. Your weights are in weights/best.pt.

Hands-on

Link to this sectionA first training run#

Ultralytics Platform cloud training dialog

The fine-tune flow — covered end-to-end in the fine-tuning guide — is just three steps:

graph LR
    A[Pretrained<br/>yolo26n.pt] --> B[model.train<br/>data=data.yaml]
    B --> C[runs/detect/train/<br/>weights/best.pt]
    C --> D[Validate<br/>+ iterate]

    style A fill:#2196F3,color:#fff
    style B fill:#9C27B0,color:#fff
    style C fill:#4CAF50,color:#fff

from ultralytics import YOLO

model = YOLO("yolo26n.pt")     # start from a pretrained checkpoint

results = model.train(
    data="my_dataset/data.yaml",
    epochs=100,
    imgsz=640,
    batch=16,
    name="forklift_v1",
)

# Path to the best checkpoint
print(results.save_dir)

That writes a directory like runs/detect/forklift_v1/ with:

weights/best.pt — best validation mAP across epochs.
weights/last.pt — last epoch.
results.csv — per-epoch metrics.
A bunch of plots — confusion matrix, PR curves, F1 curves, sample predictions.

Open the directory in a file explorer and scroll the plots before running anything else.

Link to this sectionThe arguments that matter#

Defaults are sane. Three knobs you'll touch first:

Arg	Default	When to change
`epochs`	100	Lower for tiny datasets to avoid overfitting; higher (200–300) for large ones
`imgsz`	640	Increase to 1024 / 1280 for small objects
`batch`	16	Batch size — match GPU memory; -1 picks the largest that fits

model.train(data="my_dataset/data.yaml", epochs=200, imgsz=1024, batch=-1)

Start from a pretrained checkpoint

Always pass yolo26n.pt (or another size) as the model — never train from scratch unless you're researching the backbone. Pretrained weights cut training time by 5–10× and reach much higher final accuracy on most datasets.

Link to this sectionReading the live log#

The console log per epoch looks like this:

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       1/100     2.43G      1.234      1.456      0.987         42        640: 100% ...

                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95)
                   all         50        102      0.612      0.534      0.561      0.342

What to watch:

box_loss, cls_loss, dfl_loss trend down — these are the components of YOLO's loss function and should fall steadily for the first many epochs. A loss that plateaus immediately means data or config trouble.
P (precision) / R (recall) trend up — and balance. Precision >> recall means the model is too cautious; recall >> precision means it's hallucinating.
mAP50 and mAP50-95 trend up — the actual quality numbers; the performance metrics guide explains them in depth.

If anything looks off in the first 5 epochs, kill the run with Ctrl-C and investigate before burning hours.

Link to this sectionMulti-GPU#

model.train(data=..., device=[0, 1, 2, 3])    # use 4 GPUs

Ultralytics YOLO uses DDP automatically and trains in mixed precision by default. Effective batch size = batch × number of GPUs. When you're ready to push past sensible defaults, the hyperparameter tuning guide covers learning rate sweeps, augmentation knobs, and the genetic optimizer.

Link to this sectionCLI version#

The same training, on the command line:

yolo detect train data=my_dataset/data.yaml model=yolo26n.pt epochs=100 imgsz=640 name=forklift_v1

CLI and Python are equivalent — pick whichever fits your workflow.

Try It

Run model.train(data=…, epochs=100). While it trains, scan the console output every few epochs. After it finishes, open runs/detect/.../results.png and look at the curves. Note where mAP plateaus.

Commit

git add -A && git commit -m "feat(model): trained first forklift detector"

Done When

You've finished the lesson when all of these are true.

Training completed without crashing.
runs/detect/<name>/weights/best.pt exists.
You've looked at the loss/mAP curves and have an opinion on whether they look healthy.

Show solution

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.train(
    data="my_dataset/data.yaml",
    epochs=100,
    imgsz=640,
    batch=-1,           # auto-batch
    name="forklift_v1",
    patience=20,        # early-stop if mAP doesn't improve for 20 epochs
)

What's next

We have a model. Next: validate it honestly and figure out what to fix.