YOLOv5 mit eigenen Daten trainieren#

📚 Diese Anleitung erklärt, wie du mit dem Modell YOLOv5 🚀 deinen eigenen benutzerdefinierten Datensatz trainierst. Das Trainieren benutzerdefinierter Modelle ist ein grundlegender Schritt, um Lösungen für Computer Vision auf bestimmte reale Anwendungen zuzuschneiden, die über die allgemeine Objekterkennung hinausgehen.

Vor dem Start#

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 Datensätze werden automatisch aus dem neuesten YOLOv5-Release heruntergeladen, falls sie lokal nicht gefunden werden.

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

Mit eigenen Daten trainieren#

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

1. Bilder sammeln und organisieren: Sammle Bilder, die für deine konkrete Aufgabe relevant sind. Hochwertige und vielfältige Daten sind entscheidend. Sieh dir unseren Leitfaden zur Datenerfassung und Annotation an.
2. Objekte beschriften: Annotiere die interessierenden Objekte in deinen Bildern präzise.
3. Ein Modell trainieren: Trainiere dein YOLOv5-Modell mit den beschrifteten Daten. Nutze Transfer Learning, indem du mit vortrainierten Gewichten startest.
4. Bereitstellen und Vorhersagen treffen: Verwende das trainierte Modell für Inferenz mit neuen, bisher ungesehenen Daten.
5. Grenzfälle erfassen: Ermittle Szenarien, in denen das Modell schlecht abschneidet (Grenzfälle), und ergänze deinen Datensatz um ähnliche Daten, um die Robustheit zu verbessern. Wiederhole den Zyklus.

Die Ultralytics Platform bietet eine schlanke, codefreie Lösung für den gesamten Betrieb von Machine-Learning-Systemen (MLOps), einschließlich Datensatzverwaltung, Modelltraining und Bereitstellung.

Vor Beginn des Trainings muss der Datensatz vorbereitet werden.

1. Datensatz erstellen#

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

1.1 dataset.yaml erstellen#

Die Konfigurationsdatei des Datensatzes (z. B. coco128.yaml) beschreibt dessen Struktur, Klassennamen und Pfade zu Bildverzeichnissen. COCO128 ist ein kleiner Beispieldatensatz, der die ersten 128 Bilder aus dem umfangreichen COCO-Datensatz umfasst. Er eignet sich zum schnellen Testen der Trainingspipeline und zum Erkennen möglicher Probleme wie Overfitting.

Die Dateistruktur von dataset.yaml umfasst:

• path: Das Stammverzeichnis mit dem Datensatz.
• train, val, test: Relative Pfade von path zu Verzeichnissen mit Bildern oder Textdateien, die Bildpfade für die Trainings-, Validierungs- und Testdatensätze auflisten.
• names: Ein Wörterbuch, 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 von coco128.yaml (auf GitHub ansehen):

# Dataset root directory relative to the yolov5 directory
path: ../datasets/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 zwar üblich, aber zeitaufwendig. Basismodelle können Annotationen automatisieren oder teilautomatisieren und die Erstellung von Datensätzen beschleunigen. Beispiele für Modelle, die beim Erzeugen von Beschriftungen helfen können:

• Google Gemini: Große multimodale Modelle wie Gemini verfügen über leistungsstarke Fähigkeiten zum Bildverständnis. Du kannst sie dazu auffordern, Objekte in Bildern zu erkennen und zu lokalisieren. Dabei können Begrenzungsrahmen oder Beschreibungen erzeugt werden, die sich in Beschriftungen im YOLO-Format umwandeln lassen. Entdecke die Möglichkeiten im bereitgestellten Tutorial-Notebook.
• SAM2 (Modell „Segment Anything“ 2): Auf Segmentierung spezialisierte Basismodelle wie SAM2 können Objekte mit hoher Präzision erkennen und abgrenzen. Obwohl die Modelle hauptsächlich für die Segmentierung gedacht sind, lassen sich die resultierenden Masken oft in Begrenzungsrahmen-Annotationen umwandeln, die sich für Aufgaben der Objekterkennung eignen.
• YOLOWorld: Dieses Modell ermöglicht die Erkennung mit offenem Vokabular. Du kannst Textbeschreibungen der Objekte angeben, nach denen du suchst, und YOLOWorld kann diese in Bildern lokalisieren, ohne zuvor mit diesen bestimmten Klassen trainiert worden zu sein. Das Modell kann als Ausgangspunkt für die Erstellung erster Beschriftungen dienen, die anschließend verfeinert werden können.

