Train, Read, and Fine-Tune Runs

Launch a Run#

Click New Model on a project or dataset page. The Cloud Training tab walks through these settings:

The arguments are the same ones model.train(...) takes locally, and the model page later shows a copyable yolo train command with the non-default values.

Pick the GPU and Budget the Run#

The cost card estimates duration and price before you start: about $0.23 for 1,000 images × YOLO26n × 100 epochs on the default RTX PRO 6000, and about $1.56 for 5,000 images × YOLO26s × 100 epochs on an H100 SXM, which trains roughly 3.4× faster than an RTX 4090. Billing follows actual GPU time: completed, canceled, and failed runs are charged once a GPU has started, a run needs a balance covering its estimate (at least 15 minutes of GPU time), and active runs stop if the balance goes negative, so turn on auto top-up in Settings > Billing for long jobs. Selecting a GPU cheaper than the RTX PRO 6000 can earn a free upgrade to it when Ultralytics-managed capacity is idle, still billed at your selected rate.

Decision rules: smoke-test a new dataset with 10–20 epochs on the default GPU first. Move to an H100 or H200 when a run takes hours and someone is waiting on it. Pick a cheaper GPU, not a faster one, when GPU utilization stays low.

Watch the Run#

The model page's Train tab includes Metrics, Console, and System subtabs, plus Validation when validation results are available. Metrics plots task metrics, train and validation losses, and learning rate per epoch; Console keeps the last 2,000 lines and stops the run at once on a traceback or CUDA out-of-memory error; System shows GPU utilization, memory, and temperature:

A run that reports nothing for 4 hours is marked failed. The best checkpoint uploads periodically, so a canceled run keeps its best epoch so far, and Slack alerts can tell you when runs complete or fail.

Worked Example: Train, Stream, and Read a Run#

You can train anywhere and still track the run in Platform. With an API key from Settings > API Keys exported as ULTRALYTICS_API_KEY, a project of the form username/project streams charts, console, and the best checkpoint into that project:

from ultralytics import YOLO

# export ULTRALYTICS_API_KEY="..." first to stream this run into your Platform project
model = YOLO("yolo26n.pt")
results = model.train(data="medical-pills.yaml", epochs=10, imgsz=320, project="username/pill-inspection", name="v1-baseline")
print(f"mAP50-95 {results.box.map:.3f}, best checkpoint: {model.trainer.best}")

                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95)
                   all         23        399       0.97      0.957      0.977      0.659
mAP50-95 0.659, best checkpoint: .../runs/detect/username/pill-inspection/v1-baseline/weights/best.pt

The same command runs on Platform's GPUs when you click New Model; locally it took under two minutes on a laptop CPU at imgsz=320. The run's results.csv holds the per-epoch series the Metrics subtab plots, so a few lines turn "watch the curves" into a rule:

import pandas as pd

df = pd.read_csv("results.csv")  # the per-epoch metrics behind the Metrics subtab
df.columns = df.columns.str.strip()
m = df["metrics/mAP50-95(B)"]
best_epoch = int(df.loc[m.idxmax(), "epoch"])
recent_gain = m.iloc[-1] - m.iloc[-4]  # change over the last 3 epochs
val_loss = df["val/box_loss"]
print(f"epochs={len(df)} best mAP50-95={m.max():.3f} at epoch {best_epoch}")
print(f"gain over last 3 epochs: {recent_gain:+.3f}")
print(f"val box loss: {val_loss.iloc[0]:.3f} -> {val_loss.iloc[-1]:.3f}")
if recent_gain < 0.005 and val_loss.iloc[-1] >= val_loss.iloc[-4]:
    print("verdict: plateaued - stop, and fix the data before training longer")
elif best_epoch == len(df):
    print("verdict: still improving at the last epoch - more epochs should help")
else:
    print("verdict: converged - keep best.pt")

epochs=10 best mAP50-95=0.659 at epoch 10
gain over last 3 epochs: +0.028
val box loss: 1.367 -> 1.045
verdict: still improving at the last epoch - more epochs should help

The best epoch is the last one, mAP50-95 rose 2.8 points over the last three epochs, and validation loss is still falling: this 10-epoch run stopped early, and a longer run or a fine-tune will help. Use the same three signals on any Platform run's Metrics subtab: where the best epoch sits, the recent gain, and the direction of validation loss.

Fine-Tune From an Earlier Model#

Pick your previous model under My Models as the base model; Platform creates a new model that starts from that checkpoint and leaves the old one unchanged. The usual advice is a lower learning rate, but with the default optimizer: auto training picks its own optimizer and learning rate and ignores lr0. The console says so in the first lines:

optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and determining best 'optimizer' and 'lr0' automatically...
optimizer: AdamW(lr=0.002, momentum=0.9) with parameter groups 114 weight(decay=0.0), 126 weight(decay=0.0005), 126 bias(decay=0.0)

Set optimizer explicitly in Advanced Settings and the value sticks. Fine-tuning the pill model for 5 more epochs with optimizer: SGD and lr0: 0.001 logs:

optimizer: SGD(lr=0.001, momentum=0.937) with parameter groups 114 weight(decay=0.0), 126 weight(decay=0.0005), 126 bias(decay=0.0)
                   all         23        399      0.969      0.962      0.983      0.687

mAP50-95 rose from 0.659 to 0.687. You'll put that candidate through a promotion gate in the next lesson.

To reproduce an earlier run, open its Training Configuration table on the model page, choose Copy JSON, and paste it into Advanced Settings. The fine-tuning guide covers layer freezing, and the hyperparameter tuning guide covers systematic sweeps.

Pitfalls#