Trainiere YOLOv5 mit benutzerdefinierten Daten#

📚 Dieser Leitfaden erklärt, wie du deinen eigenen benutzerdefinierten Datensatz mit dem YOLOv5-Modell trainierst 🚀. Das Training eigener Modelle ist ein grundlegender Schritt, um Computer Vision-Lösungen an spezifische reale Anwendungen jenseits der generischen Objekterkennung anzupassen.

Bevor du beginnst#

Stelle zuerst sicher, dass deine Umgebung eingerichtet ist. Klone das YOLOv5-Repository und installiere die erforderlichen Abhängigkeiten von requirements.txt. Eine Python>=3.8.0-Umgebung mit PyTorch>=1.8 ist essenziell. Modelle und Datensätze werden automatisch aus dem neuesten YOLOv5-Release heruntergeladen, falls sie nicht lokal gefunden werden.

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

Auf benutzerdefinierten Daten trainieren#

Die Entwicklung eines eigenen Modells zur Objekterkennung ist ein iterativer Prozess:

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

Die Ultralytics Platform bietet eine optimierte, codefreie Lösung für diesen gesamten Machine Learning Operations (MLOps)-Zyklus, einschließlich Datensatzverwaltung, Modelltraining und Bereitstellung.

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

Erstelle ein Dataset#

YOLOv5 Modelle benötigen beschriftete Daten, um die visuellen Merkmale von Objektklassen zu erlernen. Die korrekte Organisation deines Datasets ist der Schlüssel.

1.1 dataset.yaml erstellen#

Die Datensatz-Konfigurationsdatei (z. B. coco128.yaml) beschreibt die Struktur des Datensatzes, Klassennamen und Pfade zu Bildverzeichnissen. COCO128 dient als kleiner Beispieldatensatz, der die ersten 128 Bilder aus dem umfangreichen COCO-Datensatz umfasst. Er ist nützlich, um die Trainings-Pipeline schnell zu testen und potenzielle Probleme wie Overfitting zu diagnostizieren.

Die Dateistruktur von dataset.yaml umfasst:

• path: Das Stammverzeichnis, das den Datensatz enthält.
• train, val, test: Relative Pfade von path zu Verzeichnissen, die Bilder oder Textdateien mit Bildpfaden für Trainings-, Validierungs- und Testsets enthalten.
• names: Ein Dictionary, das Klassenindizes (beginnend bei 0) ihren entsprechenden Klassennamen zuordnet.

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

Unten ist 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 automatisierte Beschriftung nutzen#

Manuelle Beschriftung ist der übliche Ansatz, aber zeitaufwendig. Foundation-Modelle können die Annotation automatisieren oder teilautomatisieren und die Dataset-Erstellung beschleunigen. Beispiele für Modelle, die bei der Generierung von Labels helfen können:

• Google Gemini: Große multimodale Modelle wie Gemini verfügen über leistungsstarke Bildverständnisfähigkeiten. Sie können dazu aufgefordert werden, Objekte in Bildern zu identifizieren und zu lokalisieren, wodurch Bounding Boxes oder Beschreibungen generiert werden, die in YOLO-Format-Labels umgewandelt werden können. Entdecke ihr Potenzial im bereitgestellten Tutorial-Notebook.
• SAM2 (Segment Anything Model 2): Grundlagenmodelle, die sich auf Segmentierung konzentrieren, wie SAM2, können Objekte mit hoher Präzision identifizieren und abgrenzen. Obwohl sie primär für die Segmentierung gedacht sind, lassen sich die resultierenden Masken oft in Bounding-Box-Annotationen umwandeln, die für Objekterkennungsaufgaben geeignet sind.
• YOLOWorld: Dieses Modell bietet Open-Vocabulary-Erkennungsfunktionen. Du kannst Textbeschreibungen der Objekte bereitstellen, an denen du interessiert bist, und YOLOWorld kann sie in Bildern lokalisieren, ohne vorheriges Training zu diesen spezifischen Klassen. Dies kann als Ausgangspunkt für die Generierung erster Labels verwendet werden, die dann verfeinert werden können.

Die Verwendung dieser Modelle kann einen „Vor-Labeling“-Schritt ermöglichen und den manuellen Aufwand reduzieren. Es ist jedoch entscheidend, automatisch generierte Labels zu überprüfen und zu verfeinern, um Genauigkeit und Konsistenz sicherzustellen, da die Qualität direkten Einfluss auf die Leistung deines trainierten YOLOv5-Modells hat. Stelle nach dem Generieren (und eventuellen Verfeinern) deiner Labels 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, bei null beginnende Klasse). Wenn ein Bild keine Zielobjekte enthält, ist keine entsprechende *.txt-Datei erforderlich.

Die Dateispezifikationen des YOLO-Formats *.txt sind präzise:

• Eine Zeile pro Bounding Box eines Objekts.
• Jede Zeile muss Folgendes enthalten: class_index x_center y_center width height.
• Koordinaten müssen auf einen Bereich zwischen 0 und 1 normalisiert sein. Teile dazu die Pixelwerte von x_center und width durch die Gesamtbreite des Bildes und teile y_center und height durch die Gesamthöhe des Bildes.
• Klassenindizes sind nullbasiert (d. h. die erste Klasse wird durch 0 repräsentiert, die zweite durch 1 usw.).

Die Labelfelder, die dem obigen Bild entsprechen und zwei „Personen“-Objekte (Klassenindex 0) sowie ein „Krawatten“-Objekt (Klassenindex 27) enthalten, würden wie folgt aussehen:

1.3 Verzeichnisse organisieren#

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

YOLOv5 findet die Labels für jedes Bild automatisch, indem das letzte Auftreten von /images/ im Bildpfad durch /labels/ ersetzt wird. Zum 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 ist:

/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)
            └── ...

Ein Modell auswählen#

Wähle ein vortrainiertes Modell, um den Trainingsprozess zu starten. Das Beginnen mit vortrainierten Gewichten beschleunigt das Lernen erheblich und verbessert die Leistung im Vergleich zum Training von Grund auf. YOLOv5 bietet verschiedene Modellgrößen, die jeweils Geschwindigkeit und Genauigkeit unterschiedlich ausbalancieren. Zum Beispiel ist YOLOv5s das zweitkleinste und schnellste Modell, das sich für ressourcenbeschränkte Umgebungen eignet. Konsultiere die README-Tabelle für einen detaillierten Vergleich aller verfügbaren Modelle.

Trainieren#

Beginne das Modelltraining mit dem Skript train.py. Wesentliche Argumente umfassen:

• --img: Definiert die Eingabe-Bildgröße (z. B. --img 640). Größere Größen liefern im Allgemeinen eine bessere Genauigkeit, erfordern jedoch mehr GPU-Speicher.
• --batch: Bestimmt die Batch-Größe (z. B. --batch 16). Wähle die größte Größe, die deine GPU bewältigen kann.
• --epochs: Gibt die Gesamtzahl der Trainings-Epochen an (z. B. --epochs 100). Eine Epoche repräsentiert einen vollständigen Durchlauf über den gesamten Trainingsdatensatz.
• --data: Pfad zu deiner dataset.yaml-Datei (z. B. --data coco128.yaml).
• --weights: Pfad zur initialen Gewichtsdatei. Die Verwendung vortrainierter Gewichte (z. B. --weights yolov5s.pt) wird dringend empfohlen, um eine schnellere Konvergenz und überlegene Ergebnisse zu erzielen. Um von Grund auf zu trainieren (nicht empfohlen, es sei denn, du hast einen sehr großen Datensatz und spezielle Anforderungen), verwende --weights '' --cfg yolov5s.yaml.

Vortrainierte Gewichte werden automatisch aus dem neuesten YOLOv5-Release heruntergeladen, falls 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 Trainingsausgaben, einschließlich Gewichte und Protokolle, werden im Verzeichnis runs/train/ gespeichert. Jede Trainingseinheit erstellt ein neues Unterverzeichnis (z. B. runs/train/exp, runs/train/exp2 usw.). Für eine interaktive Praxiserfahrung erkunde den Trainingsabschnitt in unseren offiziellen Tutorial-Notebooks:

Visualisieren#

YOLOv5 lässt sich nahtlos in verschiedene Tools integrieren, um den Trainingsfortschritt zu visualisieren, Ergebnisse zu bewerten und die Leistung in Echtzeit zu überwachen.

Comet Logging und Visualisierung#

Comet ist vollständig für ein umfassendes Experiment-Tracking integriert. Visualisiere Metriken live, speichere Hyperparameter, verwalte Datensätze und Modell-Checkpoints und analysiere Modellvorhersagen mit interaktiven Comet Custom 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 dich in die unterstützten Funktionen in unserem Comet-Integrationsleitfaden. Erfahre mehr über Comets Funktionen in dessen offizieller Dokumentation. Probiere das Comet Colab Notebook für eine Live-Demo aus:

ClearML Logging und Automatisierung#

Die ClearML-Integration ermöglicht detailliertes Experiment-Tracking, Datensatz-Versionsverwaltung und sogar die Remote-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 dich mit deinem ClearML-Server zu verbinden (entweder selbst gehostet oder der kostenlose Tarif).

ClearML erfasst automatisch Experimentdetails, Modell-Uploads, Vergleiche, nicht committete Code-Änderungen und installierte Pakete, um eine vollständige Reproduzierbarkeit zu gewährleisten. Du kannst Trainingsaufgaben ganz einfach auf Remote-Agenten planen und Datensatzversionen mit ClearML Data verwalten. Erkunde den ClearML-Integrationsleitfaden für umfassende Details.

Lokales Logging#

Trainingsergebnisse werden automatisch mit TensorBoard protokolliert und als CSV-Dateien im spezifischen Experimentverzeichnis (z. B. runs/train/exp) gespeichert. Zu den protokollierten Daten gehören:

• Trainings- und Validierungsverlust sowie Leistungsmetriken.
• Beispielbilder, die angewendete Augmentationen (wie Mosaike) zeigen.
• Ground-Truth-Labels zusammen mit Modellvorhersagen zur visuellen Inspektion.
• Wichtige Evaluierungsmetriken wie Precision-Recall-Kurven (PR-Kurven).
• Konfusionsmatrizen für eine detaillierte klassenbezogene Leistungsanalyse.

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 plotten:

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

Nächste Schritte#

Nach erfolgreichem Abschluss des Trainings wird der leistungsstärkste Modell-Checkpoint (best.pt) gespeichert und ist bereit für die Bereitstellung oder weitere Verfeinerung. Mögliche nächste Schritte umfassen:

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

Unterstützte Umgebungen#

Ultralytics bietet einsatzbereite Umgebungen, die mit wesentlichen Abhängigkeiten wie CUDA, cuDNN, Python und PyTorch ausgestattet sind, um einen reibungslosen Start zu ermöglichen.

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

Projektstatus#

Dieses Badge zeigt an, dass alle YOLOv5-GitHub Actions-CI-Tests (Continuous Integration) erfolgreich bestanden wurden. Diese strengen CI-Tests decken die Kernfunktionalitäten ab, einschließlich Training, Validierung, Inferenz, Export und Benchmarks auf den Betriebssystemen macOS, Windows und Ubuntu. Tests werden alle 24 Stunden und bei jedem Code-Commit automatisch ausgeführt, um gleichbleibende Stabilität und optimale Leistung zu gewährleisten.

FAQ#