YOLOv5 mit benutzerdefinierten Daten trainieren#

📚 Dieser Leitfaden erklärt, wie du dein eigenes benutzerdefiniertes Dataset mit dem Modell YOLOv5 trainierst 🚀. Das Trainieren benutzerdefinierter Modelle ist ein grundlegender Schritt, um Computer-Vision-Lösungen auf spezifische Anwendungen in der realen Welt zuzuschneiden, die über die allgemeine Objekterkennung hinausgehen.

Bevor du beginnst#

Stelle zunächst sicher, dass deine Umgebung eingerichtet ist. Klone das YOLOv5-Repository und installiere die erforderlichen Abhängigkeiten aus requirements.txt. Eine Umgebung mit Python>=3.8.0 und PyTorch>=1.8 ist unerlässlich. Modelle und Datasets werden automatisch aus dem neuesten YOLOv5-Release heruntergeladen, wenn sie nicht lokal gefunden werden.

git clone https://github.com/ultralytics/yolov5 # Clone the repository
cd yolov5
pip install -r requirements.txt # Install dependencies

Mit benutzerdefinierten Daten trainieren#

Die Entwicklung eines benutzerdefinierten Objekterkennungs-Modells ist ein iterativer Prozess:

1. Bilder sammeln und organisieren: Sammle Bilder, die für deine spezifische Aufgabe relevant sind. Hochwertige und vielfältige Daten sind entscheidend. Siehe unseren Leitfaden zur Datensammlung und Annotation.
2. Objekte beschriften: Annotiere die interessierenden Objekte in deinen Bildern präzise.
3. Ein Modell trainieren: Verwende die beschrifteten Daten, um dein YOLOv5-Modell zu trainieren. Nutze Transfer-Lernen, indem du mit vortrainierten Gewichten beginnst.
4. Bereitstellen und Vorhersagen: Nutze das trainierte Modell für die Inferenz auf neuen, bisher unbekannten Daten.
5. Sonderfälle sammeln: Identifiziere Szenarien, in denen das Modell schlecht abschneidet (Sonderfälle), und füge deinem Dataset ähnliche Daten hinzu, um die Robustheit zu verbessern. Wiederhole den Zyklus.

Die Ultralytics Platform bietet eine optimierte No-Code-Lösung für diesen gesamten Zyklus der MLOps, einschließlich Dataset-Verwaltung, Modelltraining und Bereitstellung.

Vor Beginn des Trainings ist die Vorbereitung des Datasets unerlässlich.

1. Ein Dataset erstellen#

YOLOv5-Modelle benötigen beschriftete Daten, um die visuellen Merkmale von Objektklassen zu erlernen. Die korrekte Organisation deines Datasets ist entscheidend.

1.1 dataset.yaml erstellen#

Die Dataset-Konfigurationsdatei (z. B. coco128.yaml) beschreibt die Struktur des Datasets, die Klassennamen und die Pfade zu den Bildverzeichnissen. COCO128 ist ein kleines Beispieldataset, das aus den ersten 128 Bildern des umfangreichen COCO-Datasets besteht. Es eignet sich zum schnellen Testen der Trainingspipeline und zum Erkennen potenzieller Probleme wie Overfitting.

Die Dateistruktur von dataset.yaml umfasst:

• path: Das Stammverzeichnis mit dem Dataset.
• train, val, test: Relative Pfade von path zu Verzeichnissen mit Bildern oder Textdateien, die Bildpfade für Trainings-, Validierungs- und Testdatensätze auflisten.
• names: Ein Dictionary, das Klassenindizes (beginnend bei 0) den entsprechenden Klassennamen zuordnet.

Du kannst path entweder auf ein absolutes Verzeichnis (z. B. /home/user/datasets/coco128) oder auf einen relativen Pfad wie ../datasets/coco128 setzen, wenn du das Training aus dem Stammverzeichnis des YOLOv5-Repositorys startest.

Unten siehst du die Struktur für coco128.yaml (auf GitHub ansehen):

# Dataset root directory relative to the yolov5 directory
path: coco128

# Train/val/test sets: specify directories, *.txt files, or lists
train: images/train2017 # 128 images for training
val: images/train2017 # 128 images for validation
test: # Optional path to test images

