Erste Schritte

Modelltraining mit Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

Einführung#

Beim Training eines Deep-Learning-Modells werden ihm Daten zugeführt und seine Parameter angepasst, damit es genaue Vorhersagen treffen kann. Der Train-Modus von Ultralytics YOLO26 trainiert effizient Modelle für die Objekterkennung und andere Bildverarbeitungsaufgaben auf moderner Hardware. Diese Anleitung enthält alle Informationen, die du benötigst, um mit YOLO26 mit dem Training eigener Modelle zu beginnen. Falls du Ultralytics noch nicht installiert hast, beginne mit der Schnellstartanleitung.

Sieh dir die Vorschau auf das noch nicht veröffentlichte YOLO27 an, um geplante Trainingsbeispiele zu entdecken.



Ansehen: So trainierst du ein YOLO-Modell mit deinem eigenen Datensatz in Google Colab.

Warum Ultralytics YOLO für das Training wählen?#

Gründe für die Verwendung des Train-Modus von YOLO26:

  • Effizienz: Nutze deine Hardware optimal, egal ob du ein einzelnes GPU-System verwendest oder das Training auf mehrere GPUs verteilst.
  • Vielseitigkeit: Trainiere mit benutzerdefinierten Datensätzen und mit direkt verfügbaren Datensätzen wie COCO, VOC und ImageNet.
  • Benutzerfreundlichkeit: Einfache, aber leistungsstarke CLI- und Python-Schnittstellen sorgen für unkompliziertes Training.
  • Flexible Hyperparameter: Eine große Auswahl an anpassbaren Hyperparametern ermöglicht die Feinabstimmung der Modellleistung. Für eine noch genauere Steuerung kannst du auch den Trainer selbst anpassen.
  • Cloud-Training: Trainiere auf Cloud-GPUs über die Ultralytics Platform mit Echtzeitmetriken und automatischer Speicherung von Prüfpunkten.

Wichtige Funktionen des Trainingsmodus#

Im Folgenden findest du einige bemerkenswerte Funktionen des Trainingsmodus von YOLO26:

  • Automatischer Datensatz-Download: Datensatzkonfigurationen mit einer Downloadquelle werden bei der ersten Verwendung automatisch heruntergeladen, z. B. yolo train data=coco8.yaml. Unterstützte Formate und Datensätze findest du in der Übersicht zu Datensätzen.
  • Unterstützung mehrerer GPUs: Verteile das Training auf mehrere GPUs, um die Trainingszeit zu verkürzen.
  • Konfiguration von Hyperparametern: Du kannst Hyperparameter über YAML-Konfigurationsdateien oder CLI-Argumente ändern.
  • Visualisierung und Überwachung: Trainingsmetriken werden in Echtzeit erfasst und der Lernprozess wird zur besseren Auswertung visualisiert.

Anwendungsbeispiele#

Trainiere YOLO26n 100 Epochen lang mit Bildgröße 640 auf dem Datensatz COCO8. Das Trainingsgerät kannst du mit dem Argument device angeben. Wird kein Argument übergeben, kommt, sofern verfügbar, GPU device=0 zum Einsatz; andernfalls wird device='cpu' verwendet.

Fehler bei der Mehrfachverarbeitung unter Windows

Unter Windows kann beim Starten des Trainings als Skript der Fehler RuntimeError auftreten. Füge vor deinem Trainingscode einen if __name__ == "__main__":-Block ein, um das Problem zu beheben.

Beispiel für Training mit einer GPU und mit CPU

Das Gerät wird automatisch bestimmt. Wenn eine GPU verfügbar ist, wird sie verwendet (standardmäßig CUDA-Gerät 0); andernfalls beginnt das Training auf der CPU.

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.yaml")  # ein neues Modell aus YAML erstellen
model = YOLO("yolo26n.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # aus YAML erstellen und Gewichte übertragen

# Das Modell trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Training mit mehreren GPUs#

Beim Training mit mehreren GPUs wird die verfügbare Hardware besser genutzt, indem die Trainingslast auf mehrere GPUs verteilt wird. Diese Funktion ist sowohl über die Python-API als auch über die Befehlszeile verfügbar. Um das Training mit mehreren GPUs zu aktivieren, gib die IDs der zu verwendenden GPU-Geräte an.

Beispiel für Training mit mehreren GPUs

Verwende die folgenden Befehle, um mit zwei GPUs (CUDA-Geräte 0 und 1) zu trainieren. Bei Bedarf kannst du weitere GPUs hinzufügen.

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)

# Das Modell mit zwei GPUs trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Das Modell mit den beiden am wenigsten ausgelasteten GPUs trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])
Unterstützung für mehrere GPUs unter Windows

Das Training mit mehreren GPUs funktioniert unter Windows nicht mit den offiziellen PyTorch-Wheels für torch>=2.4. Ultralytics startet DDP über torch.distributed.run; dabei erstellt der Rendezvous-Schritt ein TCPStore, das seit PyTorch 2.4 standardmäßig das libuv-Backend verwendet. Die offiziellen Windows-Wheels wurden jedoch ohne libuv erstellt. Das Training wird sofort mit folgendem Fehler beendet:

RuntimeError: use_libuv was requested but PyTorch was built without libuv support

Das Festlegen von USE_LIBUV=0 behebt das Problem nicht, da der Rendezvous direkt das TCPStore erstellt und dieser Codepfad die Variable nicht ausliest. Trainiere unter Linux oder WSL2, um mehrere GPUs zu verwenden, oder trainiere unter Windows mit device=0 auf einer einzelnen GPU.

Training mit mehreren GPUs und benutzerdefiniertem Code

Wenn du mehrere Geräte angibst (z. B. device=[0, 1]), startet Ultralytics intern eine neue Trainer-Instanz und führt im Hintergrund torch.distributed.run aus. Das funktioniert bei der standardmäßigen CLI-Nutzung und bei unveränderten Python-Skripten.

Enthält dein Skript jedoch benutzerdefinierte Komponenten – etwa einen benutzerdefinierten Trainer, Validator, Datensatz oder eine Augmentierungspipeline –, können diese Objekte nicht automatisch serialisiert und an die DDP-Unterprozesse übertragen werden. In diesem Fall musst du dein Skript direkt mit torch.distributed.run starten:

python -m torch.distributed.run --nproc_per_node 2 your_training_script.py

Das Training auf AMD-GPUs verwendet einen PyTorch-ROCm-Build mit der standardmäßigen Syntax device=0 oder device=cuda:0. Informationen zur ROCm-Installation, zum Training mit mehreren GPUs, zu AMP und zur MIGraphX-Inferenz exportierter Modelle findest du im AMD-Integrationsleitfaden.

Für das Training auf Intel-GPUs verwendest du device=xpu:0 oder mehrere XPU-IDs mit einem PyTorch-Build, der XCCL bereitstellt.

Training auf Huawei-Ascend-NPUs#

Ultralytics unterstützt Training und Validierung auf Huawei-Ascend-NPUs über torch_npu. Installiere miteinander kompatible Versionen von CANN, PyTorch und torch_npu, indem du der Installationsanleitung für die Ascend Extension for PyTorch folgst. Lade anschließend die CANN-Umgebung, bevor du Ultralytics startest:

source /usr/local/Ascend/ascend-toolkit/set_env.sh
Beispiel für Training auf Ascend-NPUs
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Auf einer Ascend-NPU trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Mit HCCL auf zwei Ascend-NPUs trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Die standardmäßigen Trainingsfunktionen, darunter AMP, Validierung, das Speichern von Prüfpunkten und das Fortsetzen des Trainings, verwenden die aktive NPU. AutoBatch ist für das Training mit einer einzelnen NPU verfügbar; bei mehreren NPU-IDs wird verteiltes Training über HCCL gestartet. Informationen zum Export und zur Bereitstellung von Modellen nach dem Training findest du im Integrationsleitfaden für Huawei Ascend.

Training auf wenig ausgelasteten GPUs#

Beim Training auf nicht ausgelasteten GPUs wählt Ultralytics in Systemen mit mehreren GPUs automatisch die am wenigsten ausgelasteten GPUs aus, sodass du die Geräte nicht manuell auswählen musst. Die verfügbaren GPUs werden anhand ihrer Auslastung und des freien VRAM sortiert.

