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 Trainingsmodus in Ultralytics YOLO26 wurde für ein effektives und effizientes Training von Objekterkennungsmodellen entwickelt und nutzt die Möglichkeiten moderner Hardware vollständig aus. Dieser Leitfaden behandelt alle Details, die du für den Einstieg ins Training eigener Modelle mit den umfangreichen Funktionen von YOLO26 benötigst. Wenn du Ultralytics noch nicht installiert hast, beginne mit dem Schnellstartleitfaden.

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

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

Hier sind einige überzeugende Gründe für den Trainingsmodus von YOLO26:

• Effizienz: Nutze deine Hardware optimal aus, egal ob du mit einer einzelnen GPU arbeitest oder auf mehrere GPUs skalierst.
• Vielseitigkeit: Trainiere mit benutzerdefinierten Datensätzen und frei 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 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: Skaliere dein Training nahtlos über mehrere GPUs, um den Vorgang zu beschleunigen.
• 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 dem COCO8-Datensatz und einer Bildgröße von 640. Das Trainingsgerät lässt sich mit dem Argument device festlegen. Wird kein Argument übergeben, kommt, sofern verfügbar, die GPU device=0 zum Einsatz; andernfalls wird device='cpu' verwendet. Eine vollständige Liste der Trainingsargumente findest du im Abschnitt „Argumente“ weiter unten.

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 Trainingslast auf mehrere GPUs verteilt, sodass die verfügbaren Hardwareressourcen effizienter genutzt werden. Diese Funktion ist sowohl über die Python-API als auch über die Befehlszeilenschnittstelle verfügbar. Um das Training mit mehreren GPUs zu aktivieren, gib die IDs der gewünschten GPU-Geräte an.

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])

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

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 wenig ausgelasteten GPUs werden in Systemen mit mehreren GPUs automatisch die am wenigsten ausgelasteten GPUs ausgewählt. So wird die Ressourcennutzung ohne manuelle GPU-Auswahl optimiert. Diese Funktion ermittelt anhand der Auslastungswerte und des verfügbaren VRAM, welche GPUs verfügbar sind.

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)

Diese Funktion ist besonders in gemeinsam genutzten Computerumgebungen oder bei mehreren gleichzeitig laufenden Trainingsaufträgen für unterschiedliche Modelle nützlich. Sie passt sich automatisch an veränderte Systembedingungen an und sorgt so ohne manuelles Eingreifen für eine optimale Ressourcenzuweisung.

MPS-Training auf Apple Silicon#

Da die Ultralytics-YOLO-Modelle jetzt Apple-Silicon-Chips unterstützen, kannst du deine Modelle auf Geräten mit dem leistungsstarken Metal Performance Shaders (MPS)-Framework trainieren. MPS ermöglicht die leistungsstarke Ausführung von Berechnungen und Bildverarbeitungsaufgaben auf Apples speziell entwickelten Chips.

Um das Training auf Apple-Silicon-Chips zu aktivieren, gib beim Start des Trainings als Gerät „mps“ an. Im Folgenden findest du ein Beispiel für die Verwendung mit Python und über die Befehlszeile:

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")

Durch die Nutzung der Rechenleistung der Apple-Silicon-Chips lassen sich Trainingsaufgaben effizienter verarbeiten. Eine ausführlichere Anleitung und erweiterte Konfigurationsoptionen findest du in der PyTorch-MPS-Dokumentation.

Unterbrochene Trainingsläufe fortsetzen#

Das Fortsetzen des Trainings aus einem zuvor gespeicherten Zustand ist bei der Arbeit mit Deep-Learning-Modellen eine wichtige Funktion. Das kann in verschiedenen Situationen hilfreich sein, etwa wenn der Trainingsprozess unerwartet unterbrochen wurde oder du ein Modell mit neuen Daten oder über weitere Epochen hinweg trainieren möchtest.

