Modelltraining mit Ultralytics YOLO#

Einleitung#

Das Training eines Deep-Learning-Modells besteht darin, ihm Daten zuzuführen und seine Parameter anzupassen, damit es präzise Vorhersagen treffen kann. Der Trainingsmodus in Ultralytics YOLO26 ist für ein effektives und effizientes Training von Objekterkennungsmodellen entwickelt worden und nutzt moderne Hardware-Fähigkeiten vollständig aus. Dieser Leitfaden soll alle Details abdecken, die du benötigst, um mit dem Training deiner eigenen Modelle über den robusten Funktionsumfang von YOLO26 zu beginnen. Falls du Ultralytics noch nicht installiert hast, beginne mit dem Schnellstart-Leitfaden.

Sieh dir die unveröffentlichte YOLO27-Vorschau für geplante Trainingsbeispiele an.

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

Hier sind einige überzeugende Gründe, sich für den Trainingsmodus von YOLO26 zu entscheiden:

• Effizienz: Hole das Beste aus deiner Hardware heraus, ganz gleich, ob du ein Setup mit einer einzelnen GPU verwendest oder auf mehrere GPUs skalierst.
• Vielseitigkeit: Trainiere auf benutzerdefinierten Datensätzen zusätzlich zu frei verfügbaren Datensätzen wie COCO, VOC und ImageNet.
• Benutzerfreundlichkeit: Einfache und dennoch leistungsstarke CLI- und Python-Schnittstellen für ein unkompliziertes Trainingserlebnis.
• Hyperparameter-Flexibilität: Eine breite Palette an anpassbaren Hyperparametern zur Feinabstimmung der Modellleistung. Für eine tiefgreifendere Kontrolle kannst du den Trainer anpassen.
• Cloud-Training: Trainiere auf Cloud-GPUs über die Ultralytics Platform mit Metriken in Echtzeit und automatischer Erstellung von Prüfpunkten.

Hauptfunktionen des Trainingsmodus#

Die folgenden Punkte sind einige nennenswerte Funktionen des Trainingsmodus von YOLO26:

• Automatischer Datensatz-Download: Datensatzkonfigurationen mit einer Download-Quelle werden bei der ersten Verwendung automatisch heruntergeladen, z. B. yolo train data=coco8.yaml. Siehe die Datensatz-Übersicht für unterstützte Formate und Datensätze.
• Multi-GPU-Unterstützung: Skaliere deine Trainingsbemühungen nahtlos über mehrere GPUs hinweg, um den Prozess zu beschleunigen.
• Hyperparameter-Konfiguration: Die Option, Hyperparameter über YAML-Konfigurationsdateien oder CLI-Argumente zu modifizieren.
• Visualisierung und Überwachung: Echtzeit-Verfolgung der Trainingsmetriken und Visualisierung des Lernprozesses für bessere Einblicke.

Verwendungsbeispiele#

Trainiere YOLO26n auf dem COCO8-Datensatz für 100 Epochen bei einer Bildgröße von 640. Das Trainingsgerät kann über das Argument device angegeben werden. Wenn kein Argument übergeben wird, wird die GPU device=0 verwendet, sofern sie verfügbar ist; andernfalls wird device='cpu' verwendet. Siehe den Abschnitt „Argumente“ unten für eine vollständige Liste der Trainingsargumente.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.yaml")  # build a new model from YAML
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Multi-GPU-Training#

Das Multi-GPU-Training ermöglicht eine effizientere Nutzung der verfügbaren Hardwareressourcen, indem die Trainingslast auf mehrere GPUs verteilt wird. Diese Funktion ist sowohl über die Python-API als auch über die Befehlszeilenschnittstelle verfügbar. Um das Multi-GPU-Training zu aktivieren, gib die GPU-Geräte-IDs an, die du verwenden möchtest.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model with 2 GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Train the model with the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

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

Das Training auf AMD GPU verwendet einen PyTorch ROCm-Build mit der Standard-Syntax device=0 oder device=cuda:0. Weitere Informationen zur Installation und zum aktuellen Unterstützungsstatus von MIGraphX, DirectML und Ryzen AI NPU findest du im AMD integration guide.

Das Training mit Intel-GPUs verwendet device=xpu:0 oder mehrere XPU-IDs mit einem PyTorch-Build, der XCCL bereitstellt.

Training mit Huawei Ascend NPU#

Ultralytics unterstützt das Training und die Validierung auf Huawei Ascend NPUs über torch_npu. Installiere zueinander kompatible CANN-, PyTorch- und torch_npu-Versionen gemäß dem Ascend Extension for PyTorch installation guide und lade anschließend die CANN-Umgebung, bevor du Ultralytics startest:

source /usr/local/Ascend/ascend-toolkit/set_env.sh

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Train on one Ascend NPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Train across two Ascend NPUs with HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Die Standard-Trainingsfunktionen, einschließlich AMP, Validierung, Prüfpunkterstellung (Checkpointing) und Fortsetzung (Resume), nutzen die aktive NPU. AutoBatch ist für das Training mit einer NPU verfügbar, während mehrere NPU-IDs ein verteiltes Training über HCCL starten. Informationen zum Modellexport und zur Bereitstellung nach dem Training findest du im Huawei Ascend integration guide.

