Modelltraining mit Ultralytics YOLO

Einführung

Das Training eines Deep-Learning-Modells beinhaltet das Einspeisen von Daten und das Anpassen seiner Parameter, sodass es genaue Vorhersagen treffen kann. Der Trainingsmodus in Ultralytics YOLO11 ist für ein effektives und effizientes Training von Objekterkennungsmodellen konzipiert und nutzt die Möglichkeiten moderner Hardware voll aus. Dieser Leitfaden soll alle Details abdecken, die Sie benötigen, um mit dem Training Ihrer eigenen Modelle mit den robusten Funktionen von YOLO11 zu beginnen.

Ansehen: Wie man ein YOLO-Modell auf Ihrem benutzerdefinierten Datensatz in Google Colab trainiert.

Warum Ultralytics YOLO für das Training wählen?

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

• Effizienz: Holen Sie das Beste aus Ihrer Hardware heraus, egal ob Sie eine Single-GPU-Konfiguration verwenden oder über mehrere GPUs skalieren.
• Vielseitigkeit: Trainieren Sie mit benutzerdefinierten Datensätzen zusätzlich zu den bereits verfügbaren wie COCO, VOC und ImageNet.
• Benutzerfreundlich: Einfache, aber leistungsstarke CLI- und Python-Schnittstellen für eine unkomplizierte Trainingserfahrung.
• Flexibilität der Hyperparameter: Eine breite Palette anpassbarer Hyperparameter zur Feinabstimmung der Modellleistung.

Hauptmerkmale des Trainingsmodus

Im Folgenden sind einige bemerkenswerte Funktionen des YOLO11-Trainingsmodus aufgeführt:

• Automatischer Datensatz-Download: Standarddatensätze wie COCO, VOC und ImageNet werden bei der ersten Verwendung automatisch heruntergeladen.
• Multi-GPU-Unterstützung: Skalieren Sie Ihre 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 von Trainingsmetriken und Visualisierung des Lernprozesses für bessere Einblicke.

Anwendungsbeispiele

Trainiere YOLO11n auf dem COCO8-Datensatz für 100 Epochen bei einer Bildgröße von 640. Das Trainingsgerät kann mit dem device Argument angegeben werden. Wenn kein Argument übergeben wird, wird die GPU device=0 verwendet, falls verfügbar, andernfalls wird die device='cpu' CPU verwendet. Weitere Informationen finden Sie 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-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 die Befehlszeilenschnittstelle verfügbar. Um das Multi-GPU-Training zu aktivieren, geben Sie die GPU-Geräte-IDs an, die Sie verwenden möchten.

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])

# Train the model with the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -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

# Use the two most idle GPUs
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=-1,-1

GPU-Training im Leerlauf