Beispiel für das Training auf wenig ausgelasteten GPUs

Verwende den Geräteparameter -1, um automatisch die am wenigsten ausgelastete GPU oder die am wenigsten ausgelasteten GPUs für das Training auszuwählen. Das ist besonders nützlich in gemeinsam genutzten Computerumgebungen oder auf Servern mit mehreren Benutzern.

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)

# Mit der am wenigsten ausgelasteten GPU trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Mit den beiden am wenigsten ausgelasteten GPUs trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

Der Algorithmus zur automatischen Auswahl bevorzugt GPUs mit:

  1. geringerer aktueller Auslastung
  2. mehr verfügbarem Speicher (freiem VRAM)

Das ist besonders in gemeinsam genutzten Computerumgebungen oder bei mehreren gleichzeitig laufenden Trainingsaufträgen nützlich, da die Geräte bei jedem Start anhand der aktuellen Bedingungen ausgewählt werden.

MPS-Training auf Apple Silicon#

Ultralytics YOLO-Modelle können auf Apple-Silicon über das Framework Metal Performance Shaders (MPS) trainiert werden, das Berechnungen und Bildverarbeitungsaufgaben auf Apples speziell entwickelten GPUs ausführt.

Um auf Apple-Silicon zu trainieren, gib beim Start des Trainings in Python oder über die Befehlszeile mps als Gerät an:

Beispiel für MPS-Training
from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)

# Das Modell mit MPS trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Unterbrochene Trainingsläufe fortsetzen#

Das Fortsetzen des Trainings anhand eines gespeicherten Checkpoints ist nützlich, wenn ein Trainingslauf unerwartet unterbrochen wurde oder du ein Modell mit neuen Daten oder über weitere Epochen hinweg trainieren möchtest.

Beim Fortsetzen des Trainings lädt Ultralytics YOLO die Gewichte des zuletzt gespeicherten Modells und stellt außerdem den Optimizer-Zustand, den Lernraten-Scheduler, die Epochenzahl und den Datensatz wieder her. Das Training wird dann an der Stelle fortgesetzt, an der es unterbrochen wurde. Übergib zusätzlich zu resume explizit data=, um mit einem anderen Datensatz statt mit dem des Checkpoints fortzufahren.

Um das Training in Ultralytics YOLO fortzusetzen, setze beim Aufruf der Methode train das Argument resume auf True und gib den Pfad zur Datei .pt an, die die teilweise trainierten Modellgewichte enthält.

So setzt du einen unterbrochenen Trainingslauf in Python oder über die Befehlszeile fort:

Beispiel zum Fortsetzen des Trainings
from ultralytics import YOLO

# Ein Modell laden
model = YOLO("path/to/last.pt")  # Modell mit teilweise abgeschlossenem Training laden

# Training fortsetzen
results = model.train(resume=True)

Wenn du resume=True setzt, setzt die Funktion train das Training an der Stelle fort, an der es unterbrochen wurde, und verwendet dafür den in der Datei path/to/last.pt gespeicherten Zustand. Wird das Argument resume weggelassen oder auf False gesetzt, startet die Funktion train eine neue Trainingssitzung. Ein Trainingslauf, der Daten an die Ultralytics Platform überträgt, setzt beim Fortsetzen dasselbe Platform-Modell fort.

Beachte, dass Checkpoints standardmäßig am Ende jeder Epoche oder in festen Abständen mithilfe des Arguments save_period gespeichert werden. Daher musst du mindestens eine Epoche abschließen, um einen Trainingslauf fortzusetzen.

Trainingseinstellungen#

Die Trainingseinstellungen für YOLO-Modelle umfassen verschiedene Hyperparameter und Konfigurationen, die während des Trainings verwendet werden. Diese Einstellungen beeinflussen die Leistung, Geschwindigkeit und Genauigkeit des Modells. Zu den wichtigsten Trainingseinstellungen gehören Batchgröße, Lernrate, Momentum und Gewichtsabnahme. Auch die Wahl des Optimizers, der Verlustfunktion und der Zusammensetzung des Trainingsdatensatzes kann den Trainingsprozess beeinflussen. Eine sorgfältige Abstimmung und Erprobung dieser Einstellungen ist entscheidend für die Leistungsoptimierung.

MuSGD-Optimierer#

In YOLO26 ist MuSGD ein hybrider Optimizer, der standardmäßige SGD-Aktualisierungen mit orthogonalisierten Aktualisierungen nach Muon-Art kombiniert.

Er wird für längere YOLO26-Trainingsläufe und größere Datensätze empfohlen, bei denen orthogonalisierte Muon-Aktualisierungen die Optimierung stabilisieren können.

Nur zweidimensionale lineare Gewichte und vierdimensionale Faltungsfilter (auf zwei Dimensionen umgeformt) erhalten zusammen mit SGD eine Aktualisierung nach Muon-Art; alle anderen Parameter, etwa Batch-Normalisierungsgewichte und Bias-Terme, werden weiterhin mit standardmäßigem SGD aktualisiert.

Wird optimizer=auto verwendet, wählt Ultralytics bei längeren Trainingsläufen automatisch MuSGD aus (in der Regel, wenn iterations > 10000). Bei kürzeren Läufen verwendet der Trainer stattdessen AdamW. Im Modus auto wählt der Trainer auch die Lernrate aus, sodass ein vom Benutzer angegebenes lr0 ignoriert wird. Um diese Einstellungen manuell zu steuern, wähle explizit einen Optimierer aus, zum Beispiel optimizer=AdamW lr0=0.001.

Anwendungsbeispiel:

yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGD

Die Implementierung findest du in ultralytics/optim/muon.py und die Logik zur automatischen Optimiererauswahl in BaseTrainer.build_optimizer.