Training auf im Leerlauf befindlichen GPUs#

Das Training auf im Leerlauf befindlichen GPUs ermöglicht die automatische Auswahl der am wenigsten ausgelasteten GPUs in Multi-GPU-Systemen und optimiert so die Ressourcennutzung ohne manuelle GPU-Auswahl. Diese Funktion identifiziert verfügbare GPUs basierend auf Auslastungsmetriken und der VRAM-Verfügbarkeit.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train using the single most idle GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Train using the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

Der Algorithmus zur automatischen Auswahl priorisiert GPUs mit:

1. Niedrigeren aktuellen Auslastungsprozentsätzen
2. Höherem verfügbarem Speicher (freier VRAM)
3. Niedrigerer Temperatur und geringerem Stromverbrauch

Diese Funktion ist besonders wertvoll in gemeinsam genutzten Umgebungen oder beim Ausführen mehrerer Trainingsaufträge für verschiedene Modelle. Sie passt sich automatisch an sich ändernde Systembedingungen an und sorgt so für eine optimale Ressourcenzuweisung ohne manuelles Eingreifen.

Training mit Apple Silicon MPS#

Mit der in die Ultralytics YOLO-Modelle integrierten Unterstützung für Apple Silicon-Chips ist es nun möglich, deine Modelle auf Geräten zu trainieren, die das leistungsstarke Metal Performance Shaders (MPS)-Framework nutzen. MPS bietet eine hochperformante Möglichkeit zur Ausführung von Rechen- und Bildverarbeitungsaufgaben auf dem kundenspezifischen Silizium von Apple.

Um das Training auf Apple Silicon-Chips zu aktivieren, solltest du beim Initiieren des Trainingsprozesses 'mps' als dein Gerät angeben. Unten siehst du ein Beispiel dafür, wie du dies in Python und über die Befehlszeile tun kannst:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model with MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Während die Rechenleistung der Apple Silicon-Chips genutzt wird, ermöglicht dies eine effizientere Verarbeitung der Trainingsaufgaben. Ausführlichere Anleitungen und erweiterte Konfigurationsoptionen findest du in der PyTorch MPS-Dokumentation.

Fortsetzen unterbrochener Trainings#

Das Fortsetzen des Trainings aus einem zuvor gespeicherten Zustand ist eine entscheidende Funktion bei der Arbeit mit Deep-Learning-Modellen. Dies kann in verschiedenen Szenarien nützlich sein, beispielsweise wenn der Trainingsprozess unerwartet unterbrochen wurde oder wenn du das Training eines Modells mit neuen Daten oder für weitere Epochen fortsetzen möchtest.

Wenn das Training fortgesetzt wird, lädt Ultralytics YOLO die Gewichte des zuletzt gespeicherten Modells und stellt zudem den Optimizer-Zustand, den Learning Rate-Scheduler, die Epochennummer und den Datensatz wieder her. Dadurch kannst du den Trainingsprozess nahtlos dort fortsetzen, wo du ihn unterbrochen hast. Übergib einen expliziten data= zusammen mit resume, um das Training stattdessen auf einem anderen Datensatz als dem des Checkpoints fortzusetzen.

Du kannst das Training in Ultralytics YOLO ganz einfach fortsetzen, indem du das Argument resume beim Aufruf der Methode train auf True setzt und den Pfad zu der Datei .pt angibst, die die teilweise trainierten Modellgewichte enthält.

Unten siehst du ein Beispiel dafür, wie du ein unterbrochenes Training mit Python und über die Befehlszeile fortsetzt:

from ultralytics import YOLO

# Load a model
model = YOLO("path/to/last.pt")  # load a partially trained model

# Resume training
results = model.train(resume=True)

Durch das Setzen von resume=True setzt die Funktion train das Training dort fort, wo es unterbrochen wurde, und verwendet dabei den Zustand, der in der Datei 'path/to/last.pt' gespeichert ist. Wenn das Argument resume weggelassen oder auf False gesetzt wird, startet die Funktion train eine neue Trainingseinheit.

Denke daran, dass Prüfpunkte standardmäßig am Ende jeder Epoche oder in festen Intervallen über das Argument save_period gespeichert werden. Du musst also mindestens 1 Epoche abschließen, um einen Trainingsdurchlauf fortzusetzen.

Trainings-Einstellungen#

Die Trainingseinstellungen für YOLO-Modelle umfassen verschiedene Hyperparameter und Konfigurationen, die während des Trainingsprozesses verwendet werden. Diese Einstellungen beeinflussen die Leistung, Geschwindigkeit und Genauigkeit des Modells. Zu den wichtigsten Trainingseinstellungen gehören Batch-Größe, Lernrate, Momentum und Gewichtungsabfall. Darüber hinaus können die Wahl des Optimierers, der Verlustfunktion und die Zusammensetzung des Datensatzes für das Training den Trainingsprozess beeinflussen. Eine sorgfältige Abstimmung und Experimente mit diesen Einstellungen sind entscheidend für die Leistungsoptimierung.

