Modelltraining mit Ultralytics YOLO
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.
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.
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.
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])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.
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.pyDas 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.shfrom 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.
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:
- geringerer aktueller Auslastung
- 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:
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:
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=MuSGDDie Implementierung findest du in ultralytics/optim/muon.py und die Logik zur automatischen Optimiererauswahl in BaseTrainer.build_optimizer.
| Argument | Typ | Standard | Beschreibung |
|---|---|---|---|
model | str | None | Gibt 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. |
data | str | None | Pfad 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). |
epochs | int | 100 | Gesamtzahl der Trainingsepochen. Jede Epoche entspricht einem vollständigen Durchlauf durch den gesamten Datensatz. Dieser Wert wirkt sich auf die Trainingsdauer und die Modellleistung aus. |
time | float | None | Maximale 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. |
patience | int | 100 | Anzahl 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. |
batch | int oder float | 16 | Batchgröß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). |
imgsz | int | 640 | Zielbildgröß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. |
save | bool | True | Aktiviert das Speichern von Trainingsprüfpunkten und den finalen Modellgewichten. Nützlich, um das Training fortzusetzen oder das Modell bereitzustellen. |
save_period | int | -1 | Hä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. |
cache | bool oder str | False | Aktiviert 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. |
tile | bool oder int | False | Erweitert 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. |
device | int oder str oder list | None | Gibt 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]). |
workers | int | 8 | Anzahl 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. |
project | str | None | Name des Projektverzeichnisses, in dem die Trainingsergebnisse gespeichert werden. Ein relativer Pfad wird unter runs_dir/<task> abgelegt, ein absoluter Pfad wird unverändert verwendet. |
name | str | None | Name des Trainingslaufs. Wird verwendet, um im Projektordner ein Unterverzeichnis für Trainingsprotokolle und -ausgaben anzulegen. |
exist_ok | bool | False | Wenn 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_dir | str | None | Gibt 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. |
pretrained | bool oder str | True | Legt 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_remap | bool | True | Beim 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. |
optimizer | str | '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. |
seed | int | 0 | Legt den Zufallsstartwert für das Training fest und gewährleistet so die Reproduzierbarkeit der Ergebnisse bei Läufen mit denselben Konfigurationen. |
deterministic | bool | True | Erzwingt die Verwendung deterministischer Algorithmen und gewährleistet die Reproduzierbarkeit. Die Einschränkung nichtdeterministischer Algorithmen kann jedoch Leistung und Geschwindigkeit beeinträchtigen. |
verbose | bool | True | Aktiviert ausführliche Ausgaben während des Trainings und zeigt Fortschrittsbalken, Metriken für jede Epoche und zusätzliche Trainingsinformationen in der Konsole an. |
single_cls | bool | False | Behandelt 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. |
classes | list[int] | None | Gibt 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. |
rect | bool | False | Ermö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_scale | float | 0.0 | Variiert 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_lr | bool | False | Verwendet 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_mosaic | int | 10 | Deaktiviert die Mosaik-Datenerweiterung in den letzten N Epochen, um das Training vor dem Abschluss zu stabilisieren. Mit dem Wert 0 wird diese Funktion deaktiviert. |
resume | bool | False | Setzt 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. |
amp | bool oder str | True | Legt die Trainingsgenauigkeit fest: True oder "fp16" verwendet FP16, "bf16" BF16 auf unterstützten CUDA-Geräten und False oder "fp32" FP32. |
quantize | int oder str | None | Setze 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. |
fraction | float, int oder list | 1.0 | Teilmenge 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. |
profile | bool | False | Aktiviert während des Trainings die Profilierung der ONNX- und TensorRT-Geschwindigkeiten, was für die Optimierung der Modellbereitstellung nützlich ist. |
freeze | int oder list | None | Friert 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. |
lr0 | float | 0.01 | Anfä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. |
lrf | float | 0.01 | Finale Lernrate als Anteil der anfänglichen Lernrate = (lr0 * lrf), die zusammen mit Schedulern zur Anpassung der Lernrate im Zeitverlauf verwendet wird. |
momentum | float | 0.937 | Momentum 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_decay | float | 0.0005 | L2-Regularisierung, die große Gewichte bestraft, um Überanpassung zu verhindern. |
warmup_epochs | float | 3.0 | Aufwä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_momentum | float | 0.8 | Anfangs-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_lr | float | 0.1 | Lernrate 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_model | str | None | Pfad 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. |
dis | float | 6.0 | Gewichtung des Destillationsverlusts, der zu den standardmäßigen Erkennungsverlusten hinzukommt. Höhere Werte verstärken den Einfluss der Merkmalsvorgaben des Lehrermodells. |
box | float | 7.5 | Gewichtung der Box-Verlustkomponente in der Verlustfunktion, die bestimmt, wie stark die präzise Vorhersage der Koordinaten des Begrenzungsrahmens gewichtet wird. |
cls | float | 0.5 | Gewichtung des Klassifizierungsverlusts in der Gesamtverlustfunktion. Beeinflusst, wie wichtig eine korrekte Klassenvorhersage im Vergleich zu anderen Komponenten ist. |
cls_pw | float | 0.0 | Potenz 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. |
dfl | float | 1.5 | Gewichtung 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). |
pose | float | 12.0 | Gewichtung 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. |
kobj | float | 1.0 | Gewichtung des Objektivitätsverlusts für Schlüsselpunkte bei Posenschätzungsmodellen. Stimmt die Erkennungssicherheit auf die Genauigkeit der Posenschätzung ab. |
rle | float | 1.0 | Gewichtung des Verlusts der residualen Log-Likelihood-Schätzung in Posenschätzungsmodellen. Beeinflusst die Präzision der Lokalisierung von Schlüsselpunkten. |
angle | float | 1.0 | Gewichtung des Winkelverlusts in OBB-Modellen. Beeinflusst die Präzision der Winkelvorhersagen orientierter Begrenzungsrahmen. |
dlog | float | 1.0 | Gewichtung des skaleninvarianten logarithmischen Verlusts (SILog) in Modellen zur Tiefenschätzung; dieser Hauptterm bestimmt die Tiefengenauigkeit. |
dgrad | float | 0.5 | Gewichtung des Gradientenverlusts in Modellen zur Tiefenschätzung. Bestraft Fehler an Tiefenkanten und fördert schärfere Oberflächengrenzen. |
dlam | float | 1.0 | Varianzfaktor 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. |
nbs | int | 64 | Soll-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_mask | bool | True | Legt 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_ratio | int | 4 | Verkleinerungsfaktor 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. |
dropout | float | 0.0 | Dropout-Rate zur Regularisierung bei Klassifizierungsaufgaben. Verhindert Überanpassung, indem während des Trainings zufällig Einheiten ausgelassen werden. |
val | bool | True | Aktiviert die Validierung während des Trainings und ermöglicht so die regelmäßige Bewertung der Modellleistung anhand eines separaten Datensatzes. |
split | str | '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. |
nms | bool, optional | None | Wä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. |
plots | bool | True | Erzeugt und speichert Diagramme der Trainings- und Validierungsmetriken sowie Vorhersagebeispiele und bietet so einen visuellen Einblick in Modellleistung und Lernfortschritt. |
compile | bool oder str | False | Aktiviert 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_last | bool | None | Verwendet 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_det | int | 300 | Maximale 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. |
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. trainiertbatch=15auf 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:
| Argument | Typ | Standard | Unterstützte Aufgaben | Bereich | Beschreibung |
|---|---|---|---|---|---|
hsv_h | float | 0.015 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Passt 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_s | float | 0.7 | detect, segment, semantic, depth, classify, pose, obb | 0.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_v | float | 0.4 | detect, segment, semantic, depth, classify, pose, obb | 0.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. |
degrees | float | 0 | detect, segment, semantic, depth, pose, obb | 0.0 - 180 | Dreht das Bild zufällig innerhalb des angegebenen Winkelbereichs und verbessert so die Fähigkeit des Modells, Objekte in verschiedenen Ausrichtungen zu erkennen. |
translate | float | 0.1 | detect, segment, semantic, depth, pose, obb | 0.0 - 1.0 | Verschiebt das Bild horizontal und vertikal um einen Anteil der Bildgröße. Dadurch lernt das Modell, teilweise sichtbare Objekte zu erkennen. |
scale | float | tuple | 0.5 | detect, segment, semantic, depth, classify, pose, obb | 0 - 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. |
shear | float | 0 | detect, segment, semantic, depth, pose, obb | -180 - +180 | Verzerrt das Bild um einen angegebenen Winkel und ahmt so den Effekt nach, dass Objekte aus verschiedenen Blickwinkeln betrachtet werden. |
perspective | float | 0 | detect, segment, semantic, depth, pose, obb | 0.0 - 0.001 | Wendet eine zufällige perspektivische Transformation auf das Bild an und verbessert so die Fähigkeit des Modells, Objekte im dreidimensionalen Raum zu verstehen. |
flipud | float | 0 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Dreht das Bild mit der angegebenen Wahrscheinlichkeit auf den Kopf und erhöht so die Datenvielfalt, ohne die Merkmale des Objekts zu verändern. |
fliplr | float | 0.5 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Spiegelt das Bild mit der angegebenen Wahrscheinlichkeit horizontal. Dies eignet sich zum Lernen symmetrischer Objekte und erhöht die Vielfalt des Datensatzes. |
bgr | float | 0 | detect, segment, semantic, depth, pose, obb | 0.0 - 1.0 | Vertauscht mit der angegebenen Wahrscheinlichkeit die Bildkanäle von RGB zu BGR. Dies erhöht die Robustheit gegenüber einer falschen Kanalreihenfolge. |
mosaic | float | 1 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Fügt vier Trainingsbilder zu einem Bild zusammen und simuliert so unterschiedliche Szenenzusammensetzungen und Objektinteraktionen. Eignet sich für ein besseres Verständnis komplexer Szenen. |
mixup | float | 0 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Mischt zwei Bilder und ihre Beschriftungen zu einem zusammengesetzten Bild. Durch Rauschen in den Beschriftungen und visuelle Variationen verbessert sich die Generalisierungsfähigkeit des Modells. |
cutmix | float | 0 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Kombiniert Teile zweier Bilder zu einer teilweisen Überblendung, wobei die Bereiche unterscheidbar bleiben. Dadurch wird die Robustheit des Modells durch simulierte Verdeckungssituationen verbessert. |
copy_paste | float | 0 | segment, semantic, obb | 0.0 - 1.0 | Anteil 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_mode | str | flip | segment, semantic, obb | - | Gibt die zu verwendende Strategie copy-paste an. Zur Auswahl stehen 'flip' und 'mixup'. |
auto_augment | str | randaugment | classify | - | Wendet eine vordefinierte Augmentierungsrichtlinie ('randaugment', 'autoaugment' oder 'augmix') an, um die Modellleistung durch visuelle Vielfalt zu verbessern. |
erasing | float | 0.4 | classify | 0.0 - 1.0 | Löscht während des Trainings zufällig Bildbereiche, damit sich das Modell auf weniger offensichtliche Merkmale konzentriert. |
augmentations | list | None | detect, 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.
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:
# 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:
# 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:
%load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directoryUm TensorBoard lokal zu verwenden, führe den folgenden Befehl aus und rufe die Ergebnisse unter localhost:6006 auf.
tensorboard --logdir ultralytics/runs # replace with 'runs' directoryDadurch 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 CPUfrom 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
resumeaufTrueund gib den Pfad zum zuletzt gespeicherten Checkpoint an.Beispiel zum Fortsetzen des Trainingsfrom 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_pwsteuert die Stärke der Klassengewichtung anhand der inversen Klassenhäufigkeit:cls_pw=0.0(Standard): Deaktiviert die Klassengewichtungcls_pw=1.0: Wendet die vollständige Gewichtung anhand der inversen Häufigkeit an- Werte zwischen
0.0und1.0: Ermöglichen eine teilweise Gewichtung bei mäßiger Ungleichverteilung
Die Klassengewichte werden als
(1.0 / class_counts) ^ cls_pwberechnet und so normalisiert, dass ihr Mittelwert 1.0 beträgt.class_countsist die Anzahl der annotierten Objekte pro Klasse oder bei der Klassifizierung die Anzahl der Trainingsbilder pro Klasse. Klassen ohne Trainingsannotationen, etwa solche, die durchclasses=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 istpder Anteil der annotierten Trainingspixel in jeder Klasse, sodass eine Klasse ohne annotierte Pixel das höchste Gewicht erhält.Training mit unausgewogenem Datensatzfrom 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)TippBeginne bei mäßig unausgewogenen Datensätzen mit
cls_pw=0.25und erhöhe den Wert auf1.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
mpsals Trainingsgerät an.Beispiel für MPS-Trainingfrom 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:
Argument Standard Beschreibung 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,1odermps.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.
drcosimo
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:
-
Load a pretrained model from yolo
-
transfer learning with my custom dataset that possibly can focus on just some classes(person,car,truck,bus,bycicle)
-
Validate model to see how it performs
-
Operate a tuning with the custom best model and using my custom dataset
-
Retrain the initial pretrained model with my custom dataset and the best hyperparameters found in the tuning process.
-
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
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:
-
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.
-
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.
-
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.
-
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.
-
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.
-
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!
-
drcosimo
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.
Paula DerrengerUltralyticsHello,
Thank you for your follow-up questions. Let's address each of them:
-
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.
-
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.
-
-
wangztao
这个翻译太那啥了吧, train翻译成火车?
3
Paula DerrengerUltralytics哈哈,确实,“train”翻译成“火车”听起来很有趣 😄。这里的“train”应该翻译为“训练”,指的是在机器学习中对模型进行训练,以提高其准确性和效率。感谢您指出这个问题,我们会尽快修正翻译错误。如果您有任何其他建议或问题,欢迎随时告诉我们!🚀
2
Syedshajib55
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.
1Muh-7
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.pyso thatparse_model()can resolve it from the YAML.It would be really useful if Ultralytics added something like a
register_module()API for this, though.
Murat Raimbekov@Syedshajib55 @Muh-7 Platform can train any model that the
ultralyticsPython 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 theultralytics.nn.tasksnamespace, so a name in your YAML must exist there. You don't need to edittasks.pyfor 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 YAMLFull 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", )projectandnameenable the Platform integration automatically; nothing else is required. Verified on 8.4.157 with a customnn.Moduleinserted 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
.ptpickles the class by import path (my_custom_package.MyBlock), so any environment that loads it needs that package importable — otherwise loading fails withModuleNotFoundError. 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
RussellLee12345
Hello all,
I want my training images to rotate 360 degrees randomly. How do I set the hyper-parameter: degrees?
Thanks a lot.
1
Glenn JocherUltralytics@RussellLee12345 to rotate your training images randomly up to 360 degrees, set the
degreesparameter to180in 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.
GKYoffice
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
Glenn JocherUltralytics@GKYoffice when using the YOLO11 model,
imgszcan 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.
IruhDegSet
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
1IruhDegSet
I forgot to mention that the task is segmentation not bb detection
1
Glenn JocherUltralytics@IruhDegSet yOLOv8 does not directly support class weights in the
data.yamlfile. 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.IruhDegSet
@glenn-jocher thank you for your reply, does this apply on yolo v 11 too?
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.
UserDear 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
Glenn JocherUltralytics@Stephen-Hao the weights for the
box,cls, anddfllosses 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 theclsweight did not improve your model's performance, consider the following approaches:- Hyperparameter Tuning: Experiment with other hyperparameters such as learning rate, batch size, and augmentation settings.
- Data Quality: Ensure your dataset is well-labeled and balanced. Poor quality data can significantly affect model performance.
- Training Duration: Increase the number of epochs to allow the model more time to learn.
- 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.
UserThank you a lot!
Glenn JocherUltralytics@Stephen-Hao thank you for your question! The weights for
box,cls, anddfllosses are typically set based on empirical results and fine-tuning on standard datasets like COCO. If increasing theclsweight 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.
karthikUthaman
how to train a trained model again with new dataset
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:
-
Make sure your new dataset is prepared in the same YOLO format as your initial training (a dataset YAML plus one
.txtlabel file per image). -
Load your pre-trained model using the
YOLOloading method, then specify your new dataset in thetrainmethod. 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 theepochsandimgsz(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! 🚀
-
songziang182
谢谢你们开发了这么完善的 yolov8🙏, 我想问一下,这两种训练方式的区别 model = YOLO('yolov8n.pt') model = YOLO('yolov8n.yaml').load('yolov8n.pt') model.train(.........)
1
Paula DerrengerUltralyticsHello there! 😊
The main difference between the two training methods you've mentioned:
-
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. -
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.ptmodel. 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!
-
songziang182
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?
Paula DerrengerUltralytics(bearbeitet)Hey! 😊 Thank you for your kind words, and I'm glad the information was helpful to you!
Regarding the
yolov8n.yamlconfiguration file, it defines the architecture for YOLOv8 models. All scales share one model file (yolov8.yaml) that contains ascalessection 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. 😊
vonzo
So, imgsz works different when training than when predicting?
For train: if it's an
intthe ratio will be kept and the train function will take care of that (can't be atuple). For predict: if it's anintthe image will be resized as a square of sizeimgsz x imgsz, if it's atuplethe image will be resized usingHxWand the user has to take care of the ratio andstride.Is this right? I would add a comment in the doc to avoid confusions
1
Paula DerrengerUltralytics(bearbeitet)You've got it mostly right! 👍 For training (
train),imgszis anint, the aspect ratio is maintained and resizing is handled internally. It can't be atuple. For prediction (predict), anintimgszresizes the longest side toimgszwhile 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. 😊