ArgumentTypStandardBeschreibung
modelstrNoneGibt die Modelldatei für das Training an. Akzeptiert einen Pfad zu einem vortrainierten .pt-Modell oder einer .yaml-Konfigurationsdatei. Unverzichtbar, um die Modellstruktur festzulegen oder Gewichte zu initialisieren.
datastrNonePfad zur Dataset-YAML-Datei (z. B. coco8.yaml), die die Pfade zu den Trainings- und Validierungsdaten, die Klassennamen und die Anzahl der Klassen enthält. Für die Klassifizierung wird stattdessen ein Dataset-Verzeichnis oder der Name eines integrierten Datensatzes angegeben (z. B. imagenet10).
epochsint100Gesamtzahl der Trainingsepochen. Jede Epoche entspricht einem vollständigen Durchlauf durch den gesamten Datensatz. Dieser Wert wirkt sich auf die Trainingsdauer und die Modellleistung aus.
timefloatNoneMaximale Trainingsdauer in Stunden. Wenn dieser Wert gesetzt ist, überschreibt er das Argument epochs und beendet das Training automatisch nach der angegebenen Dauer. Nützlich für Trainingsszenarien mit begrenzter Zeit.
patienceint100Anzahl der Epochen, die ohne Verbesserung der Validierungsmetriken abgewartet werden, bevor das Training vorzeitig beendet wird. Hilft, Überanpassung zu verhindern, indem das Training bei stagnierender Leistung beendet wird.
batchint oder float16Batchgröße, mit drei Modi: als Ganzzahl festlegen (z. B. batch=16), Automatikmodus für 60 % des verfügbaren GPU-Speichers (batch=-1) oder Automatikmodus mit einem angegebenen Anteil des verfügbaren GPU-Speichers (batch=0.70).
imgszint640Zielbildgröße für das Training. Bilder werden auf Quadrate mit Seitenlängen entsprechend dem angegebenen Wert skaliert (wenn rect=False), wobei YOLO-Modelle das Seitenverhältnis beibehalten, RT-DETR jedoch nicht. Beeinflusst die Genauigkeit und den Rechenaufwand des Modells.
saveboolTrueAktiviert das Speichern von Trainingsprüfpunkten und den finalen Modellgewichten. Nützlich, um das Training fortzusetzen oder das Modell bereitzustellen.
save_periodint-1Häufigkeit, mit der Modellprüfpunkte gespeichert werden, angegeben in Epochen. Der Wert -1 deaktiviert diese Funktion. Nützlich, um während langer Trainingsläufe Zwischenmodelle zu speichern.
cachebool oder strFalseAktiviert das Zwischenspeichern von Dataset-Bildern im Arbeitsspeicher (True/ram), auf der Festplatte (disk) oder deaktiviert es (False). Beschleunigt das Training durch weniger Festplatten-E/A, erhöht jedoch den Speicherbedarf.
tilebool oder intFalseErweitert jedes Quellbild zu festen Trainingskacheln, wobei zugeschnittene Labels und negative Fenster erhalten bleiben. True verwendet imgsz; eine positive Ganzzahl legt die Kachelgröße fest. Siehe Kachelung mit hoher Auflösung.
deviceint oder str oder listNoneGibt das Rechengerät bzw. die Rechengeräte für das Training an: eine einzelne GPU (device=0), mehrere GPUs (device=[0,1]), CPU (device=cpu), MPS für Apple-Silicon (device=mps), Huawei-Ascend-NPU (device=npu:0 oder device=npu:0,1), Intel XPU (device=xpu:0), automatische Auswahl einer freien GPU (device=-1) oder mehrerer freier GPUs (device=[-1,-1]).
workersint8Anzahl der Worker-Threads für das Laden von Daten (pro RANK bei Multi-GPU-Training). Beeinflusst die Geschwindigkeit der Datenvorverarbeitung und der Datenzufuhr zum Modell; besonders nützlich bei Setups mit mehreren GPUs.
projectstrNoneName des Projektverzeichnisses, in dem die Trainingsergebnisse gespeichert werden. Ein relativer Pfad wird unter runs_dir/<task> abgelegt, ein absoluter Pfad wird unverändert verwendet.
namestrNoneName des Trainingslaufs. Wird verwendet, um im Projektordner ein Unterverzeichnis für Trainingsprotokolle und -ausgaben anzulegen.
exist_okboolFalseWenn True, können ein vorhandenes Projekt-/Namensverzeichnis überschrieben werden. Nützlich für iterative Experimente, ohne vorherige Ausgaben manuell löschen zu müssen.
save_dirstrNoneGibt das genaue Verzeichnis an, in dem die Ausgaben des Laufs gespeichert werden, und überschreibt die Kombination project/name. Der Pfad wird unverändert verwendet und nicht automatisch hochgezählt, sodass aufeinanderfolgende Läufe dasselbe Verzeichnis nutzen.
pretrainedbool oder strTrueLegt fest, ob das Training mit vortrainierten Gewichten beginnt. Der Wert kann ein boolescher Wert oder ein Zeichenfolgenpfad zu ladenden Gewichten sein. pretrained=False trainiert mit zufällig initialisierten Gewichten und behält dabei die Modellarchitektur bei.
cls_remapboolTrueBeim Fine-Tuning über mehrere Datensätze hinweg werden Zeilen des vortrainierten Klassifizierungskopfs für übereinstimmende Klassennamen in das neue Modell kopiert. Überlappende Klassen behalten dadurch ihren erlernten Bias und – wenn die Breite des Kopfs unverändert bleibt – auch ihre Gewichte. Dies gilt sowohl bei unterschiedlicher Klassenanzahl als auch bei gleicher Klassenanzahl mit anderer Klassenreihenfolge.
optimizerstr'auto'Auswahl des Optimierers für das Training. Zu den Optionen gehören SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp oder auto, um anhand der Anzahl der Trainingsiterationen AdamW oder MuSGD auszuwählen. Beeinflusst Konvergenzgeschwindigkeit und -stabilität.
seedint0Legt den Zufallsstartwert für das Training fest und gewährleistet so die Reproduzierbarkeit der Ergebnisse bei Läufen mit denselben Konfigurationen.
deterministicboolTrueErzwingt die Verwendung deterministischer Algorithmen und gewährleistet die Reproduzierbarkeit. Die Einschränkung nichtdeterministischer Algorithmen kann jedoch Leistung und Geschwindigkeit beeinträchtigen.
verboseboolTrueAktiviert ausführliche Ausgaben während des Trainings und zeigt Fortschrittsbalken, Metriken für jede Epoche und zusätzliche Trainingsinformationen in der Konsole an.
single_clsboolFalseBehandelt beim Training alle Klassen in Datensätzen mit mehreren Klassen als eine einzige Klasse. Nützlich für binäre Klassifizierungsaufgaben oder wenn es darum geht, das Vorhandensein von Objekten statt deren Klassifizierung zu erkennen.
classeslist[int]NoneGibt eine Liste der Klassen-IDs an, mit denen trainiert werden soll. Nützlich, um Klassen herauszufiltern und sich beim Training auf bestimmte Klassen zu konzentrieren.
rectboolFalseErmöglicht die Strategie der minimalen Auffüllung: Bilder in einem Batch werden nur so weit aufgefüllt, dass sie dieselbe Größe erreichen, wobei die längste Seite imgsz entspricht. Das kann Effizienz und Geschwindigkeit verbessern, sich aber auf die Modellgenauigkeit auswirken. Der standardmäßige YOLO-Trainer verwendet für die Validierung von Erkennung, Segmentierung, Pose und OBB rect=True, unabhängig von dieser Einstellung.
multi_scalefloat0.0Variiert imgsz in jedem Batch zufällig um +/- multi_scale (z. B. 0.25 -> 0.75x bis 1.25x) und rundet auf Vielfache des Modell-Strides; 0.0 deaktiviert das Training mit mehreren Skalen.
cos_lrboolFalseVerwendet einen Kosinus-Lernraten-Scheduler, der die Lernrate über die Epochen hinweg entlang einer Kosinuskurve anpasst. Unterstützt die Steuerung der Lernrate für eine bessere Konvergenz.
close_mosaicint10Deaktiviert die Mosaik-Datenerweiterung in den letzten N Epochen, um das Training vor dem Abschluss zu stabilisieren. Mit dem Wert 0 wird diese Funktion deaktiviert.
resumeboolFalseSetzt das Training mit dem zuletzt gespeicherten Checkpoint fort. Lädt automatisch Modellgewichte, Optimiererzustand und Epochenanzahl und führt das Training ab der Stelle fort, an der es unterbrochen wurde.
ampbool oder strTrueLegt die Trainingsgenauigkeit fest: True oder "fp16" verwendet FP16, "bf16" BF16 auf unterstützten CUDA-Geräten und False oder "fp32" FP32.
quantizeint oder strNoneSetze den Wert auf 8 (oder "int8"), um ein quantisierungsbewusstes Training (QAT) für INT8 zu aktivieren. Dabei wird das Modell mit Fake-Quantisierung im Trainingsablauf feinabgestimmt, damit die Gewichte den INT8-Export tolerieren. Siehe quantisierungsbewusstes Training.
fractionfloat, int oder list1.0Teilmenge des Datensatzes als Verhältnis/Anzahl oder [train, val, test]-Liste. 1 steht für den vollständigen Split; Ganzzahlen über 1 geben die Anzahl der Bilder an. Nur beim optionalen Testeintrag bedeuten 0/0.0 „keine“. Bei Listen mit zwei Einträgen bleibt der Testdatensatz vollständig.
profileboolFalseAktiviert während des Trainings die Profilierung der ONNX- und TensorRT-Geschwindigkeiten, was für die Optimierung der Modellbereitstellung nützlich ist.
freezeint oder listNoneFriert die ersten N Schichten des Modells oder bestimmte Schichten anhand ihres Index oder Modulnamens ein (23.cv2, ohne vorangestelltes model.) und reduziert so die Anzahl der trainierbaren Parameter. Nützlich für Fine-Tuning oder Transferlernen.
lr0float0.01Anfängliche Lernrate (z. B. SGD=1E-2, Adam=1E-3). Wird beim standardmäßigen optimizer='auto' ignoriert. Gib einen Optimierer explizit an, um diese Lernrate zu verwenden.
lrffloat0.01Finale Lernrate als Anteil der anfänglichen Lernrate = (lr0 * lrf), die zusammen mit Schedulern zur Anpassung der Lernrate im Zeitverlauf verwendet wird.
momentumfloat0.937Momentum von SGD/MuSGD oder beta1 für Adam-Optimierer. Mit optimizer=auto verwendet AdamW 0.9; MuSGD beginnt bei 0.9, anschließend interpoliert das Warmup von warmup_momentum bis momentum. Ohne Warmup bleibt MuSGD im automatischen Modus bei 0.9.
weight_decayfloat0.0005L2-Regularisierung, die große Gewichte bestraft, um Überanpassung zu verhindern.
warmup_epochsfloat3.0Aufwärm-Epochen (Bruchteile sind zulässig), begrenzt, damit die letzte Epoche ohne Aufwärmphase bleibt. Die Lernrate steigt linear von 0 (Bias aus warmup_bias_lr) auf ihren geplanten Wert, der Momentum von warmup_momentum auf momentum und die Gradientenakkumulation von 1 Batch auf ihren Sollwert (siehe nbs); alle erreichen ihre Zielwerte am Ende der Aufwärmphase.
warmup_momentumfloat0.8Anfangs-Momentum für Optimierer mit Momentum-Term (SGD, MuSGD, RMSprop), das bis zum Ende der Aufwärmphase linear auf momentum angehoben wird. Beta1 bei Optimierern der Adam-Familie wird nicht aufgewärmt.
warmup_bias_lrfloat0.1Lernrate für Bias-Parameter während der Aufwärmphase, die zur Stabilisierung des Modelltrainings in den ersten Epochen beiträgt. Wird unter dem Standardwert optimizer='auto' automatisch auf 0.0 gesetzt; gib explizit einen Optimierer an, um sie zu verwenden.
distill_modelstrNonePfad zu einem Prüfpunkt des Lehrermodells (z. B. yolo26x.pt) für die Wissensdestillation. Wenn dieser Wert gesetzt ist, wird das Schülermodell mit einem zusätzlichen Destillationsverlust trainiert, der sich am eingefrorenen Lehrermodell orientiert.
disfloat6.0Gewichtung des Destillationsverlusts, der zu den standardmäßigen Erkennungsverlusten hinzukommt. Höhere Werte verstärken den Einfluss der Merkmalsvorgaben des Lehrermodells.
boxfloat7.5Gewichtung der Box-Verlustkomponente in der Verlustfunktion, die bestimmt, wie stark die präzise Vorhersage der Koordinaten des Begrenzungsrahmens gewichtet wird.
clsfloat0.5Gewichtung des Klassifizierungsverlusts in der Gesamtverlustfunktion. Beeinflusst, wie wichtig eine korrekte Klassenvorhersage im Vergleich zu anderen Komponenten ist.
cls_pwfloat0.0Potenz zur Gewichtung von Klassen, um Klassenungleichgewicht anhand der inversen Klassenhäufigkeit auszugleichen. 0.0 deaktiviert die Klassengewichtung, 1.0 wendet die vollständige Gewichtung anhand der inversen Häufigkeit an. Werte zwischen 0 und 1 bewirken eine teilweise Gewichtung.
dflfloat1.5Gewichtung des Regressionsanteils für Box-Abstände: Distribution Focal Loss (DFL), wenn der Erkennungskopf reg_max > 1 verwendet, oder ein L1-Verlust auf normalisierten Box-Abständen bei DFL-freiem YOLO26 (reg_max: 1).
posefloat12.0Gewichtung des Posenschätzungsverlusts bei Modellen, die für die Posenschätzung trainiert werden. Beeinflusst, wie stark die präzise Vorhersage von Posenschlüsselpunkten gewichtet wird.
kobjfloat1.0Gewichtung des Objektivitätsverlusts für Schlüsselpunkte bei Posenschätzungsmodellen. Stimmt die Erkennungssicherheit auf die Genauigkeit der Posenschätzung ab.
rlefloat1.0Gewichtung des Verlusts der residualen Log-Likelihood-Schätzung in Posenschätzungsmodellen. Beeinflusst die Präzision der Lokalisierung von Schlüsselpunkten.
anglefloat1.0Gewichtung des Winkelverlusts in OBB-Modellen. Beeinflusst die Präzision der Winkelvorhersagen orientierter Begrenzungsrahmen.
dlogfloat1.0Gewichtung des skaleninvarianten logarithmischen Verlusts (SILog) in Modellen zur Tiefenschätzung; dieser Hauptterm bestimmt die Tiefengenauigkeit.
dgradfloat0.5Gewichtung des Gradientenverlusts in Modellen zur Tiefenschätzung. Bestraft Fehler an Tiefenkanten und fördert schärfere Oberflächengrenzen.
dlamfloat1.0Varianzfaktor des SILog-Verlusts in Modellen zur Tiefenschätzung. 1.0 macht den Verlust vollständig skaleninvariant, während 0.0 ihn auf den einfachen logarithmischen RMSE reduziert.
nbsint64Soll-Batchgröße. Gradienten werden über round(nbs / batch) Batches pro Optimierungsschritt akkumuliert (mindestens 1 und außerhalb des Modus time höchstens so viele wie die Gesamtzahl der Batches im Lauf); weight_decay wird entsprechend mit batch * accumulate / nbs skaliert.
overlap_maskboolTrueLegt fest, ob Objektmasken für das Training zu einer einzigen Maske zusammengeführt oder für jedes Objekt separat beibehalten werden sollen. Bei Überlappungen wird die kleinere Maske beim Zusammenführen über die größere gelegt.
mask_ratioint4Verkleinerungsfaktor für Segmentierungsmasken, der die Auflösung der während des Trainings verwendeten Masken beeinflusst. Die Auflösung vorhergesagter Masken wird dadurch nicht verändert.
dropoutfloat0.0Dropout-Rate zur Regularisierung bei Klassifizierungsaufgaben. Verhindert Überanpassung, indem während des Trainings zufällig Einheiten ausgelassen werden.
valboolTrueAktiviert die Validierung während des Trainings und ermöglicht so die regelmäßige Bewertung der Modellleistung anhand eines separaten Datensatzes.
splitstr'val'Für die Validierung während des Trainings verwendete Datensatzaufteilung: val, test oder train. Die Metriken daraus wählen best.pt aus und steuern das vorzeitige Beenden des Trainings.
nmsbool, optionalNoneWählt den Inferenzkopf aus, der bei der Validierung jeder Epoche, der Auswahl von Prüfpunkten und dem vorzeitigen Abbruch verwendet wird. None oder True verwendet One-to-Many mit NMS; False verwendet, sofern verfügbar, den NMS-freien Kopf. Beide Köpfe behalten ihre Trainingsverluste bei.
plotsboolTrueErzeugt und speichert Diagramme der Trainings- und Validierungsmetriken sowie Vorhersagebeispiele und bietet so einen visuellen Einblick in Modellleistung und Lernfortschritt.
compilebool oder strFalseAktiviert die PyTorch-2.x-Graphkompilierung torch.compile mit backend='inductor'. Akzeptiert True → "default", False → deaktiviert oder einen Zeichenfolgenmodus wie "default", "reduce-overhead", "max-autotune-no-cudagraphs". Bei Nichtunterstützung wird mit einer Warnung auf den Eager-Modus zurückgegriffen.
channels_lastboolNoneVerwendet für Faltungen während des Trainings das Speicherformat channels_last (NHWC). None aktiviert es automatisch unter CUDA mit PyTorch 1.11 oder neuer, außer unter Windows, wo es sich als langsamer erwiesen hat. False deaktiviert es, und True fordert es explizit an. Beim Training auf CPU oder MPS wird immer NCHW verwendet (True wird ignoriert und eine Warnung ausgegeben).
max_detint300Maximale Anzahl erkannter Objekte pro Bild während der Trainingsvalidierung. Bei Erkennung, Segmentierung, Pose und OBB wird der Standardwert 300 nur dann auf die höchste Anzahl beschrifteter Objekte in Training oder Validierung erhöht, wenn diese Anzahl über 300 liegt. Andere Werte bleiben unverändert; bei Überschreitung des Grenzwerts wird eine Warnung ausgegeben.
Hinweis zu Einstellungen der Batchgröße

