Modelltraining mit Ultralytics YOLO

Einführung

Das Training 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 wurde für ein effektives und effizientes Training von Objekterkennungsmodellen entwickelt und nutzt die Möglichkeiten moderner Hardware voll aus. Dieser Leitfaden deckt alle Details ab, die du benötigst, um mit dem Training deiner eigenen Modelle unter Verwendung der robusten Funktionen von YOLO26 zu beginnen.

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 Single-GPU-Setup 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 ein unkompliziertes Trainingserlebnis.
• Flexibilität bei Hyperparametern: Eine breite Palette anpassbarer Hyperparameter zur Feinabstimmung der Modellleistung. Für eine tiefergehende Kontrolle kannst du den Trainer selbst anpassen.
• Cloud-Training: Trainiere auf Cloud-GPUs über die Ultralytics Platform mit Echtzeitmetriken und automatischem Checkpointing.

Hauptfunktionen des Train-Modus

Im Folgenden sind einige bemerkenswerte Funktionen des Train-Modus von YOLO26 aufgeführt:

• Automatischer Datensatz-Download: Standard-Datensätze wie COCO, VOC und ImageNet werden bei der ersten Verwendung automatisch heruntergeladen.
• Multi-GPU-Unterstützung: Skaliere deine Trainingsbemühungen nahtlos über mehrere GPUs, um den Prozess zu beschleunigen.
• Konfiguration der Hyperparameter: Die Option, 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 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, falls verfügbar; andernfalls wird device='cpu' genutzt. 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

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 das Command-Line-Interface verfügbar. Um das Multi-GPU-Training zu aktivieren, gib die IDs der GPU-Geräte 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

Idle GPU-Training

Idle GPU-Training ermöglicht die automatische Auswahl der am wenigsten ausgelasteten GPUs in Multi-GPU-Systemen und optimiert die Ressourcennutzung ohne manuelle GPU-Auswahl. Diese Funktion identifiziert verfügbare GPUs basierend auf 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 geteilten Rechenumgebungen oder beim Ausführen mehrerer Trainingsjobs für verschiedene Modelle. Sie passt sich automatisch an sich ändernde Systembedingungen an und stellt eine optimale Ressourcenzuweisung ohne manuelles Eingreifen sicher.

Apple Silicon MPS-Training

Mit der in 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 eigenen Silizium von Apple.

Um das Training auf Apple-Silicon-Chips zu aktivieren, solltest du 'mps' als dein Gerät angeben, wenn du den Trainingsprozess startest. 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. Für detailliertere Anleitungen und erweiterte Konfigurationsoptionen lies bitte die PyTorch MPS-Dokumentation.

Fortsetzen unterbrochener Trainings

Das Fortsetzen des Trainings von einem zuvor gespeicherten Zustand ist eine entscheidende Funktion bei der Arbeit mit Deep-Learning-Modellen. Dies kann in verschiedenen Szenarien praktisch 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 vom zuletzt gespeicherten Modell und stellt auch den Zustand des Optimierers, den Lernraten-Scheduler und die Epochennummer wieder her. Dies ermöglicht es dir, den Trainingsprozess nahtlos dort fortzusetzen, wo er unterbrochen wurde.

You can easily resume training in Ultralytics YOLO by setting the resume argument to True when calling the train method, and specifying the path to the .pt file containing the partially trained model weights.

Nachfolgend findest du ein Beispiel, wie man 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 train-Funktion das Training dort fort, wo es unterbrochen wurde, unter Verwendung des im 'path/to/last.pt'-Dateipfad gespeicherten Zustands. Wenn das resume-Argument weggelassen oder auf False gesetzt wird, startet die train-Funktion eine neue Trainingssitzung.

Denk daran, dass Checkpoints standardmäßig am Ende jeder Epoche oder in festen Intervallen mithilfe des save_period-Arguments 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 Genauigkeit des Modells. Zu den wichtigsten Trainingseinstellungen gehören Batchgröße, Lernrate, Momentum und Weight Decay. Zusätzlich können die Wahl des Optimierers, der Verlustfunktion und die Zusammensetzung des Trainingsdatensatzes den Trainingsprozess beeinflussen. Sorgfältiges Tuning und Experimentieren mit diesen Einstellungen sind entscheidend für die Optimierung der Leistung.

MuSGD-Optimierer

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

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

Nur Parameter mit param.ndim >= 2 (wie Faltungsgewichte) erhalten das Muon-artige Update zusammen mit SGD, während niedrigdimensionale Parameter wie Batch-Normalisierungsschichten und Bias-Terme beim Standard-SGD verbleiben.

Wenn optimizer=auto verwendet wird, wählt Ultralytics automatisch MuSGD für längere Trainingsläufe (normalerweise wenn Iterationen > 10000). Für kürzere Läufe 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 wesentlich, um die Robustheit und Leistung von YOLO-Modellen zu verbessern, indem sie Variabilität in die Trainingsdaten einbringen und dem Modell helfen, besser auf unbekannte Daten zu generalisieren. Die folgende Tabelle erläutert den Zweck und die Wirkung jedes Augmentierungsarguments:

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 Zeitverlauf zu verfolgen. Hier kommt die Protokollierung 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 aus dem Dropdown-Menü im obigen Code-Schnipsel aus und führe ihn aus. Der gewählte Logger wird dann installiert und initialisiert.