# Classes (example using 80 COCO classes)
names:
    0: person
    1: bicycle
    2: car
    # ... (remaining COCO classes)
    77: teddy bear
    78: hair drier
    79: toothbrush

1.2 Modelle für die automatische Beschriftung nutzen#

Die manuelle Beschriftung ist der übliche Ansatz, aber zeitaufwendig. Foundation-Modelle können Annotationen automatisieren oder teilweise automatisieren und die Erstellung von Datasets beschleunigen. Beispiele für Modelle, die bei der Erstellung von Beschriftungen helfen können:

• Google Gemini: Große multimodale Modelle wie Gemini verfügen über leistungsfähige Fähigkeiten zum Verstehen von Bildern. Sie können aufgefordert werden, Objekte in Bildern zu identifizieren und zu lokalisieren, und daraus Begrenzungsrahmen oder Beschreibungen erzeugen, die in Beschriftungen im YOLO-Format umgewandelt werden können. Entdecke das Potenzial im bereitgestellten Tutorial-Notebook.
• SAM2 (Segment Anything Model 2): Auf Segmentierung spezialisierte Foundation-Modelle wie SAM2 können Objekte mit hoher Präzision identifizieren und abgrenzen. Obwohl sie hauptsächlich für die Segmentierung eingesetzt werden, lassen sich die resultierenden Masken häufig in Begrenzungsrahmen-Annotationen für Objekterkennungsaufgaben umwandeln.
• YOLOWorld: Dieses Modell bietet Objekterkennung mit offenem Vokabular. Du kannst Textbeschreibungen der gewünschten Objekte angeben, und YOLOWorld kann sie in Bildern lokalisieren, ohne zuvor auf diesen spezifischen Klassen trainiert worden zu sein. Dies kann als Ausgangspunkt für die Erstellung erster Beschriftungen dienen, die anschließend verfeinert werden können.

Die Verwendung dieser Modelle kann einen Schritt zur „Vorbeschriftung“ ermöglichen und den manuellen Aufwand reduzieren. Es ist jedoch entscheidend, automatisch erstellte Beschriftungen zu überprüfen und zu verfeinern, um Genauigkeit und Konsistenz sicherzustellen, da ihre Qualität die Leistung deines trainierten YOLOv5-Modells direkt beeinflusst. Stelle nach der Erstellung und möglichen Verfeinerung deiner Beschriftungen sicher, dass sie dem YOLO-Format entsprechen: eine *.txt-Datei pro Bild, wobei jede Zeile ein Objekt als class_index x_center y_center width height (normalisierte Koordinaten, nullbasierter Klassenindex) darstellt. Wenn ein Bild keine interessierenden Objekte enthält, ist keine entsprechende *.txt-Datei erforderlich.

Die Spezifikationen der *.txt-Datei im YOLO-Format sind genau festgelegt:

• Eine Zeile pro Begrenzungsrahmen.
• Jede Zeile muss Folgendes enthalten: class_index x_center y_center width height.
• Die Koordinaten müssen auf einen Bereich zwischen 0 und 1 normalisiert werden. Teile dazu die Pixelwerte von x_center und width durch die Gesamtbreite des Bildes und y_center und height durch die Gesamthöhe des Bildes.
• Klassenindizes beginnen bei null (d. h. die erste Klasse wird durch 0, die zweite durch 1 usw. dargestellt).

Die zum obigen Bild gehörende Beschriftungsdatei mit zwei Objekten vom Typ „person“ (Klassenindex 0) und einem Objekt vom Typ „tie“ (Klassenindex 27) würde so aussehen:

1.3 Verzeichnisse organisieren#

Strukturiere dein Datasets-Verzeichnis wie unten dargestellt. Standardmäßig erwartet YOLOv5 das Dataset-Verzeichnis (z. B. /coco128) in einem /datasets-Ordner, der neben dem Verzeichnis des /yolov5-Repositorys liegt.

YOLOv5 findet die Beschriftungen für jedes Bild automatisch, indem es das letzte Vorkommen von /images/ im Bildpfad durch /labels/ ersetzt. Beispiel:

../datasets/coco128/images/im0.jpg # Path to the image file
../datasets/coco128/labels/im0.txt # Path to the corresponding label file

Die empfohlene Verzeichnisstruktur lautet:

/datasets/
└── coco128/  # Dataset root
    ├── images/
    │   ├── train2017/  # Training images
    │   │   ├── 000000000009.jpg
    │   │   └── ...
    │   └── val2017/    # Validation images (optional if using same set for train/val)
    │       └── ...
    └── labels/
        ├── train2017/  # Training labels
        │   ├── 000000000009.txt
        │   └── ...
        └── val2017/    # Validation labels (optional if using same set for train/val)
            └── ...

2. Ein Modell auswählen#

Wähle ein vortrainiertes Modell, um den Trainingsprozess zu starten. Der Beginn mit vortrainierten Gewichten beschleunigt das Lernen deutlich und verbessert die Leistung gegenüber dem Training von Grund auf. YOLOv5 bietet verschiedene Modellgrößen, die Geschwindigkeit und Genauigkeit jeweils unterschiedlich ausbalancieren. Beispielsweise ist YOLOv5s das zweitkleinste und schnellste Modell und eignet sich für Umgebungen mit begrenzten Ressourcen. Eine detaillierte Übersicht aller verfügbaren Modelle findest du in der README-Tabelle.

3. Trainieren#

Starte das Modelltraining mit dem Skript train.py. Zu den wichtigsten Argumenten gehören:

• --img: Legt die Bildgröße der Eingabe fest (z. B. --img 640). Größere Größen liefern im Allgemeinen eine bessere Genauigkeit, benötigen aber mehr GPU-Speicher.
• --batch: Legt die Batchgröße fest (z. B. --batch 16). Wähle die größte Größe, die deine GPU verarbeiten kann.
• --epochs: Gibt die Gesamtzahl der Trainings-Epochen an (z. B. --epochs 100). Eine Epoche entspricht einem vollständigen Durchlauf durch das gesamte Trainingsdataset.
• --data: Pfad zu deiner dataset.yaml-Datei (z. B. --data coco128.yaml).
• --weights: Pfad zur Datei mit den Anfangsgewichten. Die Verwendung vortrainierter Gewichte (z. B. --weights yolov5s.pt) wird für eine schnellere Konvergenz und bessere Ergebnisse dringend empfohlen. Um von Grund auf zu trainieren (nicht empfohlen, außer du hast ein sehr großes Dataset und spezielle Anforderungen), verwende --weights '' --cfg yolov5s.yaml.

Vortrainierte Gewichte werden automatisch aus dem neuesten YOLOv5-Release heruntergeladen, wenn sie nicht lokal gefunden werden.

# Example: Train YOLOv5s on the COCO128 dataset for 3 epochs
python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt

Alle Trainingsergebnisse, einschließlich Gewichten und Protokollen, werden im Verzeichnis runs/train/ gespeichert. Jede Trainingssitzung erstellt ein neues Unterverzeichnis (z. B. runs/train/exp, runs/train/exp2 usw.). Für eine interaktive, praxisnahe Erfahrung kannst du den Trainingsabschnitt in unseren offiziellen Notebooks mit Tutorials erkunden:

4. Visualisieren#

YOLOv5 lässt sich nahtlos in verschiedene Werkzeuge zur Visualisierung des Trainingsfortschritts, zur Auswertung der Ergebnisse und zur Überwachung der Leistung in Echtzeit integrieren.

Comet-Protokollierung und -Visualisierung#

Comet ist vollständig für eine umfassende Experimentverfolgung integriert. Visualisiere Metriken live, speichere Hyperparameter, verwalte Datasets und Modellprüfpunkte und analysiere Modellvorhersagen mit interaktiven benutzerdefinierten Comet-Panels.

Der Einstieg ist unkompliziert:

pip install comet_ml                                                          # 1. Install Comet library
export COMET_API_KEY=YOUR_API_KEY_HERE                                        # 2. Set your Comet API key (create a free account at Comet.ml)
python train.py --img 640 --epochs 3 --data coco128.yaml --weights yolov5s.pt # 3. Train your model - Comet automatically logs everything!

Vertiefe dein Wissen über die unterstützten Funktionen in unserem Comet-Integrationsleitfaden. Erfahre mehr über die Funktionen von Comet in der offiziellen Dokumentation. Probiere das Comet-Colab-Notebook für eine Live-Demo aus:

ClearML-Protokollierung und Automatisierung#

Die ClearML-Integration ermöglicht eine detaillierte Experimentverfolgung, die Verwaltung von Dataset-Versionen und sogar die entfernte Ausführung von Trainingsläufen. Aktiviere ClearML mit diesen einfachen Schritten:

• Installiere das Paket: pip install clearml
• Initialisiere ClearML: Führe clearml-init einmal aus, um eine Verbindung zu deinem ClearML-Server herzustellen (entweder selbst gehostet oder über die kostenlose Stufe).

ClearML erfasst automatisch Experimentdetails, Modell-Uploads, Vergleiche, nicht committete Codeänderungen und installierte Pakete und gewährleistet so vollständige Reproduzierbarkeit. Du kannst Trainingsaufgaben einfach auf entfernten Agents planen und Dataset-Versionen mit ClearML Data verwalten. Ausführliche Informationen findest du im ClearML-Integrationsleitfaden.

Lokale Protokollierung#

Trainingsergebnisse werden automatisch mit TensorBoard protokolliert und als CSV-Dateien im jeweiligen Experimentverzeichnis (z. B. runs/train/exp) gespeichert. Die protokollierten Daten umfassen:

• Trainings- und Validierungsverlust sowie Leistungsmetriken.
• Beispielbilder mit angewendeten Augmentierungen (z. B. Mosaiken).
• Ground-Truth-Beschriftungen neben den Modellvorhersagen zur visuellen Überprüfung.
• Wichtige Bewertungsmetriken wie Precision-Recall-Kurven (PR-Kurven).
• Konfusionsmatrizen zur detaillierten Analyse der klassenweisen Leistung.

Die Datei results.csv wird nach jeder Epoche aktualisiert und nach Abschluss des Trainings als results.png dargestellt. Du kannst auch jede results.csv-Datei manuell mit der bereitgestellten Hilfsfunktion darstellen:

from utils.plots import plot_results

# Plot results from a specific training run directory
plot_results("runs/train/exp/results.csv")  # This will generate 'results.png' in the same directory

5. Nächste Schritte#

Nach erfolgreichem Abschluss des Trainings wird der Modellprüfpunkt mit der besten Leistung (best.pt) gespeichert und ist bereit für die Bereitstellung oder weitere Verfeinerung. Mögliche nächste Schritte sind:

• Führe mit dem trainierten Modell über die CLI oder Python eine Inferenz auf neuen Bildern oder Videos durch.
• Führe eine Validierung durch, um die Genauigkeit und Generalisierungsfähigkeit des Modells auf verschiedenen Datensplits (z. B. einem zurückgehaltenen Testdatensatz) zu bewerten.
• Exportiere das Modell in verschiedene Bereitstellungsformate wie ONNX, TensorFlow SavedModel oder TensorRT, um die Inferenz auf unterschiedlichen Plattformen zu optimieren.
• Setze Hyperparameter-Optimierung ein, um möglicherweise zusätzliche Leistungssteigerungen zu erzielen.
• Verbessere dein Modell kontinuierlich, indem du unseren Tipps für beste Trainingsergebnisse folgst und auf Grundlage der Leistungsanalyse iterativ vielfältigere und anspruchsvollere Daten hinzufügst.

Unterstützte Umgebungen#

Ultralytics stellt sofort einsatzbereite Umgebungen mit wichtigen Abhängigkeiten wie CUDA, cuDNN, Python und PyTorch bereit und ermöglicht so einen reibungslosen Einstieg.

• Kostenlose GPU-Notebooks:
  • 
  • 
  • 
• Cloud-Plattformen:
  • Google Cloud: Kurzanleitung für GCP
  • Amazon AWS: AWS-Schnellstartleitfaden
  • Microsoft Azure: AzureML-Schnellstartleitfaden
• Lokale Einrichtung:
  • Docker: Docker-Schnellstartanleitung

Projektstatus#

Dieses Abzeichen zeigt an, dass alle GitHub Actions-Tests von YOLOv5 zur kontinuierlichen Integration (CI) erfolgreich bestanden werden. Diese strengen CI-Tests decken die Kernfunktionen ab, einschließlich Training, Validierung, Inferenz, Export und Benchmarks, und werden unter den Betriebssystemen macOS, Windows und Ubuntu ausgeführt. Die Tests werden automatisch alle 24 Stunden sowie bei jedem Code-Commit ausgeführt und gewährleisten so eine gleichbleibende Stabilität und optimale Leistung.

FAQ#