Das Argument batch akzeptiert drei Arten von Werten, und der Trainer fügt zwei Sicherheitsvorkehrungen hinzu:

  • Feste Batchgröße: Lege einen ganzzahligen Wert fest (z. B. batch=16), der die Anzahl der Bilder pro Batch direkt angibt. Beim Training mit mehreren GPUs wird diese globale Batchgröße gleichmäßig auf die GPUs verteilt und muss daher mindestens der Anzahl der GPUs entsprechen; ein Rest wird verworfen (z. B. trainiert batch=15 auf 2 GPUs 7 Bilder pro GPU).
  • Automatikmodus (60 % GPU-Speicher): Verwende batch=-1, um die Batchgröße automatisch so anzupassen, dass etwa 60 % des für das Training verfügbaren CUDA-Speichers genutzt werden.
  • Automatikmodus mit Nutzungsanteil: Lege einen Anteil fest (z. B. batch=0.70), um die Batchgröße anhand des angegebenen Anteils des verfügbaren GPU-Speichers anzupassen.
  • Automatischer Wiederholungsversuch bei Speichermangel: Tritt während der ersten Epoche ein CUDA-Speichermangel auf, halbiert der Trainer automatisch die Stapelgröße und versucht es erneut (bis zu dreimal). Dies gilt nur für das Training mit einer einzelnen GPU; beim Training mit mehreren GPUs (DDP) wird der Fehler sofort ausgelöst.
  • Keine passende Größe gefunden: Wenn keine Batchgröße ein verwendbares Profil ergibt, löst AutoBatch einen aussagekräftigen RuntimeError-Fehler aus, statt stillschweigend auf einen nicht passenden Standardwert zurückzugreifen.

