Durchläufe trainieren, auswerten und fein abstimmen

Einen Durchlauf starten#

Klicke auf einer Projekt- oder Datensatzseite auf New Model. Der Tab Cloud Training führt dich durch die folgenden Einstellungen:

Es sind dieselben Argumente, die model.train(...) bei einem lokalen Durchlauf verwendet. Auf der Modellseite wird später ein kopierbarer yolo train-Befehl mit den Werten angezeigt, die von den Standardeinstellungen abweichen.

GPU auswählen und Durchlauf budgetieren#

Die Kostenübersicht schätzt Dauer und Preis, bevor du startest: etwa $0.23 für 1,000 Bilder × YOLO26n × 100 Epochen auf der Standard-RTX PRO 6000 und etwa $1.56 für 5,000 Bilder × YOLO26s × 100 Epochen auf einer H100 SXM, die ungefähr 3.4× schneller trainiert als eine RTX 4090. Abgerechnet wird die tatsächliche GPU-Laufzeit: Abgeschlossene, abgebrochene und fehlgeschlagene Läufe werden berechnet, sobald eine GPU gestartet wurde. Für einen Lauf muss dein Guthaben die geschätzten Kosten abdecken (mindestens 15 Minuten GPU-Laufzeit), und aktive Läufe werden beendet, wenn dein Guthaben negativ wird. Aktiviere daher unter Einstellungen > Abrechnung die automatische Aufladung für lange Aufträge. Wenn du eine günstigere GPU als die RTX PRO 6000 auswählst, kannst du kostenlos auf diese GPU hochgestuft werden, sobald von Ultralytics verwaltete Kapazität ungenutzt ist; abgerechnet wird weiterhin dein ausgewählter Tarif.

Entscheidungsregeln: Teste einen neuen Datensatz zuerst mit 10–20 Epochen auf der Standard-GPU. Wechsle zu einer H100 oder H200, wenn ein Lauf Stunden dauert und jemand darauf wartet. Wähle eine günstigere statt einer schnelleren GPU, wenn die GPU-Auslastung niedrig bleibt.

Lauf überwachen#

Der Tab Training auf der Modellseite enthält drei Untertabs mit laufender Aktualisierung. Diagramme zeigt Metriken, Trainings- und Validierungsverluste sowie die Lernrate pro Epoche an; Konsole behält die letzten 2,000 Zeilen und beendet den Lauf sofort bei einem Traceback oder einem CUDA-Speicherfehler; System zeigt GPU-Auslastung, Speicher und Temperatur an:

Ein Lauf, der 4 Stunden lang keine Meldung ausgibt, wird als fehlgeschlagen markiert. Der beste Checkpoint wird regelmäßig hochgeladen, sodass bei einem abgebrochenen Lauf die bis dahin beste Epoche erhalten bleibt. Über Slack-Benachrichtigungen kannst du dich informieren lassen, wenn Läufe abgeschlossen sind oder fehlschlagen.

Praxisbeispiel: Einen Lauf trainieren, streamen und auswerten#

Du kannst überall trainieren und den Lauf trotzdem in Platform verfolgen. Exportiere einen API-Schlüssel aus Einstellungen > API-Schlüssel als ULTRALYTICS_API_KEY. Mit einem project im Format username/project werden Diagramme, Konsole und der beste Checkpoint in dieses Projekt übertragen:

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

Derselbe Befehl läuft auf den GPUs von Platform, wenn du auf Neues Modell klickst; lokal dauerte es auf einer Laptop-CPU weniger als zwei Minuten mit imgsz=320. Das results.csv des Laufs enthält die Reihen pro Epoche, die der Untertab „Diagramme“ darstellt. Mit ein paar Zeilen wird aus „Kurven beobachten“ eine klare Regel:

import pandas as pd

df = pd.read_csv("results.csv")  # the per-epoch metrics behind the Charts 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

Die beste Epoche ist die letzte, mAP50-95 ist in den letzten drei Epochen um 2.8 Punkte gestiegen und der Validierungsverlust sinkt weiterhin: Dieser Lauf über 10 Epochen wurde vorzeitig beendet, und ein längerer Lauf oder ein Fine-Tuning wird helfen. Verwende dieselben drei Signale im Untertab „Diagramme“ jedes Platform-Laufs: die Lage der besten Epoche, den jüngsten Zuwachs und die Richtung des Validierungsverlusts.

Ein früheres Modell feinabstimmen#

Wähle unter Meine Modelle dein vorheriges Modell als Basismodell aus. Platform erstellt ein neues Modell, das mit diesem Checkpoint beginnt, und lässt das alte unverändert. Üblicherweise wird eine niedrigere Lernrate empfohlen. Beim standardmäßigen optimizer: auto wählt das Training jedoch selbst Optimierer und Lernrate und ignoriert lr0. Die ersten Zeilen der Konsole weisen darauf hin:

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)

Lege optimizer ausdrücklich in den erweiterten Einstellungen fest, damit der Wert übernommen wird. Beim Fine-Tuning des Pillenmodells über weitere 5 Epochen mit optimizer: SGD und lr0: 0.001 wird Folgendes protokolliert:

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 stieg von 0.659 auf 0.687. In der nächsten Lektion prüfst du diesen Kandidaten anhand einer Freigabeschwelle.

Um einen früheren Lauf zu reproduzieren, öffne auf der Modellseite die Tabelle „Trainingskonfiguration“, wähle JSON kopieren und füge die Konfiguration in die erweiterten Einstellungen ein. Der Leitfaden zum Fine-Tuning behandelt das Einfrieren von Schichten; der Leitfaden zur Hyperparameteroptimierung behandelt systematische Durchläufe.

Stolperfallen#