MuSGD-Optimierer#

In YOLO26 ist MuSGD ein hybrider Optimierer, der standardmäßige SGD-Updates mit orthogonalisierten Updates im Muon-Stil kombiniert.

Er wird für längere YOLO26-Trainingsläufe und größere Datensätze empfohlen, bei denen orthogonalisierte Muon-Updates zur Stabilisierung der Optimierung beitragen können.

Nur 2D-lineare Gewichte und 4D-Faltungsfilter (zu 2D umgeformt) erhalten das Update im Muon-Stil zusammen mit SGD, während alle anderen Parameter, wie Batch-Normalisierungsgewichte und Bias-Terme, beim Standard-SGD verbleiben.

Wenn optimizer=auto verwendet wird, wählt Ultralytics automatisch MuSGD für längere Trainingsläufe (typischerweise bei Iterationen > 10000). Bei kürzeren Läufen greift der Trainer auf AdamW zurück.

Beispiel für die Verwendung:

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

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

Augmentierungseinstellungen und Hyperparameter#

Augmentierungstechniken sind unerlässlich, um die Robustheit und Leistung von YOLO-Modellen zu verbessern, indem Variabilität in die Trainingsdaten eingebracht wird, was dem Modell hilft, besser auf ungesehene Daten zu verallgemeinern. Die folgende Tabelle beschreibt den Zweck und die Wirkung der einzelnen Augmentierungsargumente:

Diese Einstellungen können angepasst werden, um den spezifischen Anforderungen des jeweiligen Datensatzes und der Aufgabe gerecht zu werden. Das Experimentieren mit verschiedenen Werten kann dabei helfen, die optimale Augmentierungsstrategie zu finden, die zu der besten Modellleistung führt.

Protokollierung#

Trainingsmetriken, Diagramme und Prüfpunkte werden immer in das Ausführungsverzeichnis geschrieben, und Ultralytics streamt sie zudem an jeden installierten und aktivierten Experiment-Tracker: Comet, ClearML, TensorBoard, MLflow, Weights & Biases und DVCLive. Jeder Logger wird über die Ultralytics settings umgeschaltet, zum Beispiel yolo settings tensorboard=True. Die drei gängigsten Setups werden unten gezeigt.

Comet#

Comet ist eine Plattform, die es Data Scientists und Entwicklern ermöglicht, Experimente und Modelle zu verfolgen, zu vergleichen, zu erklären und zu optimieren. Sie bietet Funktionalitäten wie Metriken in Echtzeit, Code-Diffs und die Verfolgung von Hyperparametern.

So verwendest du Comet:

# pip install comet_ml
import comet_ml

comet_ml.init()

Denke daran, dich auf deren Website in deinem Comet-Konto anzumelden und deinen API-Schlüssel abzurufen. Du musst diesen zu deinen Umgebungsvariablen oder deinem Skript hinzufügen, um deine Experimente zu protokollieren.

ClearML#

ClearML ist eine Open-Source-Plattform, die die Verfolgung von Experimenten automatisiert und bei der effizienten Freigabe von Ressourcen hilft. Sie wurde entwickelt, um Teams dabei zu unterstützen, ihre ML-Arbeit effizienter zu verwalten, auszuführen und zu reproduzieren.

So verwendest du ClearML:

# pip install clearml
import clearml

clearml.browser_login()

Nach dem Ausführen dieses Skripts musst du dich im Browser bei deinem ClearML-Konto anmelden und deine Sitzung authentifizieren.

TensorBoard#

TensorBoard ist ein Visualisierungs-Toolkit für TensorFlow. Es ermöglicht dir, deinen TensorFlow-Graphen zu visualisieren, quantitative Metriken zur Ausführung deines Graphen zu plotten und zusätzliche Daten wie Bilder anzuzeigen, die ihn durchlaufen.

So verwendest du TensorBoard in Google Colab:

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

Führe den folgenden Befehl aus, um TensorBoard lokal zu verwenden, und zeige die Ergebnisse unter localhost:6006 an.

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, kannst du mit dem Training deines Modells fortfahren. Alle Trainingsmetriken werden automatisch auf deiner gewählten Plattform protokolliert, und du kannst auf diese Protokolle zugreifen, um die Leistung deines Modells im Laufe der Zeit zu überwachen, verschiedene Modelle zu vergleichen und Bereiche mit Verbesserungspotenzial zu identifizieren.

Wie geht es weiter?#

Validiere dein trainiertes Modell anhand von zurückgehaltenen Daten, um seine Genauigkeit in der Praxis zu überprüfen, und exportiere es dann nach ONNX, TensorRT oder in ein anderes Bereitstellungsformat. Trainierst du mit deinen eigenen Daten statt mit COCO8? Formatiere sie zuerst mit dem Datensatz-Leitfaden.

FAQ#