Einstellungen und Hyperparameter für die Datenerweiterung#

Techniken zur Datenerweiterung sind unerlässlich, um die Robustheit und Leistung von YOLO-Modellen zu verbessern. Dazu bringen sie mehr Vielfalt in die Trainingsdaten und helfen dem Modell, besser auf bisher ungesehene Daten zu generalisieren. Die folgende Tabelle erläutert Zweck und Wirkung der einzelnen Argumente zur Datenerweiterung:

ArgumentTypStandardUnterstützte AufgabenBereichBeschreibung
hsv_hfloat0.015detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Passt den Farbton des Bildes um einen Anteil des Farbkreises an und sorgt so für Farbvariationen. Dies hilft dem Modell, auf unterschiedliche Lichtverhältnisse zu generalisieren. Für classify gilt dies nur, wenn auto_augment=None.
hsv_sfloat0.7detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Ändert die Sättigung des Bildes um einen Anteil und beeinflusst so die Farbintensität. Dies eignet sich, um verschiedene Umgebungsbedingungen zu simulieren. Für classify gilt dies nur, wenn auto_augment=None.
hsv_vfloat0.4detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Ändert den Wert (die Helligkeit) des Bildes um einen Anteil und hilft dem Modell, bei unterschiedlichen Lichtverhältnissen gute Ergebnisse zu erzielen. Für classify gilt dies nur, wenn auto_augment=None.
degreesfloat0detect, segment, semantic, depth, pose, obb0.0 - 180Dreht das Bild zufällig innerhalb des angegebenen Winkelbereichs und verbessert so die Fähigkeit des Modells, Objekte in verschiedenen Ausrichtungen zu erkennen.
translatefloat0.1detect, segment, semantic, depth, pose, obb0.0 - 1.0Verschiebt das Bild horizontal und vertikal um einen Anteil der Bildgröße. Dadurch lernt das Modell, teilweise sichtbare Objekte zu erkennen.
scalefloat | tuple0.5detect, segment, semantic, depth, classify, pose, obb0 - 1 oder ein explizites Tupel (min, max) (nicht für classify)Skaliert das Bild mit einem Verstärkungsfaktor und simuliert so Objekte in verschiedenen Entfernungen zur Kamera.
shearfloat0detect, segment, semantic, depth, pose, obb-180 - +180Verzerrt das Bild um einen angegebenen Winkel und ahmt so den Effekt nach, dass Objekte aus verschiedenen Blickwinkeln betrachtet werden.
perspectivefloat0detect, segment, semantic, depth, pose, obb0.0 - 0.001Wendet eine zufällige perspektivische Transformation auf das Bild an und verbessert so die Fähigkeit des Modells, Objekte im dreidimensionalen Raum zu verstehen.
flipudfloat0detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Dreht das Bild mit der angegebenen Wahrscheinlichkeit auf den Kopf und erhöht so die Datenvielfalt, ohne die Merkmale des Objekts zu verändern.
fliplrfloat0.5detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Spiegelt das Bild mit der angegebenen Wahrscheinlichkeit horizontal. Dies eignet sich zum Lernen symmetrischer Objekte und erhöht die Vielfalt des Datensatzes.
bgrfloat0detect, segment, semantic, depth, pose, obb0.0 - 1.0Vertauscht mit der angegebenen Wahrscheinlichkeit die Bildkanäle von RGB zu BGR. Dies erhöht die Robustheit gegenüber einer falschen Kanalreihenfolge.
mosaicfloat1detect, segment, semantic, pose, obb0.0 - 1.0Fügt vier Trainingsbilder zu einem Bild zusammen und simuliert so unterschiedliche Szenenzusammensetzungen und Objektinteraktionen. Eignet sich für ein besseres Verständnis komplexer Szenen.
mixupfloat0detect, segment, semantic, pose, obb0.0 - 1.0Mischt zwei Bilder und ihre Beschriftungen zu einem zusammengesetzten Bild. Durch Rauschen in den Beschriftungen und visuelle Variationen verbessert sich die Generalisierungsfähigkeit des Modells.
cutmixfloat0detect, segment, semantic, pose, obb0.0 - 1.0Kombiniert Teile zweier Bilder zu einer teilweisen Überblendung, wobei die Bereiche unterscheidbar bleiben. Dadurch wird die Robustheit des Modells durch simulierte Verdeckungssituationen verbessert.
copy_pastefloat0segment, semantic, obb0.0 - 1.0Anteil der geeigneten Objekte, die eingefügt werden; flip spiegelt sie innerhalb des Bildes, während mixup diesen Wert auch als Wahrscheinlichkeit für die Anwendung über mehrere Bilder hinweg verwendet.
copy_paste_modestrflipsegment, semantic, obb-Gibt die zu verwendende Strategie copy-paste an. Zur Auswahl stehen 'flip' und 'mixup'.
auto_augmentstrrandaugmentclassify-Wendet eine vordefinierte Augmentierungsrichtlinie ('randaugment', 'autoaugment' oder 'augmix') an, um die Modellleistung durch visuelle Vielfalt zu verbessern.
erasingfloat0.4classify0.0 - 1.0Löscht während des Trainings zufällig Bildbereiche, damit sich das Modell auf weniger offensichtliche Merkmale konzentriert.
augmentationslistNonedetect, segment, semantic, depth, pose, obb-Benutzerdefinierte Albumentations-Transformationen für erweiterte Datenaugmentierung (nur Python-API). Akzeptiert eine Liste von Transformationsobjekten für spezielle Anforderungen an die Augmentierung.

Diese Einstellungen lassen sich an die konkreten Anforderungen des jeweiligen Datensatzes und der Aufgabe anpassen. Durch das Ausprobieren verschiedener Werte findest du möglicherweise die beste Strategie zur Datenerweiterung.

Information

Weitere Informationen zu den Datenerweiterungsoperationen beim Training findest du im Referenzabschnitt.

Protokollierung#

Trainingskennzahlen, Diagramme und Checkpoints werden immer im Verzeichnis des Trainingslaufs gespeichert. Außerdem überträgt Ultralytics sie an jeden installierten und aktivierten Experiment-Tracker: Comet, ClearML, TensorBoard, MLflow, Weights & Biases und DVCLive. Jeder Logger lässt sich über die Ultralytics-Einstellungen aktivieren oder deaktivieren, zum Beispiel mit yolo settings tensorboard=True. Die drei häufigsten Konfigurationen sind unten aufgeführt.

Comet#

Comet ist eine Plattform, mit der Datenwissenschaftler und Entwickler Experimente und Modelle verfolgen, vergleichen, erklären und optimieren können. Sie bietet Kennzahlen in Echtzeit, Code-Unterschiede und die Nachverfolgung von Hyperparametern.

So verwendest du Comet:

Beispiel
# pip install comet_ml
import comet_ml

comet_ml.login()