GPU-Training im Leerlauf ermöglicht die automatische Auswahl der am wenigsten ausgelasteten 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("yolov8n.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])

# Start training using the single most idle GPU
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=-1

# Start training using the two most idle GPUs
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=-1,-1

Der Algorithmus zur automatischen Auswahl priorisiert GPUs mit:

1. Niedrigere aktuelle Auslastungsprozentsätze
2. Höherer verfügbarer Speicher (freier VRAM)
3. Niedrigere Temperatur und geringerer Stromverbrauch

Diese Funktion ist besonders wertvoll in gemeinsam genutzten Rechenumgebungen oder bei der Ausführung mehrerer Trainingsaufträge für verschiedene Modelle. Sie passt sich automatisch an sich ändernde Systembedingungen an und gewährleistet eine optimale Ressourcenzuweisung ohne manuellen Eingriff.

Apple Silicon MPS Training

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

Um das Training auf Apple-Silizium-Chips zu aktivieren, sollten Sie 'mps' als Ihr Gerät angeben, wenn Sie den Trainingsprozess starten. Nachfolgend finden Sie ein Beispiel, wie Sie dies in python und über die Befehlszeile tun können:

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

Durch die Nutzung der Rechenleistung der Apple-Silizium-Chips wird eine effizientere Verarbeitung der Trainingsaufgaben ermöglicht. Für detailliertere Anleitungen und erweiterte Konfigurationsoptionen lesen Sie bitte die PyTorch MPS-Dokumentation.

Unterbrochene Trainings fortsetzen

Das Fortsetzen des Trainings von einem zuvor gespeicherten Zustand aus 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 Sie ein Modell mit neuen Daten oder für weitere Epochen weiter trainieren möchten.

Wenn das Training fortgesetzt wird, lädt Ultralytics YOLO die Gewichte des zuletzt gespeicherten Modells und stellt auch den Zustand des Optimierers, den Lernraten-Scheduler und die Epochennummer wieder her. Dies ermöglicht es Ihnen, den Trainingsprozess nahtlos dort fortzusetzen, wo er unterbrochen wurde.

Sie können das Training in Ultralytics YOLO einfach fortsetzen, indem Sie resume Argument für True beim Aufruf der train Methode und Angabe des Pfads zu der .pt Datei, die die teilweise trainierten Modellgewichte enthält.

Nachfolgend finden Sie ein Beispiel dafür, wie Sie ein unterbrochenes Training mit python und über die Befehlszeile fortsetzen können:

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 Setzen von resume=Truewird die train Funktion das Training an der Stelle fortsetzen, an der es unterbrochen wurde, wobei der im Pfad 'path/to/last.pt' gespeicherte Zustand verwendet wird. Wenn das resume Argument weggelassen oder auf Falsewird die train gesetzt wird, startet die Funktion eine neue Trainingseinheit.

Denken Sie daran, dass Checkpoints standardmäßig am Ende jeder Epoche oder in festen Intervallen mit dem Argument save_period gespeichert werden, sodass Sie mindestens 1 Epoche abschließen müssen, 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 Batch-Größe, Lernrate, Momentum und Weight Decay. Darüber hinaus können die Wahl des Optimierers, der Loss-Funktion und der Zusammensetzung des Trainingsdatensatzes den Trainingsprozess beeinflussen. Eine sorgfältige Abstimmung und das Experimentieren mit diesen Einstellungen sind entscheidend für die Optimierung der Leistung.

Augmentierungseinstellungen und Hyperparameter

Augmentierungstechniken sind unerlässlich, um die Robustheit und Leistung von YOLO-Modellen zu verbessern, indem sie die Trainingsdaten variieren und dem Modell helfen, sich besser auf unbekannte Daten zu verallgemeinern. Die folgende Tabelle beschreibt den Zweck und die Wirkung der einzelnen Augmentierungsargumente:

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 helfen, die optimale Augmentierungsstrategie zu finden, die zur besten Modellleistung führt.

Protokollierung

Beim Trainieren eines YOLO11-Modells kann es hilfreich sein, die Leistung des Modells im Zeitverlauf zu verfolgen. Hier 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ählen Sie ihn aus dem Dropdown-Menü im obigen Code-Snippet aus und führen Sie ihn aus. Der ausgewä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 Echtzeit-Metriken, Code-Diferenzen und Hyperparameter-Tracking.

So verwenden Sie Comet:

# pip install comet_ml
import comet_ml

comet_ml.init()

Denken Sie daran, sich auf der Comet-Website in Ihrem Konto anzumelden und Ihren API-Schlüssel zu beziehen. Sie müssen diesen zu Ihren Umgebungsvariablen oder Ihrem Skript hinzufügen, um Ihre 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 bei der effizienteren Verwaltung, Ausführung und Reproduktion ihrer ML-Arbeit zu unterstützen.

So verwenden Sie ClearML:

# pip install clearml
import clearml

clearml.browser_login()

Nachdem Sie dieses Skript ausgeführt haben, müssen Sie sich in Ihrem ClearML-Konto im Browser anmelden und Ihre Sitzung authentifizieren.

TensorBoard

TensorBoard ist ein Visualisierungstoolkit für TensorFlow. Es ermöglicht Ihnen, Ihren TensorFlow-Graphen zu visualisieren, quantitative Metriken über die Ausführung Ihres Graphen zu plotten und zusätzliche Daten wie Bilder anzuzeigen, die ihn durchlaufen.

So verwenden Sie TensorBoard in Google Colab:

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

Um TensorBoard lokal zu verwenden, führen Sie den folgenden Befehl aus und zeigen Sie die Ergebnisse unter folgender Adresse an: http://localhost:6006/.

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

Dadurch wird TensorBoard geladen und zu dem Verzeichnis geleitet, in dem Ihre Trainingsprotokolle gespeichert sind.

Nachdem Sie Ihren Logger eingerichtet haben, können Sie mit dem Modelltraining fortfahren. Alle Trainingsmetriken werden automatisch auf der von Ihnen gewählten Plattform protokolliert, und Sie können auf diese Protokolle zugreifen, um die Leistung Ihres Modells im Laufe der Zeit zu überwachen, verschiedene Modelle zu vergleichen und Bereiche für Verbesserungen zu identifizieren.

FAQ

Wie trainiere ich ein Objekterkennungsmodell mit Ultralytics YOLO11?

Um ein Objekterkennungsmodell mit Ultralytics YOLO11 zu trainieren, können Sie entweder die Python API oder die CLI verwenden. Nachfolgend finden Sie ein Beispiel für beides:

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 finden Sie im Abschnitt Train Settings.

Was sind die Hauptmerkmale des Trainingsmodus von Ultralytics YOLO11?

Die wichtigsten Funktionen des Ultralytics YOLO11 Trainingsmodus umfassen:

• Automatischer Datensatz-Download: Lädt automatisch Standarddatensätze wie COCO, VOC und ImageNet herunter.
• Multi-GPU-Unterstützung: Skalieren Sie das Training über mehrere GPUs, um die Verarbeitung zu beschleunigen.
• Hyperparameter-Konfiguration: Passen Sie 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 Ihre Bedürfnisse anpassbar. Weitere Informationen finden Sie im Abschnitt Key Features of Train Mode.

Wie setze ich das Training nach einer Unterbrechung in Ultralytics YOLO11 fort?

Um das Training von einer unterbrochenen Sitzung aus fortzusetzen, setzen Sie resume Argument für True und geben Sie 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)

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

Weitere Informationen finden Sie im Abschnitt Resuming Interrupted Trainings.

Kann ich YOLO11 Modelle auf Apple Silicon Chips trainieren?

Ja, Ultralytics YOLO11 unterstützt das Training auf Apple Silicon Chips unter Verwendung des Metal Performance Shaders (MPS) Frameworks. Geben Sie 'mps' als Ihr Trainingsgerät an.

from ultralytics import YOLO

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

# Train the model on Apple silicon chip (M1/M2/M3/M4)
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 finden Sie im Abschnitt Apple Silicon MPS Training.

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

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

Eine ausführliche Anleitung zu den Trainingseinstellungen finden Sie im Abschnitt Train Settings.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 2 Monaten

Kommentare