Wird das Training fortgesetzt, lädt Ultralytics YOLO die Gewichte des zuletzt gespeicherten Modells und stellt außerdem den Zustand des Optimierers, den Lernraten-Scheduler, die Epochenzahl und den Datensatz wieder her. So kannst du den Trainingsprozess nahtlos an der Stelle fortsetzen, an der er unterbrochen wurde. Übergib neben resume explizit data=, um mit einem anderen Datensatz statt mit dem des Checkpoints fortzufahren.

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

Unten findest du ein Beispiel dafür, wie du ein unterbrochenes Training mit Python und über die Befehlszeile fortsetzen kannst:

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 anhand des im Dateipfad 'path/to/last.pt' gespeicherten Zustands an der Stelle fort, an der es unterbrochen wurde. Wenn das Argument resume weggelassen oder auf False gesetzt wird, startet die Funktion train eine neue Trainingssitzung.

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 Trainingsprozesses verwendet werden. Diese Einstellungen beeinflussen Leistung, Geschwindigkeit und Genauigkeit des Modells. Zu den wichtigsten Trainingseinstellungen zählen Stapelgröße, Lernrate, Impuls und Gewichtsabnahme. Auch die Wahl des Optimierers, der Verlustfunktion und die Zusammensetzung des Trainingsdatensatzes können den Trainingsprozess beeinflussen. Sorgfältiges Abstimmen und Ausprobieren dieser Einstellungen ist entscheidend, um die Leistung zu optimieren.

MuSGD-Optimierer#

In YOLO26 ist MuSGD ein hybrider Optimierer, der standardmäßige SGD-Aktualisierungen mit orthogonalisierten Aktualisierungen im Muon-Stil 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 2D umgeformt) erhalten zusammen mit SGD die Aktualisierung im Muon-Stil. Alle anderen Parameter, etwa Batch-Normalisierungsgewichte und Bias-Terme, bleiben bei standardmäßigem SGD.

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.

Einstellungen und Hyperparameter für die Datenerweiterung#

Datenerweiterungsverfahren sind unverzichtbar, um die Robustheit und Leistung von YOLO-Modellen zu verbessern. Dazu bringen sie Abwechslung in die Trainingsdaten und helfen dem Modell, besser auf unbekannte Daten zu verallgemeinern. Die folgende Tabelle zeigt Zweck und Wirkung der einzelnen Argumente für die Datenerweiterung:

Diese Einstellungen lassen sich an die jeweiligen Anforderungen des Datensatzes und der Aufgabe anpassen. Durch Ausprobieren verschiedener Werte findest du möglicherweise die optimale Strategie zur Datenerweiterung, mit der sich die beste Modellleistung erzielen lässt.

Protokollierung#

Trainingsmetriken, Diagramme und Checkpoints werden immer im Verzeichnis des Trainingslaufs gespeichert. Ultralytics überträgt sie außerdem an alle installierten und aktivierten Tools zur Experimentverfolgung: Comet, ClearML, TensorBoard, MLflow, Weights & Biases und DVCLive. Jeder Protokollierer wird über die Ultralytics-Einstellungen aktiviert oder deaktiviert, zum Beispiel mit yolo settings tensorboard=True. Die drei häufigsten Konfigurationen werden im Folgenden vorgestellt.

Comet#

Comet ist eine Plattform, auf der Datenwissenschaftler und Entwickler Experimente und Modelle verfolgen, vergleichen, erklären und optimieren können. Sie bietet Funktionen wie Metriken in Echtzeit, Codevergleiche 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' directory

Um 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' directory

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

Nachdem du deinen Protokollierer eingerichtet hast, kannst du mit dem Modelltraining beginnen. Alle Trainingsmetriken werden automatisch auf der ausgewählten Plattform protokolliert. Du kannst die Protokolle abrufen, um die Leistung deines Modells im Zeitverlauf zu überwachen, verschiedene Modelle zu vergleichen und Verbesserungsmöglichkeiten zu 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#