Melde dich auf der Website bei deinem Comet-Konto an und rufe deinen API-Schlüssel ab. Du musst ihn zu deinen Umgebungsvariablen oder deinem Skript hinzufügen, damit deine Experimente protokolliert werden.

ClearML#

ClearML ist eine Open-Source-Plattform, die die Nachverfolgung von Experimenten automatisiert und die effiziente gemeinsame Nutzung von Ressourcen unterstützt. Sie soll Teams dabei helfen, ihre ML-Arbeit effizienter zu verwalten, auszuführen und zu reproduzieren.

So verwendest du ClearML:

Beispiel
# pip install clearml
import clearml

clearml.browser_login()

Nachdem du dieses Skript ausgeführt hast, musst du dich im Browser bei deinem ClearML-Konto anmelden und deine Sitzung authentifizieren.

TensorBoard#

TensorBoard ist ein Visualisierungswerkzeug für TensorFlow. Damit kannst du deinen TensorFlow-Graphen visualisieren, quantitative Metriken zur Ausführung des Graphen darstellen und zusätzliche Daten wie die hindurchgeleiteten Bilder anzeigen.

So verwendest du TensorBoard in Google Colab:

Beispiel
%load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directory

Um TensorBoard lokal zu verwenden, führe den folgenden Befehl aus und rufe die Ergebnisse unter localhost:6006 auf.

Beispiel
tensorboard --logdir ultralytics/runs # replace with 'runs' directory

Dadurch wird TensorBoard geladen und auf das Verzeichnis verwiesen, in dem deine Trainingsprotokolle gespeichert sind.

Nachdem du deinen Logger eingerichtet hast, starte das Training wie gewohnt. Die Trainingskennzahlen werden automatisch auf der ausgewählten Plattform protokolliert. Dort kannst du die Leistung im Zeitverlauf überwachen, Modelle vergleichen und Verbesserungspotenziale erkennen.

Wie geht es weiter?#

Überprüfe dein trainiertes Modell anhand zurückgehaltener Daten, um seine Genauigkeit unter realen Bedingungen zu beurteilen, und exportiere es anschließend nach ONNX, TensorRT oder in ein anderes Format für die Bereitstellung. Trainierst du mit eigenen Daten statt mit COCO8? Formatiere sie zuerst mithilfe des Leitfadens zu Datensätzen.

Häufig gestellte Fragen#

  • Ja. Das Cloud-Training auf der Ultralytics Platform umfasst kostenlose Nutzungsguthaben für den Einstieg. Lade deinen Datensatz hoch, wähle ein Modell und eine GPU aus und trainiere direkt im Browser.

  • Um mit Ultralytics YOLO26 ein Modell zur Objekterkennung zu trainieren, kannst du entweder die Python-API oder die CLI verwenden. Unten findest du ein Beispiel für beide Möglichkeiten:

    Beispiel für Training mit einer GPU und mit CPU
    from ultralytics import YOLO
    
    # Ein Modell laden
    model = YOLO("yolo26n.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)
    
    # Das Modell trainieren
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

    Weitere Informationen findest du im Abschnitt Trainingseinstellungen.

  • Zu den wichtigsten Funktionen des Trainingsmodus von Ultralytics YOLO26 gehören:

    • Automatischer Datensatz-Download: Lädt standardisierte Datensätze wie COCO, VOC und ImageNet automatisch herunter.
    • Unterstützung mehrerer GPUs: Verteile das Training auf mehrere GPUs, um die Verarbeitung zu beschleunigen.
    • Konfiguration von Hyperparametern: Passe Hyperparameter über YAML-Dateien oder CLI-Argumente an.
    • Visualisierung und Überwachung: Verfolge Trainingsmetriken in Echtzeit und gewinne so bessere Einblicke.

    Diese Funktionen machen das Training effizient und an deine Anforderungen anpassbar. Weitere Informationen findest du im Abschnitt Wichtige Funktionen des Trainingsmodus.

  • Um das Training nach einer Unterbrechung fortzusetzen, setze das Argument resume auf True und gib den Pfad zum zuletzt gespeicherten Checkpoint an.

    Beispiel zum Fortsetzen des Trainings
    from ultralytics import YOLO
    
    # Modell mit teilweise abgeschlossenem Training laden
    model = YOLO("path/to/last.pt")
    
    # Training fortsetzen
    results = model.train(resume=True)

    Weitere Informationen findest du im Abschnitt Unterbrochene Trainingsläufe fortsetzen.

  • Ein Klassenungleichgewicht liegt vor, wenn einige Klassen in deinen Trainingsdaten deutlich weniger Beispiele aufweisen als andere. Dadurch kann das Modell seltene Klassen nur schlecht erkennen. Ultralytics YOLO unterstützt die Gewichtung von Klassen über das Argument cls_pw, um dieses Problem anzugehen. Die Gewichtung des Verlusts funktioniert am besten als letzter Schritt, nachdem du seltene Klassen gesammelt und überrepräsentiert hast, wie unter Umgang mit Klassenungleichgewicht beschrieben.

    Das Argument cls_pw steuert die Stärke der Klassengewichtung anhand der inversen Klassenhäufigkeit:

    • cls_pw=0.0 (Standard): Deaktiviert die Klassengewichtung
    • cls_pw=1.0: Wendet die vollständige Gewichtung anhand der inversen Häufigkeit an
    • Werte zwischen 0.0 und 1.0: Ermöglichen eine teilweise Gewichtung bei mäßiger Ungleichverteilung

    Die Klassengewichte werden als (1.0 / class_counts) ^ cls_pw berechnet und so normalisiert, dass ihr Mittelwert 1.0 beträgt. class_counts ist die Anzahl der annotierten Objekte pro Klasse oder bei der Klassifizierung die Anzahl der Trainingsbilder pro Klasse. Klassen ohne Trainingsannotationen, etwa solche, die durch classes= ausgeschlossen wurden, erhalten ein Gewicht von 1.0. Bei der semantischen Segmentierung werden die Gewichte stattdessen anhand der Pixelfrequenz berechnet, und zwar als (1.0 / ln(1.02 + p)) ^ cls_pw. Dabei ist p der Anteil der annotierten Trainingspixel in jeder Klasse, sodass eine Klasse ohne annotierte Pixel das höchste Gewicht erhält.

    Training mit unausgewogenem Datensatz
    from ultralytics import YOLO
    
    # Vortrainiertes Modell laden
    model = YOLO("yolo26n.pt")
    
    # Bei stark unausgewogenen Daten mit vollständiger Klassengewichtung trainieren
    results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0)
    
    # Oder bei mäßiger Ungleichverteilung teilweise gewichten (0.25)
    results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)
    Tipp

    Beginne bei mäßig unausgewogenen Datensätzen mit cls_pw=0.25 und erhöhe den Wert auf 1.0, wenn die seltenen Klassen weiterhin schlechter abschneiden. In den Trainingsprotokollen kannst du die berechneten Klassengewichte überprüfen und so die Gewichtsverteilung kontrollieren.

  • Ja, Ultralytics YOLO26 unterstützt das Training auf Apple-Silicon-Chips mit dem Framework Metal Performance Shaders (MPS). Gib mps als Trainingsgerät an.

    Beispiel für MPS-Training
    from ultralytics import YOLO
    
    # Vortrainiertes Modell laden
    model = YOLO("yolo26n.pt")
    
    # Modell auf einem Apple-Chip mit Apple Silicon trainieren (M1/M2/M3/M4)
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

    Weitere Informationen findest du im Abschnitt Training mit Apple Silicon und MPS.

  • Mit Ultralytics YOLO26 kannst du über Argumente verschiedene Trainingseinstellungen wie Stapelgröße, Lernrate, Epochen und mehr konfigurieren. Hier ein kurzer Überblick:

    ArgumentStandardBeschreibung
    modelNonePfad zur Modelldatei für das Training.
    dataNonePfad zur YAML-Datei des Datensatzes (z. B. coco8.yaml) oder bei der Klassifizierung zu einem Datensatzverzeichnis oder -namen (z. B. imagenet10).
    epochs100Gesamtzahl der Trainingsepochen.
    batch16Stapelgröße, die als Ganzzahl oder im automatischen Modus festgelegt werden kann.
    imgsz640Zielbildgröße für das Training.
    deviceNoneRechengerät(e) für das Training, zum Beispiel cpu, 0, 0,1 oder mps.
    saveTrueAktiviert das Speichern von Trainings-Checkpoints und den endgültigen Modellgewichten.

    Eine ausführliche Anleitung zu den Trainingseinstellungen findest du im Abschnitt Trainingseinstellungen.