Mit diesen Modellen lässt sich ein Schritt zur „Vorabbeschriftung“ einfügen, der den manuellen Aufwand reduziert. Es ist jedoch entscheidend, automatisch erzeugte Beschriftungen zu überprüfen und zu verfeinern, damit sie korrekt und einheitlich sind, denn ihre Qualität wirkt sich unmittelbar auf die Leistung deines trainierten YOLOv5-Modells aus. Nachdem du Beschriftungen erzeugt und gegebenenfalls verfeinert hast, stelle 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 darstellt (normalisierte Koordinaten, Klassenindex ab 0). Hat ein Bild keine interessierenden Objekte, ist keine entsprechende *.txt-Datei erforderlich.

Die Vorgaben für *.txt-Dateien im YOLO-Format sind genau festgelegt:

• Eine Zeile pro Objekt-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 sowie height durch die Gesamthöhe des Bildes.
• Klassenindizes beginnen bei 0 (d. h. die erste Klasse wird durch 0, die zweite durch 1 usw. dargestellt).

Die Beschriftungsdatei für das obige Bild mit zwei „person“-Objekten (Klassenindex 0) und einem „tie“-Objekt (Klassenindex 27) würde so aussehen:

1.3 Verzeichnisse organisieren#

Strukturiere dein Datensatz-Verzeichnis wie unten dargestellt. Standardmäßig erwartet YOLOv5, dass sich das Datensatzverzeichnis (z. B. /coco128) in einem Ordner /datasets befindet, der neben dem Repository-Verzeichnis /yolov5 liegt.

YOLOv5 findet die Beschriftungen für jedes Bild automatisch, indem das letzte Vorkommen von /images/ im Bildpfad durch /labels/ ersetzt wird. 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 sieht so aus:

/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. Modell auswählen#

Wähle ein vortrainiertes Modell, um mit dem Training zu beginnen. Der Start mit vortrainierten Gewichten beschleunigt das Lernen erheblich und verbessert die Leistung gegenüber einem Training von Grund auf. YOLOv5 bietet verschiedene Modellgrößen, die Geschwindigkeit und Genauigkeit unterschiedlich ausbalancieren. Zum Beispiel ist YOLOv5s das zweitkleinste und zweitschnellste Modell und eignet sich für Umgebungen mit begrenzten Ressourcen. Eine ausführliche Gegenüberstellung 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 Größe der Eingabebilder fest (z. B. --img 640). Größere Werte liefern im Allgemeinen eine höhere Genauigkeit, benötigen aber mehr GPU-Speicher.
• --batch: Legt die Batchgröße fest (z. B. --batch 16). Wähle den größten Wert, den deine GPU verarbeiten kann.
• --epochs: Legt die Gesamtzahl der Trainings-Epochen fest (z. B. --epochs 100). Eine Epoche ist ein vollständiger Durchlauf durch den gesamten Trainingsdatensatz.
• --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 dringend empfohlen, um schneller zu konvergieren und bessere Ergebnisse zu erzielen. Um von Grund auf zu trainieren (nicht empfohlen, außer du hast einen sehr großen Datensatz und besondere Anforderungen), verwende --weights '' --cfg yolov5s.yaml.

Vortrainierte Gewichte werden automatisch aus dem neuesten YOLOv5-Release heruntergeladen, falls sie lokal nicht 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 Trainingsausgaben, einschließlich Gewichten und Protokollen, werden im Verzeichnis runs/train/ gespeichert. Bei jeder Trainingseinheit wird ein neues Unterverzeichnis erstellt (z. B. runs/train/exp, runs/train/exp2 usw.). Wenn du interaktiv selbst loslegen möchtest, sieh dir den Trainingsabschnitt in unseren offiziellen Tutorial-Notebooks an:

4. Visualisieren#

YOLOv5 lässt sich nahtlos mit verschiedenen Tools verbinden, um den Trainingsfortschritt zu visualisieren, Ergebnisse auszuwerten und die Leistung in Echtzeit zu überwachen.