Comet

Comet ist eine Plattform, die es Datenwissenschaftlern und Entwicklern ermöglicht, Experimente und Modelle zu verfolgen, zu vergleichen, zu erklären und zu optimieren. Sie bietet Funktionen wie Echtzeit-Metriken, Code-Diffs und die Nachverfolgung 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 das Tracking von Experimenten automatisiert und bei der effizienten gemeinsamen 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()

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 ü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

Dies lädt TensorBoard und leitet es in das Verzeichnis, in dem deine Trainingsprotokolle gespeichert sind.

Nach der Einrichtung deines Loggers kannst du mit dem Training deines Modells fortfahren. Alle Trainingsmetriken werden automatisch auf der von dir 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 Verbesserungspotenziale zu identifizieren.

FAQ

Kann ich ohne eine lokale GPU trainieren?

Ja. Die Ultralytics Platform unterstützt Cloud-Training mit kostenlosen Credits für den Einstieg. Lade deinen Datensatz hoch, wähle ein Modell und eine GPU aus und trainiere direkt im Browser. Siehe den Leitfaden für Cloud-Training für weitere Details.

Wie trainiere ich ein Objekterkennungsmodell mit Ultralytics YOLO26?

Um ein Objekterkennungsmodell mit Ultralytics YOLO26 zu trainieren, kannst du entweder die Python API oder das CLI verwenden. Nachfolgend findest du ein Beispiel für beides:

from ultralytics import YOLO

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

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

Weitere Details findest du im Abschnitt Trainingseinstellungen.

Was sind die Hauptfunktionen des Train-Modus von Ultralytics YOLO26?

Die Hauptfunktionen des Train-Modus von Ultralytics YOLO26 umfassen:

• Automatischer Datensatz-Download: Lädt automatisch Standard-Datensätze wie COCO, VOC und ImageNet herunter.
• Multi-GPU-Unterstützung: Skaliere das Training über mehrere GPUs hinweg für eine schnellere Verarbeitung.
• Hyperparameter-Konfiguration: Passe Hyperparameter über YAML-Dateien oder CLI-Argumente an.
• Visualisierung und Überwachung: Echtzeit-Verfolgung von Trainingsmetriken für bessere Einblicke.

Diese Funktionen machen das Training effizient und an deine Bedürfnisse anpassbar. Weitere Details findest du im Abschnitt Hauptfunktionen des Train-Modus.

Wie setze ich das Training nach einer unterbrochenen Sitzung in Ultralytics YOLO26 fort?

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

from ultralytics import YOLO

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

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

Überprüfe den Abschnitt über Fortsetzen von unterbrochenen Trainings für weitere Informationen.

Wie trainiere ich ein Modell mit einem unausgewogenen Datensatz?

Klassenungleichgewicht tritt auf, wenn einige Klassen in deinen Trainingsdaten deutlich weniger Beispiele haben als andere. Dies kann dazu führen, dass das Modell bei seltenen Klassen schlecht abschneidet. Ultralytics YOLO unterstützt die Klassengewichtung über das Argument cls_pw, um dieses Problem anzugehen.

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

• cls_pw=0.0 (Standard): Deaktiviert die Klassengewichtung
• cls_pw=1.0: Wendet die vollständige inverse Häufigkeitsgewichtung an
• Werte zwischen 0.0 und 1.0: Bieten eine teilweise Gewichtung bei moderatem Ungleichgewicht

Die Klassengewichte werden als (1.0 / class_counts) ^ cls_pw berechnet und so normalisiert, dass ihr Mittelwert 1.0 entspricht.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n.pt")

# Train with full class weighting for severely imbalanced data
results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0)

# Or use partial weighting (0.25) for moderate imbalance
results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)

Kann ich YOLO26-Modelle auf Apple-Silicon-Chips trainieren?

Ja, Ultralytics YOLO26 unterstützt das Training auf Apple-Silicon-Chips unter Verwendung des Frameworks Metal Performance Shaders (MPS). Gib 'mps' als dein Trainingsgerät an.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n.pt")

# Train the model on Apple silicon chip (M1/M2/M3/M4)
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Weitere Details findest du im Abschnitt Apple Silicon MPS Training.

Was sind die gängigen Trainingseinstellungen und wie konfiguriere ich sie?

Ultralytics YOLO26 ermöglicht es dir, eine Vielzahl von Trainingseinstellungen wie Batch-Größe, Lernrate, Epochen und mehr über Argumente zu konfigurieren. Hier ist ein kurzer Überblick:

Für einen ausführlichen Leitfaden zu den Trainingseinstellungen, sieh dir den Abschnitt Trainingseinstellungen an.