Modell Training mit Ultralytics YOLO

Einführung

Training a deep learning model involves feeding it data and adjusting its parameters so that it can make accurate predictions. Train mode in Ultralytics YOLO11 is engineered for effective and efficient training of object detection models, fully utilizing modern hardware capabilities. This guide aims to cover all the details you need to get started with training your own models using YOLO11's robust set of features.

Pass auf: How to Train a YOLO model on Your Custom Dataset in Google Colab.

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

Here are some compelling reasons to opt for YOLO11's Train mode:

• Effizienz: Hol das Beste aus deiner Hardware heraus, egal ob du mit einem einzelnenGPU System 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

The following are some notable features of YOLO11's Train mode:

• 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

Train YOLO11n on the COCO8 dataset for 100 epochs at image size 640. The training device can be specified using the device Argument. Wenn kein Argument übergeben wird 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("yolo11n.yaml")  # build a new model from YAML
model = YOLO("yolo11n.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo11n.yaml").load("yolo11n.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=yolo11n.yaml epochs=100 imgsz=640

# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolo11n.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=yolo11n.yaml pretrained=yolo11n.pt epochs=100 imgsz=640

Multi-GPU Ausbildung

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("yolo11n.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=yolo11n.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 den Ultralytics YOLO Modellen integriert sind, ist es jetzt möglich, deine Modelle auf Geräten zu trainieren, die das leistungsstarke Metal Performance Shaders (MPS) Framework nutzen. Die MPS bietet eine leistungsstarke Möglichkeit, Berechnungen und Bildverarbeitungsaufgaben auf Apples kundenspezifischem Silizium auszuführen.

Um das Training auf Apple M1- und M2-Chips zu aktivieren, solltest du beim Starten des Trainingsprozesses "mps" als Gerät angeben. Im Folgenden findest du ein Beispiel dafür, wie du dies in Python und über die Befehlszeile tun kannst:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.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")

# Start training from a pretrained *.pt model using MPS
yolo detect train data=coco8.yaml model=yolo11n.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.

When training is resumed, Ultralytics YOLO loads the weights from the last saved model and also restores the optimizer state, learning rate scheduler, and the epoch number. This allows you to continue the training process seamlessly from where it was left off.

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.

Remember that checkpoints are saved at the end of every epoch by default, or at fixed intervals using the save_period Argument, sodass du mindestens 1 Epoche abschließen musst, um einen Trainingslauf fortzusetzen.

Zug Einstellungen

The training settings for YOLO models encompass various hyperparameters and configurations used during the training process. These settings influence the model's performance, speed, and accuracy. Key training settings include batch size, learning rate, momentum, and weight decay. Additionally, the choice of optimizer, loss function, and training dataset composition can impact the training process. Careful tuning and experimentation with these settings are crucial for optimizing performance.

Erweiterungseinstellungen und Hyperparameter

Augmentation techniques are essential for improving the robustness and performance of YOLO models by introducing variability into the training data, helping the model generalize better to unseen data. The following table outlines the purpose and effect of each augmentation argument:

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

In training a YOLO11 model, you might find it valuable to keep track of the model's performance over time. This is where logging comes into play. Ultralytics' YOLO provides support for three types of loggers - Comet, ClearML, and 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 is a visualization toolkit for TensorFlow. It allows you to visualize your TensorFlow graph, plot quantitative metrics about the execution of your graph, and show additional data like images that pass through it.

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.

FAQ

How do I train an object detection model using Ultralytics YOLO11?

To train an object detection model using Ultralytics YOLO11, you can either use the Python API or the CLI. Below is an example for both:

from ultralytics import YOLO

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

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

yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640

Weitere Informationen findest du im Abschnitt " Einstellungen für den Zug ".

What are the key features of Ultralytics YOLO11's Train mode?

The key features of Ultralytics YOLO11's Train mode include:

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

Diese Funktionen machen das Training effizient und lassen sich an deine Bedürfnisse anpassen. Weitere Informationen findest du im Abschnitt " Hauptmerkmale des Trainingsmodus ".

How do I resume training from an interrupted session in Ultralytics YOLO11?

Um das Training nach einer unterbrochenen Sitzung fortzusetzen, setzen Sie die resume Argument zu True und gib den Pfad zum letzten 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)

yolo train resume model=path/to/last.pt

Weitere Informationen findest du im Abschnitt über die Wiederaufnahme unterbrochener Schulungen.

Can I train YOLO11 models on Apple M1 and M2 chips?

Yes, Ultralytics YOLO11 supports training on Apple M1 and M2 chips utilizing the Metal Performance Shaders (MPS) framework. Specify 'mps' as your training device.

from ultralytics import YOLO

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

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

yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=mps

Weitere Informationen findest du im Abschnitt Apple M1 und M2 MPS Training.

Was sind die üblichen Trainingseinstellungen und wie kann ich sie konfigurieren?

Ultralytics YOLO11 allows you to configure a variety of training settings such as batch size, learning rate, epochs, and more through arguments. Here's a brief overview:

Eine ausführliche Anleitung zu den Trainingseinstellungen findest du im Abschnitt Trainingseinstellungen.

📅 Created 11 months ago ✏️ Updated 11 days ago

Kommentare