Protokollierung und Visualisierung mit Comet#

Comet ist für eine umfassende Nachverfolgung von Experimenten vollständig integriert. Visualisiere Kennzahlen in Echtzeit, speichere Hyperparameter, verwalte Datensätze und Modellprüfpunkte und analysiere Modellvorhersagen mit interaktiven benutzerdefinierten Comet-Ansichten.

Der Einstieg ist einfach:

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!

Weitere Informationen zu den unterstützten Funktionen findest du in unserem Comet-Integrationsleitfaden. In der offiziellen Dokumentation erfährst du mehr über die Funktionen von Comet. Probiere das Comet-Colab-Notebook mit einer Live-Demo aus:

Protokollierung und Automatisierung mit ClearML#

Die Integration von ClearML ermöglicht eine detaillierte Nachverfolgung von Experimenten, die Verwaltung von Datensatzversionen und sogar die Remote-Ausführung von Trainingsläufen. Aktiviere ClearML mit diesen einfachen Schritten:

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

ClearML erfasst automatisch Experimentsdetails, Modell-Uploads, Vergleiche, nicht übernommene Codeänderungen und installierte Pakete und gewährleistet so die vollständige Reproduzierbarkeit. Du kannst Trainingsaufgaben ganz einfach auf Remote-Agenten planen und Datensatzversionen 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 gespeichert (z. B. runs/train/exp). Die Protokolle enthalten:

• Trainings- und Validierungsverlust sowie Leistungskennzahlen.
• Beispielbilder mit angewendeten Augmentierungen (etwa Mosaiken).
• Grundwahrheitsbeschriftungen zusammen mit Modellvorhersagen zur visuellen Prüfung.
• Wichtige Bewertungskennzahlen wie Precision-Recall-Kurven (PR-Kurven).
• Konfusionsmatrizen für eine detaillierte Analyse der Leistung nach Klassen.

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

from utils.plots import plot_results

# Ergebnisse aus einem bestimmten Trainingslaufverzeichnis darstellen
plot_results("runs/train/exp/results.csv")  # Dadurch wird 'results.png' im selben Verzeichnis erstellt

5. Nächste Schritte#

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

• Führe mit dem trainierten Modell Inferenz auf neuen Bildern oder Videos über die CLI oder Python aus.
• Führe val.py aus, um die Genauigkeit und Generalisierungsfähigkeit des Modells anhand verschiedener Datenteilungen (z. B. eines zurückgehaltenen Testsatzes) zu bewerten.
• Exportiere das Modell in verschiedene Bereitstellungsformate wie ONNX, TensorFlow SavedModel oder TensorRT, um die Inferenz auf unterschiedlichen Plattformen zu optimieren.
• Nutze die Hyperparameterentwicklung, um möglicherweise noch mehr Leistung herauszuholen.
• Verbessere dein Modell weiter, indem du unsere Tipps für optimale Trainingsergebnisse befolgst und auf Grundlage der Leistungsanalyse nach und nach vielfältigere und anspruchsvollere Daten hinzufügst.

Unterstützte Umgebungen#

Ultralytics bietet sofort einsatzbereite Umgebungen mit wichtigen Abhängigkeiten wie CUDA, cuDNN, Python und PyTorch, damit du reibungslos loslegen kannst.

• Kostenlose GPU-Notebooks:
  • 
  • 
  • 
• Cloud-Plattformen:
  • Google Cloud: GCP-Schnellstartanleitung
  • Amazon AWS: AWS-Schnellstartanleitung
  • Microsoft Azure: AzureML-Schnellstartanleitung
• Lokale Einrichtung:
  • Docker: Docker-Schnellstartanleitung

Projektstatus#

Dieses Abzeichen zeigt an, dass alle GitHub-Actions-Tests zur kontinuierlichen Integration (CI) für YOLOv5 erfolgreich bestanden wurden. Diese gründlichen CI-Tests decken die zentralen Funktionen ab, darunter Training, Validierung, Inferenz, Export und Benchmarks auf den Betriebssystemen macOS, Windows und Ubuntu. Die Tests werden automatisch alle 24 Stunden und bei jedem Code-Commit ausgeführt, um eine gleichbleibende Stabilität und optimale Leistung sicherzustellen.

Häufig gestellte Fragen#