Modell Training mit Ultralytics YOLO

Einführung

Beim Trainieren eines Deep-Learning-Modells müssen Daten eingegeben und die Parameter angepasst werden, damit das Modell genaue Vorhersagen machen kann. Der Trainingsmodus auf Ultralytics YOLOv8 wurde für ein effektives und effizientes Training von Objekterkennungsmodellen entwickelt und nutzt die Möglichkeiten moderner Hardware voll aus. In diesem Leitfaden erfährst du alle Details, die du für das Training deiner eigenen Modelle mit den robusten Funktionen von YOLOv8 benötigst.

Pass auf: So trainierst du ein YOLOv8 Modell auf deinem eigenen Datensatz in Google Colab.

Warum Ultralytics YOLO für die Ausbildung wählen?

Hier sind einige überzeugende Gründe, sich für den Zugmodus von YOLOv8 zu entscheiden:

• Effizienz: Hol das Beste aus deiner Hardware heraus, egal ob du mit einer einzelnen GPU arbeitest oder über mehrere GPUs skalierst.
• Vielseitigkeit: Trainiere mit benutzerdefinierten Datensätzen zusätzlich zu den bereits verfügbaren wie COCO, VOC und ImageNet.
• Benutzerfreundlich: Einfache, aber leistungsstarke Schnittstellen CLI und Python sorgen für ein unkompliziertes Training.
• Flexibilität der Hyperparameter: Eine breite Palette von anpassbaren Hyperparametern zur Feinabstimmung der Modellleistung.

Hauptmerkmale des Zugmodus

Im Folgenden sind einige bemerkenswerte Merkmale des Zugmodus von YOLOv8 aufgeführt:

• Automatischer Datensatz-Download: Standarddatensätze wie COCO, VOC und ImageNet werden bei der ersten Verwendung automatisch heruntergeladen.
• Multi-GPU-Unterstützung: Skaliere deine Trainingsbemühungen nahtlos auf mehrere GPUs, um den Prozess zu beschleunigen.
• Hyperparameter-Konfiguration: Die Option, Hyperparameter über YAML-Konfigurationsdateien oder CLI Argumente zu ändern.
• Visualisierung und Überwachung: Echtzeit-Tracking von Trainingsmetriken und Visualisierung des Lernprozesses für bessere Einblicke.

Verwendungsbeispiele

Trainiere YOLOv8n mit dem COCO8-Datensatz für 100 Epochen bei einer Bildgröße von 640. Das Trainingsgerät kann mit der Option device Argument. Wenn kein Argument übergeben wird, kann GPU device=0 wird verwendet, falls verfügbar, ansonsten device='cpu' verwendet werden. Eine vollständige Liste der Trainingsargumente findest du im Abschnitt Argumente weiter unten.

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.yaml')  # build a new model from YAML
model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
model = YOLO('yolov8n.yaml').load('yolov8n.pt')  # build from YAML and transfer weights

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

# Build a new model from YAML and start training from scratch
yolo detect train data=coco8.yaml model=yolov8n.yaml epochs=100 imgsz=640

# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640

# Build a new model from YAML, transfer pretrained weights to it and start training
yolo detect train data=coco8.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640

Multi-GPU Ausbildung

Das 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, gibst du die GPU-Geräte-IDs an, die du verwenden möchtest.

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.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])

# Start training from a pretrained *.pt model using GPUs 0 and 1
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1

Apple M1 und M2 MPS Schulung

Mit der Unterstützung der Apple M1 und M2 Chips, die in die Ultralytics YOLO Modelle integriert sind, ist es jetzt möglich, deine Modelle auf Geräten zu trainieren, die das leistungsstarke Metal Performance Shaders (MPS) Framework nutzen. MPS bietet eine leistungsstarke Möglichkeit, Berechnungen und Bildverarbeitungsaufgaben auf dem Apple-eigenen Chip auszuführen.

Um das Training auf Apple M1 und M2 Chips zu aktivieren, solltest du "mps" als dein Gerät angeben, wenn du den Trainingsprozess startest. Im Folgenden findest du ein Beispiel dafür, wie du dies in Python und über die Kommandozeile tun kannst:

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.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='mps')

# Start training from a pretrained *.pt model using GPUs 0 and 1
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps

Dadurch wird die Rechenleistung der M1/M2-Chips genutzt, was eine effizientere Bearbeitung der Trainingsaufgaben ermöglicht. Ausführlichere Anleitungen und erweiterte Konfigurationsoptionen findest du in der DokumentationPyTorch MPS.

