Link to this sectionModelltraining mit Ultralytics YOLO#

Link to this sectionEinfü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 konzipiert und nutzt die modernen Hardwarekapazitäten 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.

Link to this sectionWarum 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 große Auswahl an anpassbaren Hyperparametern zur Feinabstimmung der Modellleistung. Für eine tiefere Kontrolle kannst du den Trainer selbst anpassen.
• Cloud-Training: Trainiere auf Cloud-GPUs über die Ultralytics Platform mit Echtzeit-Metriken und automatischem Checkpointing.

Link to this sectionHauptfunktionen des Train-Modus#

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

• Automatischer Dataset-Download: Standard-Datensätze wie COCO, VOC und ImageNet werden bei der ersten Nutzung automatisch heruntergeladen.
• 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.

Link to this sectionAnwendungsbeispiele#

Trainiere YOLO26n auf dem COCO8-Datensatz für 100 Epochen bei einer Bildgröße von 640. Das Trainingsgerät kann über das device-Argument festgelegt werden. Wenn kein Argument übergeben wird, wird die GPU device=0 verwendet, sofern verfügbar; ansonsten 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)

Link to this sectionMulti-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

Link to this sectionTraining 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.

Link to this sectionTraining 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")

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 ziehe bitte die PyTorch MPS-Dokumentation zu Rate.

Link to this sectionUnterbrochene 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 Optimierer-Status, den Learning Rate-Scheduler und die Epochennummer wieder her. Dies ermöglicht es dir, den Trainingsprozess nahtlos dort fortzusetzen, wo er aufgehört hat.

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.

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 train-Funktion das Training dort fort, wo es aufgehört hat, wobei der in der 'path/to/last.pt'-Datei gespeicherte Zustand verwendet wird. Wenn das resume-Argument weggelassen oder auf False gesetzt wird, startet die train-Funktion eine neue Trainingssitzung.

Denke daran, dass Checkpoints standardmäßig am Ende jeder Epoche gespeichert werden, oder in festen Intervallen unter Verwendung des save_period-Arguments, sodass du mindestens 1 Epoche abschließen musst, um einen Trainingslauf fortzusetzen.

Link to this sectionTrainingseinstellungen#

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, Learning Rate, Momentum und Weight Decay. Zusätzlich können die Wahl des Optimierers, der Loss Function und die Zusammensetzung des Trainingsdatensatzes den Trainingsprozess beeinflussen. Eine sorgfältige Abstimmung und das Experimentieren mit diesen Einstellungen sind entscheidend für die Optimierung der Leistung.

Link to this sectionMuSGD-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 Parameter mit param.ndim >= 2 (wie etwa Faltungsgewichte) erhalten das Muon-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 (typischerweise wenn 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 Optimierer-Auswahl in BaseTrainer.build_optimizer.

Link to this sectionAugmentierungs-Einstellungen und Hyperparameter#

Augmentierungstechniken sind entscheidend 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 Zweck und Wirkung jedes Augmentierungs-Arguments:

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.

Link to this sectionProtokollierung#

Beim Training eines YOLO26-Modells kann es wertvoll 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 im Dropdown-Menü im obigen Code-Snippet aus und führe ihn aus. Der gewählte Logger wird installiert und initialisiert.

Link to this sectionComet#

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.

Link to this sectionClearML#

ClearML ist eine Open-Source-Plattform, die das Verfolgen von Experimenten automatisiert und bei der effizienten gemeinsamen Nutzung von Ressourcen hilft. Sie wurde entwickelt, um Teams dabei zu 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.

Link to this sectionTensorBoard#

TensorBoard ist ein Visualisierungs-Toolkit für TensorFlow. Es ermöglicht dir, deinen TensorFlow-Graph 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 unten stehenden Befehl aus 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 Zeitverlauf zu überwachen, verschiedene Modelle zu vergleichen und Verbesserungsbereiche zu identifizieren.

Link to this sectionFAQ#

Link to this sectionKann 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 aus dem Browser. Weitere Details findest du im Leitfaden für Cloud-Training.

Link to this sectionWie trainiere ich ein Modell zur Objekterkennung 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 Trainings-Einstellungen.

Link to this sectionWas sind die Hauptmerkmale des Trainingsmodus von Ultralytics YOLO26?#

Die Hauptmerkmale des Trainingsmodus 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 anpassbar an deine Bedürfnisse. Weitere Details findest du im Abschnitt Hauptmerkmale des Trainingsmodus.

Link to this sectionWie 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)

Überprüfe den Abschnitt über Wiederaufnahme unterbrochener Trainings für weitere Informationen.

Link to this sectionWie 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 Klassen-Gewichtung über das cls_pw-Argument, um dieses Problem anzugehen.

Das cls_pw-Argument steuert die Gewichtung der Klasse 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 für mäßiges 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)

Link to this sectionKann ich YOLO26-Modelle auf Apple Silicon Chips trainieren?#

Ja, Ultralytics YOLO26 unterstützt das Training auf Apple Silicon Chips unter Nutzung des Metal Performance Shaders (MPS) Frameworks. 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.

Link to this sectionWas 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 Trainings-Einstellungen an.