Modelltraining mit Ultralytics YOLO#

Einführung#

Das Trainieren eines deep learning-Modells beinhaltet die Zufuhr von Daten und die Anpassung seiner Parameter, damit es präzise Vorhersagen treffen kann. Der Train-Modus in Ultralytics YOLO26 ist darauf ausgelegt, Objekterkennungsmodelle effektiv und effizient zu trainieren und dabei die modernen Hardware-Fähigkeiten voll auszuschöpfen. 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. Wenn du Ultralytics noch nicht installiert hast, beginne mit der Quickstart guide.

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

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

• Effizienz: Hole das Beste aus deiner Hardware heraus, egal ob du ein System mit einer einzelnen GPU nutzt oder auf mehrere GPUs skalierst.
• Vielseitigkeit: Trainiere auf benutzerdefinierten Datensätzen zusätzlich zu leicht verfügbaren wie COCO, VOC und ImageNet.
• Benutzerfreundlichkeit: Einfache und dennoch leistungsstarke CLI- und Python-Schnittstellen für eine unkomplizierte Trainingserfahrung.
• Hyperparameter-Flexibilität: Eine breite Palette an anpassbaren Hyperparametern zur Feinabstimmung der Modellleistung. Für eine tiefere Kontrolle kannst du den Trainer anpassen.
• Cloud-Training: Trainiere auf Cloud-GPUs über Ultralytics Platform mit Echtzeitmetriken und automatischer Checkpoint-Speicherung.

Hauptfunktionen des Train-Modus#

Dies sind einige bemerkenswerte Funktionen des Train-Modus von YOLO26:

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

Anwendungsbeispiele#

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

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#

Multi-GPU-Training ermöglicht eine effizientere Nutzung der verfügbaren Hardware-Ressourcen, 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 AMD-GPU-Training verwendet einen PyTorch-ROCm-Build mit der Standard-Syntax device=0 oder device=cuda:0. Siehe den AMD integration guide für die Installation und den aktuellen Status der Unterstützung von MIGraphX, DirectML und Ryzen AI NPU.

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

Training auf Huawei Ascend NPU#

Ultralytics unterstützt Training und Validierung auf Huawei Ascend NPUs durch torch_npu. Installiere zueinander kompatible Versionen von CANN, PyTorch und torch_npu 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, Checkpointing und Fortsetzen, verwenden die aktive NPU. AutoBatch ist für das Training mit einer einzelnen NPU verfügbar, während mehrere NPU-IDs das verteilte Training über HCCL starten. Siehe den Huawei Ascend integration guide für den Modellexport und die Bereitstellung nach dem Training.

Training mit freien GPUs (Idle GPU Training)#

Das Training mit freien GPUs ermöglicht die automatische Auswahl der am wenigsten genutzten GPUs in Multi-GPU-Systemen und optimiert so die Ressourcennutzung ohne manuelle GPU-Auswahl. Diese Funktion identifiziert verfügbare GPUs anhand von Auslastungsmetriken und 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ügbaren Speicher (freier VRAM)
3. Niedrigerer Temperatur und geringerem Stromverbrauch

Diese Funktion ist besonders wertvoll in gemeinsamen Rechenumgebungen oder wenn mehrere Trainingsjobs für verschiedene Modelle ausgeführt werden. Sie passt sich automatisch an sich ändernde Systembedingungen an und stellt so eine optimale Ressourcenzuweisung ohne manuellen Eingriff sicher.

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 Framework Metal Performance Shaders (MPS) nutzen. MPS bietet eine hochperformante Möglichkeit zur Ausführung von Rechen- und Bildverarbeitungsaufgaben auf dem benutzerdefinierten Silicon von Apple.

Um das Training auf Apple Silicon-Chips zu aktivieren, solltest du beim Starten des Trainingsprozesses 'mps' als dein Gerät angeben. Unten findest du ein Beispiel, 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")

Durch die Nutzung der Rechenleistung der Apple-Silicon-Chips ermöglicht dies eine effizientere Verarbeitung der Trainingsaufgaben. Ausführlichere Anleitungen und Optionen für fortgeschrittene Konfigurationen findest du in der PyTorch MPS documentation.

Unterbrochene Trainings fortsetzen#

Das Fortsetzen des Trainings von einem zuvor gespeicherten Zustand ist eine entscheidende Funktion bei der Arbeit mit Deep-Learning-Modellen. Dies ist in verschiedenen Szenarien nützlich, z. B. 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 außerdem den Zustand des Optimierers, den learning rate-Scheduler und die Epochennummer wieder her. Dadurch kannst du den Trainingsprozess nahtlos dort fortsetzen, wo er unterbrochen wurde.

Du kannst das Training in Ultralytics YOLO ganz einfach fortsetzen, indem du beim Aufrufen 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, wie du ein unterbrochenes Training mit Python und über die Befehlszeile fortsetzen kannst:

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 in der Datei „path/to/last.pt“ gespeicherten Zustand. Wenn das Argument resume weggelassen oder auf False gesetzt wird, startet die Funktion train eine neue Trainingseinheit.

Denke daran, dass Checkpoints standardmäßig am Ende jeder Epoche oder in festen Intervallen mithilfe des Arguments save_period gespeichert werden. Du musst also mindestens 1 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 die Leistung, Geschwindigkeit und accuracy des Modells. Zu den wichtigsten Trainingseinstellungen gehören Batch-Größe, Lernrate, Momentum und Gewichtungsabfall (Weight Decay). Darüber hinaus können die Wahl des Optimizers, der loss function und die Zusammensetzung des Trainingsdatensatzes 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 Standard-SGD-Updates mit orthogonalisierten Muon-Updates 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 lineare 2D-Gewichte und 4D-Faltungskilter (umgeformt zu 2D) erhalten zusammen mit SGD das Update im Muon-Stil, 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 mehr als 10.000 Iterationen). 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.

Augmentierungs-Einstellungen und Hyperparameter#

Augmentierungstechniken sind unerlässlich, um die Robustheit und Leistung von YOLO-Modellen zu verbessern, indem sie Variabilität in die training data einbringen und dem Modell helfen, besser auf ungesehene Daten zu verallgemeinern. Die folgende Tabelle beschreibt den Zweck und die Auswirkung der einzelnen Augmentierungsargumente:

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

Protokollierung#

Beim Training eines YOLO26-Modells kann es nützlich sein, die Leistung des Modells im Laufe der Zeit zu verfolgen. Hier kommt das Logging ins Spiel. Ultralytics YOLO bietet Unterstützung für drei Arten von Loggern – Comet, ClearML und TensorBoard.

Um einen Logger zu verwenden, wähle ihn im Dropdown-Menü im obigen Code-Snippet aus und führe ihn aus. Der gewählte Logger wird installiert und initialisiert.

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 Funktionen wie Echtzeitmetriken, 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 bei deinem Comet-Konto anzumelden und deinen API-Schlüssel zu erhalten. 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 gemeinsame Nutzung 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()

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 Visualisierungs-Toolkit für TensorFlow. Es ermöglicht dir, deinen TensorFlow-Graphen zu visualisieren, quantitative Metriken über die 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

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

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 Zeitverlauf zu überwachen, verschiedene Modelle zu vergleichen und Verbesserungsbereiche zu identifizieren.

Wie geht es weiter?#

Validiere dein trainiertes Modell anhand von Validierungsdaten (Held-out Data), 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 COCO8? Formatiere diese zuerst mit dem Datasets guide.

FAQ#