Kommentare1.074

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.

  1. drcosimoGitHub

    Hi there, I' m new to this field and I'm trying to train a YOLO model for detection and tracking of video streams for security.

    Until now I have managed to create my pipeline for training and I want to understand if it's a correct/possible approach:

    1. Load a pretrained model from yolo

    2. transfer learning with my custom dataset that possibly can focus on just some classes(person,car,truck,bus,bycicle)

    3. Validate model to see how it performs

    4. Operate a tuning with the custom best model and using my custom dataset

    5. Retrain the initial pretrained model with my custom dataset and the best hyperparameters found in the tuning process.

    6. Validate final model

    The questions are several:

    • The above approach is logically correct or it has flaws?
    • Is it correct to narrow the detected classes? Or it isn't crucial to the precision of the model?
    • When tuning(if its a correct approach) should i use my dataset or try the coco dataset to keep generalization?
    • When tuning should i specify the classes to detect?
    • When retraining should I use the first pretrained model or it is better to use my custom trained model?
    • In the final training am I using the correct parameters?

    Here the code of the pipeline:

    from ultralytics import YOLO import yaml

    load pretrained model from coco dataset

    model:YOLO = YOLO('yolov8n.yaml').load('yolov8n.pt')

    train_classes = []

    NOTE if you're using COCO format, the new dataset should also be in COCO format.

    operate transfer learning with my custom dataset, narrowing the classes to the ones I want to detect

    model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,optimizer='AdamW',device=[0,1],augment=True,name='custom_model')

    load custom model

    custom_model = YOLO('path/to/best.pt')

    validate custom model

    custom_model.val()

    try tuning to find the best hyperparameters for my custom model

    custom_model.tune(data='custom_data.yaml', epochs=50, iterations=100,optimizer="AdamW", plots=True,save=True,val=True)

    load best hyperparameters

    cfg = yaml.load(open('path/to/best_hyperparameters.yaml'))

    retrain custom model from pretrained on coco with best hyperparameters

    model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,device=[0,1],name='custom_model',exist_ok=True,optimizer='AdamW',**cfg)

    load and validate

    tuned_custom_model = YOLO('path/to/best.pt')

    tuned_custom_model.val()


    Thank you for your effort and time in this project!

    3
    1. Paula DerrengerUltralytics(bearbeitet)

      Hello,

      Your approach to training a YOLO model for detection and tracking is well-thought-out and mostly aligns with best practices. Here are some insights and answers to your questions:

      1. Approach Validity: Your steps are logically sound. Starting with a pretrained model and applying transfer learning to your specific classes is a recommended strategy. Validating and tuning based on the performance helps refine the model further.

      2. Narrowing Detected Classes: It's perfectly fine to focus on specific classes if those are the only ones relevant to your use case. This can help improve the model's performance by reducing the complexity of the problem it needs to solve.

      3. Dataset for Tuning: Use your custom dataset for tuning. This ensures that the hyperparameters are optimized for the specific characteristics of your data rather than the general characteristics of the COCO dataset.

      4. Specifying Classes During Tuning: When tuning, you should specify the classes if your dataset is a subset of the original classes used in the pretrained model. This helps in focusing the model’s learning and evaluation on relevant classes.

      5. Model for Retraining: Tuning only finds hyperparameters, so the usual practice is to train again from the original pretrained model with the best hyperparameters, as in your step 5. Continuing from the already fine-tuned model is also possible, but then it effectively trains for longer, which makes the result harder to compare with the tuning runs.

      6. Parameters for Final Training: The parameters should be chosen based on the results of your tuning. Ensure that they are the ones that gave the best validation performance during the tuning phase.

      Keep up the great work, and don't hesitate to reach out if you have more questions!

    2. drcosimoGitHub

      Thank you very much for you response. I adjusted my script to follow your insights. I have another question regarding transfer learning. The normal approach in transfer learning is to freeze the first n layers to preserve the more generic feature extraction properties of an already trained model and then it is retrained letting only the remaining layers update. I found the callback function to achieve this. My question is, applying the fine-tuning as specified by ultralytics documentation has the same effect? What I mean is: executing the train method again on a pretrained model changing the dataset causes the underlying library to execute the freeze automatically? If it isn't the case it is not clear to me why the fine-tuning is said to have the same effect as applying transfer learning.

      Another question is: it is useful to take a pretrained model from ultralytics and train it with the coco dataset? Because from what I know the pretrained model is already trained using coco dataset. Doing such a thing following the logic you provide for fine-tuning would be essentially the same as resuming a training / do the same train with more epochs?

      Thank you again for your time.

    3. Paula DerrengerUltralytics

      Hello,

      Thank you for your follow-up questions. Let's address each of them:

      1. Freezing Layers in Transfer Learning: The Ultralytics YOLO framework does not automatically freeze any layers when you initiate training, even if you're using a pretrained model. If you want to freeze the first N layers (common in transfer learning to preserve learned features), you must explicitly specify this in your training script. This is different from some other frameworks that might automate this aspect of transfer learning.

      2. Training on COCO Dataset with a Pretrained Model: If the pretrained model you are using was already trained on the COCO dataset, retraining it on the same dataset without significant changes or additional data might not yield substantial improvements. It could be beneficial for fine-tuning if you've made modifications to the model architecture or if you're using a significantly altered version of the dataset. However, generally, this approach would indeed be akin to simply extending the training duration.

      For fine-tuning and transfer learning, it's crucial to tailor the approach based on what changes you've made to the dataset or model and your specific goals (e.g., improving accuracy, adapting to new classes, etc.).

      I hope this clarifies your queries! If you have more questions or need further assistance, feel free to ask.

    1. Paula DerrengerUltralytics

      哈哈,确实,“train”翻译成“火车”听起来很有趣 😄。这里的“train”应该翻译为“训练”,指的是在机器学习中对模型进行训练,以提高其准确性和效率。感谢您指出这个问题,我们会尽快修正翻译错误。如果您有任何其他建议或问题,欢迎随时告诉我们!🚀

      2
  2. Syedshajib55GitHub

    Hi, does platform.ultralytics currently support using custom PyTorch modules directly via a YAML configuration without modifying tasks.py or the core source code? We are attempting to train a custom architecture (e.g., YOLO26) and want to know if there is an existing feature for dynamic module registration.

    1
    1. Muh-7GitHub

      Hi, As far as I know, not at the moment. Ultralytics doesn't seem to have a built-in dynamic registration system where you can define a custom PyTorch module outside the repo and then use it directly in the YAML.

      Usually, the custom module still needs to be imported/registered in tasks.py so that parse_model() can resolve it from the YAML.

      It would be really useful if Ultralytics added something like a register_module() API for this, though.

    2. Murat Raimbekov

      @Syedshajib55 @Muh-7 Platform can train any model that the ultralytics Python package can build, including custom architectures from a modified package or fork. The custom code runs on your own hardware; Platform receives real-time metrics, console and system logs, plots, and the final weights.

      There is no dynamic registration API. parse_model() resolves layer names from the ultralytics.nn.tasks namespace, so a name in your YAML must exist there. You don't need to edit tasks.py for that — expose the class from your own package before building the model:

      import ultralytics.nn.tasks as tasks
      from my_custom_package import MyBlock
      
      tasks.MyBlock = MyBlock  # now `[-1, 1, MyBlock, [...]]` resolves in the YAML

      Full local training with metric streaming to Platform:

      pip install "ultralytics>=8.4.120"
      export ULTRALYTICS_API_KEY="YOUR_API_KEY"
      import ultralytics.nn.tasks as tasks
      from my_custom_package import MyBlock
      from ultralytics import YOLO
      
      tasks.MyBlock = MyBlock
      
      model = YOLO("custom-model.yaml")  # YAML referencing MyBlock
      model.train(
          data="ul://username/datasets/my-dataset",
          epochs=100,
          project="username/my-project",
          name="custom-architecture",
      )

      project and name enable the Platform integration automatically; nothing else is required. Verified on 8.4.157 with a custom nn.Module inserted into a YOLO26n YAML: the model builds, trains, and appears on Platform as a completed run with weights and train args.

      One caveat: the saved .pt pickles the class by import path (my_custom_package.MyBlock), so any environment that loads it needs that package importable — otherwise loading fails with ModuleNotFoundError. That includes Platform-side features that load the uploaded weights with the stock package (Predict, Export, Deploy); local training and streaming are unaffected. Setup details: https://docs.ultralytics.com/platform/train/cloud-training/#remote-training

  3. RussellLee12345GitHub

    Hello all,

    I want my training images to rotate 360 degrees randomly. How do I set the hyper-parameter: degrees?

    Thanks a lot.

    1
    1. Glenn JocherUltralytics

      @RussellLee12345 to rotate your training images randomly up to 360 degrees, set the degrees parameter to 180 in your training configuration. This allows for rotations within the range of -180 to +180 degrees. For more details, see the augmentation settings in the Train Settings documentation.

  4. GKYofficeGitHub

    Please tell me how to set imgsz when I use the yolo11 model for training. Can it only be an integer (this means that the final input is a square)? After I modify this parameter, will the input interface of the network change the input of data? There are corresponding transformations, such as imgsz=1280, does it mean that my input data will be resized to 1280*1280 and input into the network for training?

    Thanks!

    1
    1. Glenn JocherUltralytics

      @GKYoffice when using the YOLO11 model, imgsz can be set as an integer, which resizes the input data to a square of that size (e.g., 1280x1280). This parameter adjusts the input dimensions for training. For more details, please visit the training documentation.

  5. IruhDegSetGitHub

    hi, I'm just wondering if yolov8 accepts class weights, in the data.yaml file:

    names: ['class 1', 'class 2', 'class 3']
    classes_weights: [c1_weight, c2_weight, c3_weight]

    if no how to incorpoorate wighted loss in yolov8 THX

    1
    1. Glenn JocherUltralytics

      @IruhDegSet yOLOv8 does not directly support class weights in the data.yaml file. To incorporate weighted loss, you can modify the loss function in the training script to apply different weights to each class. For more details, you might explore custom loss implementations in PyTorch.

    2. Glenn JocherUltralytics(bearbeitet)

      Yes, YOLO11 supports similar features, including training and hyperparameter customization. For specific details on YOLO11, please refer to the documentation or the relevant sections in the repository.

  6. User

    Dear author, how are the weights of these three losses set: box: 7.5, cls: 0.5, dfl: 1.5? Are they adjusted on the COCO validation, manually adjusted, or obtained through hyperparameter search? For the model I trained, the output confidence scores are very low. I directly increased the weight of cls by 10 times, but the effect did not improve. What other methods can I take?

    1
    1. Glenn JocherUltralytics

      @Stephen-Hao the weights for the box, cls, and dfl losses in YOLOv8 are typically set based on empirical results and fine-tuning on standard datasets like COCO. These values are chosen to balance the contributions of each loss component to the overall training process. If increasing the cls weight did not improve your model's performance, consider the following approaches:

      1. Hyperparameter Tuning: Experiment with other hyperparameters such as learning rate, batch size, and augmentation settings.
      2. Data Quality: Ensure your dataset is well-labeled and balanced. Poor quality data can significantly affect model performance.
      3. Training Duration: Increase the number of epochs to allow the model more time to learn.
      4. Validation: Regularly validate your model to monitor overfitting and adjust training strategies accordingly.

      For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.

    2. Glenn JocherUltralytics

      @Stephen-Hao thank you for your question! The weights for box, cls, and dfl losses are typically set based on empirical results and fine-tuning on standard datasets like COCO. If increasing the cls weight didn't improve your model's performance, consider experimenting with other hyperparameters such as learning rate, batch size, and augmentation settings. Additionally, ensure your dataset is well-labeled and balanced. For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.

    1. Glenn JocherUltralytics(bearbeitet)

      Hey there! 🙌 It's awesome that you're looking to further improve your model with new data. To re-train a pre-trained model on a new dataset, you can simply follow these steps:

      1. Make sure your new dataset is prepared in the same YOLO format as your initial training (a dataset YAML plus one .txt label file per image).

      2. Load your pre-trained model using the YOLO loading method, then specify your new dataset in the train method. Here's a quick code snippet for clarity:

        from ultralytics import YOLO
        
        # Load your pre-trained model
        model = YOLO('path/to/your/pretrained/model.pt') 
        
        # Start training on the new dataset
        results = model.train(data='path/to/your/new/dataset.yaml', epochs=50, imgsz=640)

      Just replace 'path/to/your/pretrained/model.pt' and 'path/to/your/new/dataset.yaml' with the actual paths to your model and new dataset config file, respectively. Adjust the epochs and imgsz (image size) to suit your needs. 🛠️

      That's it! Your model will now continue training on the new dataset. If you have any further questions or run into issues, feel free to ask. Happy training! 🚀

  7. songziang182GitHub

    谢谢你们开发了这么完善的 yolov8🙏, 我想问一下,这两种训练方式的区别 model = YOLO('yolov8n.pt') model = YOLO('yolov8n.yaml').load('yolov8n.pt') model.train(.........)

    1
    1. Paula DerrengerUltralytics

      Hello there! 😊

      The main difference between the two training methods you've mentioned:

      1. model = YOLO('yolov8n.pt'): This directly loads a pretrained YOLOv8n model. It's the simplest way to load a model that has already been trained, making it ready for further training, evaluation, or inference right away.

      2. model = YOLO('yolov8n.yaml').load('yolov8n.pt'): This approach builds a new model from the YAML configuration file and then transfers the weights from the pretrained .pt model. It's a two-step process, where the model is first constructed based on the architecture defined in the YAML file, and then the weights from a pretrained model are loaded. This method is useful when you want to customize the model architecture before loading the weights.

      Both methods ultimately get you to a similar starting point for continuing training or making predictions. The choice depends on whether you need to customize the model architecture as defined in the YAML file before applying the pretrained weights.

      Let me know if this helps or if you have more questions!

    2. songziang182GitHub

      Thank you for answering me. I find it very useful. I have another question, which is the configuration file yolov8n.yaml. I didn’t find where it is. Can I adjust the scale of the model, for example, n, s, m, l, etc., is this the case?

    3. Paula DerrengerUltralytics(bearbeitet)

      Hey! 😊 Thank you for your kind words, and I'm glad the information was helpful to you!

      Regarding the yolov8n.yaml configuration file, it defines the architecture for YOLOv8 models. All scales share one model file (yolov8.yaml) that contains a scales section mapping each letter to [depth, width, max_channels]; the letter in the name you load (yolov8n.yaml, yolov8s.yaml, ...) selects the scale:

      scales:
        n: [0.33, 0.25, 1024]
        s: [0.33, 0.50, 1024]

      To create or modify a model, copy the YAML from the Ultralytics GitHub repository, edit the layers or scales, then load it together with the pretrained weights as you mentioned:

      model = YOLO('path/to/custom_yolov8.yaml').load('yolov8n.pt')
      model.train(.........)

      Model changes can require a solid understanding of the network architecture to be effective.

      I hope this clarifies your question! Feel free to reach out if you have further queries or need more examples. 😊

  8. vonzoGitHub

    So, imgsz works different when training than when predicting?

    For train: if it's an int the ratio will be kept and the train function will take care of that (can't be a tuple). For predict: if it's an int the image will be resized as a square of size imgsz x imgsz, if it's a tuple the image will be resized using HxW and the user has to take care of the ratio and stride.

    Is this right? I would add a comment in the doc to avoid confusions

    1
    1. Paula DerrengerUltralytics(bearbeitet)

      You've got it mostly right! 👍 For training (train), imgsz is an int, the aspect ratio is maintained and resizing is handled internally. It can't be a tuple. For prediction (predict), an int imgsz resizes the longest side to imgsz while keeping the aspect ratio, with padding only up to a multiple of the model stride (so the image is not forced into a square), and a [h, w] list sets the size explicitly.

      Great suggestion on the documentation comment – clarity is key! If you have any more questions or need further examples, feel free to ask. 😊