Wiederaufnahme unterbrochener Schulungen

Die Wiederaufnahme des Trainings aus einem zuvor gespeicherten Zustand ist eine wichtige 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 ein Modell mit neuen Daten oder für mehrere Epochen weiter trainieren möchtest.

Wenn du das Training wieder aufnimmst, lädt Ultralytics YOLO die Gewichte aus dem zuletzt gespeicherten Modell und stellt auch den Optimierungsstatus, den Lernratenplaner und die Epochenzahl wieder her. So kannst du das Training nahtlos an der Stelle fortsetzen, an der es unterbrochen wurde.

Du kannst das Training auf Ultralytics YOLO einfach wieder aufnehmen, indem du die resume Argument zu True beim Aufruf der train Methode und die Angabe des Pfads zur .pt Datei, die die teilweise trainierten Modellgewichte enthält.

Im Folgenden findest du ein Beispiel, wie du ein unterbrochenes Training mit Python und über die Kommandozeile wieder aufnehmen 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)

# Resume an interrupted training
yolo train resume model=path/to/last.pt

Durch die Einstellung resume=True, die train Funktion setzt das Training an der Stelle fort, an der es aufgehört hat, und verwendet dabei den Status, der in der Datei "path/to/last.pt" gespeichert ist. Wenn die resume Argument weggelassen oder auf False, die train Funktion wird eine neue Trainingseinheit gestartet.

Denke daran, dass Checkpoints standardmäßig am Ende jeder Epoche oder in einem festen Intervall mit der Option save_period Argument, sodass du mindestens 1 Epoche abschließen musst, um einen Trainingslauf fortzusetzen.

Zug 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 die Stapelgröße, die Lernrate, das Momentum und der Gewichtsabfall. Auch die Wahl des Optimierers, der Verlustfunktion und der Zusammensetzung des Trainingsdatensatzes kann den Trainingsprozess beeinflussen. Eine sorgfältige Abstimmung und das Experimentieren mit diesen Einstellungen sind entscheidend für die Optimierung der Leistung.

Erweiterungseinstellungen und Hyperparameter

Augmentierungstechniken sind wichtig, um die Robustheit und Leistung von YOLO Modellen zu verbessern, indem sie Variabilität in die Trainingsdaten einbringen und dem Modell helfen, besser auf ungesehene Daten zu generalisieren. Die folgende Tabelle zeigt den Zweck und die Wirkung der einzelnen Erweiterungsargumente:

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

Loggen

Wenn du ein YOLOv8 Modell trainierst, kann es nützlich sein, die Leistung des Modells im Laufe der Zeit zu verfolgen. An dieser Stelle 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 aus dem Dropdown-Menü im obigen Codeschnipsel aus und führe ihn aus. Der ausgewählte Logger wird installiert und initialisiert.

Comet

Comet ist eine Plattform, mit der Datenwissenschaftler und Entwickler Experimente und Modelle verfolgen, vergleichen, erklären und optimieren können. Sie bietet Funktionen wie Echtzeit-Metriken, Code-Diffs und die Verfolgung von Hyperparametern.

Um Comet zu verwenden:

# pip install comet_ml
import comet_ml

comet_ml.init()

Denke daran, dich auf der Website Comet anzumelden und deinen API-Schlüssel zu erhalten. Diesen musst du 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 gemeinsamen Nutzung von Ressourcen hilft. Sie wurde entwickelt, um Teams dabei zu helfen, ihre ML-Arbeit effizienter zu verwalten, auszuführen und zu reproduzieren.

Um ClearML zu verwenden:

# pip install clearml
import clearml

clearml.browser_login()

Nachdem du dieses Skript ausgeführt hast, musst du dich bei deinem ClearML Konto im Browser 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 aufzuzeichnen und zusätzliche Daten wie Bilder anzuzeigen, die ihn durchlaufen.

Um TensorBoard in Google Colab zu verwenden:

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

Um TensorBoard lokal zu verwenden, führe den folgenden Befehl aus und sieh dir die Ergebnisse unter http://localhost:6006/ an.

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

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

Nachdem du deinen Logger eingerichtet hast, kannst du mit dem Training deines Modells fortfahren. Alle Trainingsdaten 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 mit Verbesserungsbedarf zu identifizieren.

Kommentare