Modelltraining mit Ultralytics YOLO

Einführung

Das Training eines Deep Learning-Modells besteht darin, ihm Daten zuzuführen und seine Parameter anzupassen, damit es präzise Vorhersagen treffen kann. Der Train-Modus in Ultralytics YOLO26 ist für ein effektives und effizientes Training von Objekterkennungsmodellen ausgelegt und nutzt die modernen Hardwarekapazitäten voll aus. Dieser Leitfaden behandelt alle Details, 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: Hol das Beste aus deiner Hardware heraus, egal ob du ein Single-GPU-Setup verwendest oder über mehrere GPUs skalierst.
• Vielseitigkeit: Trainiere auf benutzerdefinierten Datensätzen sowie auf 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 an anpassbaren Hyperparametern 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 Metriken in Echtzeit 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.
• Hyperparameter-Konfiguration: 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 Erkenntnisse.

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 bei Verfügbarkeit die GPU device=0 verwendet; andernfalls wird device='cpu' verwendet. Siehe den Abschnitt „Argumente“ weiter 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 durch Verteilung der Trainingslast auf mehrere GPUs. 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

Training auf im Leerlauf befindlicher GPU

Das Training auf einer im Leerlauf befindlichen GPU ermöglicht die automatische Auswahl der am wenigsten ausgelasteten GPUs in Multi-GPU-Systemen, wodurch die Ressourcennutzung optimiert wird, ohne dass eine manuelle GPU-Auswahl erforderlich ist. 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 gemeinsam genutzten Rechenumgebungen oder wenn mehrere Trainingsjobs für verschiedene Modelle ausgeführt werden. Sie passt sich automatisch an sich ändernde Systembedingungen an und stellt eine optimale Ressourcenzuweisung ohne manuelles Eingreifen sicher.

Apple Silicon MPS-Training

Mit der Unterstützung für Apple Silicon-Chips, die in die Ultralytics YOLO-Modelle integriert ist, ist es nun möglich, deine Modelle auf Geräten zu trainieren, die das leistungsstarke Framework Metal Performance Shaders (MPS) nutzen. MPS bietet eine hochleistungsfähige Möglichkeit, Berechnungs- und Bildverarbeitungsaufgaben auf dem benutzerdefinierten Silizium von Apple auszuführen.

Um das Training auf Apple Silicon-Chips zu aktivieren, solltest du 'mps' als dein Gerät angeben, wenn du den Trainingsprozess einleitest. 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")

Während die Rechenleistung der Apple Silicon-Chips genutzt wird, ermöglicht dies eine effizientere Verarbeitung der Trainingsaufgaben. Für detailliertere Anleitungen und erweiterte Konfigurationsoptionen lies bitte die PyTorch MPS-Dokumentation.

Wiederaufnahme unterbrochener Trainings

Die Wiederaufnahme des Trainings von einem zuvor gespeicherten Zustand ist eine entscheidende Funktion bei der Arbeit mit Deep Learning-Modellen. Dies kann in verschiedenen Szenarien nützlich sein, 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 wieder aufgenommen wird, lädt Ultralytics YOLO die Gewichte aus dem zuletzt gespeicherten Modell und stellt außerdem den Optimiererzustand, den Lernraten-Scheduler und die Epochennummer wieder her. Dadurch kannst du den Trainingsprozess nahtlos an der Stelle fortsetzen, an der er unterbrochen wurde.

Du kannst das Training in Ultralytics YOLO einfach wieder aufnehmen, indem du das Argument resume auf True setzt, wenn du die train-Methode aufrufst, und den Pfad zu der .pt-Datei angibst, die die teilweise trainierten Modellgewichte enthält.

Unten findest du ein Beispiel für die Wiederaufnahme eines unterbrochenen Trainings mit Python und über die Befehlszeile:

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 aufgehört hat, unter Verwendung des im 'path/to/last.pt'-Dateiformats gespeicherten Zustands. Wenn das Argument resume weggelassen oder auf False gesetzt wird, startet die train-Funktion eine neue Trainingseinheit.

Denk 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.

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, Impuls und Gewichtungsabfall. Zusätzlich können die Wahl des Optimierers, der Verlustfunktion und die Zusammensetzung des Trainingsdatensatzes den Trainingsprozess beeinflussen. Eine sorgfältige Abstimmung und das Experimentieren mit diesen Einstellungen sind für die Leistungsoptimierung entscheidend.

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 Parameter mit param.ndim >= 2 (wie Faltungsgewichte) erhalten das Update im Muon-Stil zusammen mit SGD, während niedrigdimensionale Parameter wie Batch-Normalisierungsschichten und Bias-Begriffe beim Standard-SGD verbleiben.

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

Anwendungsbeispiel:

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

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

Augmentierungseinstellungen und Hyperparameter

Augmentierungstechniken sind wesentlich für die Verbesserung der Robustheit und Leistung von YOLO-Modellen, 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 Auswirkung jedes Augmentierungsarguments:

Diese Einstellungen können angepasst werden, um die spezifischen Anforderungen des Datensatzes und der jeweiligen Aufgabe zu erfüllen. 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 könnte es wertvoll für dich sein, die Leistung des Modells im Laufe der Zeit 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 im Dropdown-Menü im obigen Code-Schnipsel aus und führe ihn aus. Der gewählte Logger wird 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 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 der Website von Comet in deinem 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 Nachverfolgen von Experimenten automatisiert und bei der effizienten 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 in 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, die durch ihn geleitet werden, anzuzeigen.

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 unten stehenden Befehl aus und zeige die Ergebnisse unter localhost:6006 an.

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

Dies lädt TensorBoard und leitet es in das Verzeichnis, 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 der von dir 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 für Verbesserungen zu identifizieren.

FAQ

Kann ich ohne lokale GPU trainieren?

Ja. Die Ultralytics Platform unterstützt Cloud-Training mit kostenlosen Guthaben für den Einstieg. Lade deinen Datensatz hoch, wähle ein Modell und eine GPU aus und trainiere direkt aus dem Browser heraus. Weitere Informationen findest du im Cloud-Trainingsleitfaden.

Wie trainiere ich ein Objekterkennungsmodell mit Ultralytics YOLO26?

Um ein Objekterkennungsmodell mit Ultralytics YOLO26 zu trainieren, kannst du entweder die Python API oder die 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 Standarddatensä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 anpassbar an deine Bedürfnisse. Weitere Details findest du im Abschnitt Hauptfunktionen des Train-Modus.

Wie nehme ich das Training nach einer unterbrochenen Sitzung in Ultralytics YOLO26 wieder auf?

Um das Training nach einer unterbrochenen Sitzung wieder aufzunehmen, setze das Argument resume 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)

Schau dir den Abschnitt über Wiederaufnahme unterbrochener Trainings für weitere Informationen an.

Wie trainiere ich ein Modell auf einem unausgewogenen Datensatz?

Klassenungleichgewicht tritt auf, wenn einige Klassen in deinen Trainingsdaten deutlich weniger Beispiele aufweisen 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 volle 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 Trainingseinstellungen, siehe den Abschnitt Trainingseinstellungen.