Trainiere YOLOv5 mit benutzerdefinierten Daten

📚 Dieser Leitfaden erklärt, wie du dein eigenes benutzerdefiniertes Dataset mit dem YOLOv5 Modell trainierst 🚀. Das Training 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 zuerst sicher, dass du die notwendige Umgebung eingerichtet hast. Klone das YOLOv5-Repository und installiere die erforderlichen Abhängigkeiten aus der requirements.txt. Eine Python>=3.8.0 Umgebung mit PyTorch>=1.8 ist unerlässlich. Modelle und Datasets 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

Training mit benutzerdefinierten Daten

Die Entwicklung eines benutzerdefinierten Objekterkennungs Modells 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 dazu unseren Leitfaden zur Datensammlung und Annotation.
2. Objekte beschriften: Annotiere die interessierenden Objekte in deinen Bildern präzise.
3. Ein Modell trainieren: Nutze die beschrifteten Daten, um dein YOLOv5 Modell zu trainieren. Nutze Transfer Learning, indem du mit vortrainierten Gewichten startest.
4. Bereitstellen & Vorhersagen: Nutze das trainierte Modell für die Inferenz an neuen, ungesehenen Daten.
5. Edge Cases sammeln: Identifiziere Szenarien, in denen das Modell schlecht abschneidet (Edge Cases), und füge ähnliche Daten zu deinem Dataset hinzu, um die Robustheit zu verbessern. Wiederhole den Zyklus.

Die Ultralytics Platform bietet eine optimierte, No-Code-Lösung für diesen gesamten Machine Learning Operations (MLOps) Zyklus, einschließlich Dataset-Verwaltung, 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 lernen. Die korrekte Organisation deines Datasets ist der Schlüssel.

1.1 Erstelle dataset.yaml

Die Konfigurationsdatei des Datasets (z. B. coco128.yaml) umreißt die Struktur des Datasets, Klassennamen und Pfade zu Bildverzeichnissen. COCO128 dient als kleines Beispieldataset und umfasst die ersten 128 Bilder aus dem umfangreichen COCO Dataset. Es ist nützlich, um die Trainingspipeline schnell zu testen und potenzielle Probleme wie Overfitting zu diagnostizieren.

Die Struktur der dataset.yaml Datei umfasst:

• path: Das Stammverzeichnis, das das Dataset enthält.
• train, val, test: Relative Pfade von path zu Verzeichnissen, die Bilder enthalten, oder Textdateien, die Bildpfade für Trainings-, Validierungs- und Testsets auflisten.
• names: Ein Wörterbuch, 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 anzeigen):

# 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 Nutze Modelle für die automatisierte Beschriftung

Manuelle Beschriftung ist der übliche Ansatz, aber zeitaufwendig. Grundlegende Modelle (Foundation Models) können die Annotation automatisieren oder halb-automatisieren und die Datensatzerstellung beschleunigen. Beispiele für Modelle, die beim Generieren von Labels helfen können:

• Google Gemini: Große multimodale Modelle wie Gemini besitzen leistungsstarke Bildverständnisfähigkeiten. Sie können dazu aufgefordert werden, Objekte in Bildern zu identifizieren und zu lokalisieren, wobei Bounding Boxes oder Beschreibungen generiert werden, die in YOLO-Format-Labels konvertiert werden können. Entdecke ihr Potenzial im bereitgestellten Tutorial-Notebook.
• SAM2 (Segment Anything Model 2): Auf Segmentierung fokussierte Grundmodelle wie SAM2 können Objekte mit hoher Präzision identifizieren und eingrenzen. Obwohl sie primär für die Segmentierung gedacht sind, können die resultierenden Masken oft in Bounding-Box-Annotationen umgewandelt werden, die für Objekterkennungsaufgaben geeignet sind.
• YOLOWorld: Dieses Modell bietet Funktionen zur Erkennung mit offenem Vokabular (Open-Vocabulary Detection). Du kannst Textbeschreibungen der Objekte angeben, an denen du interessiert bist, und YOLOWorld kann sie in Bildern finden, ohne vorheriges Training auf diesen spezifischen Klassen. Dies kann als Startpunkt für die Generierung erster Labels verwendet werden, die dann verfeinert werden können.

Die Verwendung dieser Modelle kann einen "Vor-Beschriftungsschritt" bieten, der den manuellen Aufwand reduziert. Es ist jedoch entscheidend, automatisch generierte Labels zu überprüfen und zu verfeinern, um Genauigkeit und Konsistenz sicherzustellen, da die Qualität die Leistung deines trainierten YOLOv5-Modells direkt beeinflusst. Stelle nach dem Generieren (und potenziellen 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, nullbasierter Klassenindex). Wenn ein Bild keine interessierenden Objekte enthält, ist keine entsprechende *.txt Datei erforderlich.

Die Spezifikationen für die YOLO-Format *.txt Datei sind präzise:

• Eine Zeile pro Objekt Bounding Box.
• Jede Zeile muss enthalten: class_index x_center y_center width height.
• Koordinaten müssen auf einen Bereich zwischen 0 und 1 normalisiert sein. Um dies zu erreichen, teile 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, die zweite durch 1 usw. repräsentiert).

Die Label-Datei, die dem obigen Bild entspricht und zwei 'person' Objekte (Klassenindex 0) und ein 'tie' Objekt (Klassenindex 27) enthält, würde so aussehen:

1.3 Verzeichnisse organisieren

Strukturiere dein Datasets Verzeichnis wie unten dargestellt. Standardmäßig erwartet YOLOv5, dass sich das Dataset-Verzeichnis (z. B. /coco128) innerhalb eines /datasets Ordners befindet, der sich angrenzend an das /yolov5 Repository-Verzeichnis befindet.

YOLOv5 lokalisiert die Labels für jedes Bild automatisch, indem die letzte Instanz 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)
            └── ...

Wähle ein Modell

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

Trainiere

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

• --img: Definiert die Eingabe-Bildgröße (z. B. --img 640). Größere Größen liefern im Allgemeinen eine bessere Genauigkeit, erfordern aber 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: Specifies the total number of training epochs (e.g., --epochs 100). One epoch represents a full pass over the entire training dataset.
• --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 für eine schnellere Konvergenz und überlegene Ergebnisse. Um von Grund auf zu trainieren (nicht empfohlen, es sei denn, du hast ein sehr großes Dataset und spezifische 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 Gewichte und Logs, werden im Verzeichnis runs/train/ gespeichert. Jede Trainingssitzung erstellt ein neues Unterverzeichnis (z. B. runs/train/exp, runs/train/exp-2 usw.). Erkunde für eine interaktive, praktische Erfahrung den Trainingsabschnitt in unseren offiziellen Tutorial-Notebooks:

Visualisiere

YOLOv5 integriert sich nahtlos in verschiedene Tools zur Visualisierung des Trainingsfortschritts, zur Auswertung von Ergebnissen und zur Überwachung der Leistung in Echtzeit.

Comet Logging und Visualisierung

Comet ist vollständig integriert für eine umfassende Experiment-Nachverfolgung. Visualisiere Metriken live, speichere Hyperparameter, verwalte Datasets und Modell-Checkpoints und analysiere Modellvorhersagen mithilfe interaktiver 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!

Tauche tiefer in die unterstützten Funktionen in unserem Comet Integrationsleitfaden ein. Erfahre mehr über die Fähigkeiten von Comet aus deren offizieller Dokumentation. Probiere das Comet Colab Notebook für eine Live-Demo aus:

ClearML Logging und Automatisierung

Die ClearML Integration ermöglicht detaillierte Experiment-Nachverfolgung, Dataset-Versionsverwaltung und sogar die Fernausfü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 (entweder selbst gehostet oder die kostenlose Stufe) zu verbinden.

ClearML erfasst automatisch Experimentdetails, Modell-Uploads, Vergleiche, nicht festgeschriebene Code-Änderungen und installierte Pakete, was volle Reproduzierbarkeit sicherstellt. Du kannst Trainingsaufgaben einfach auf Remote-Agenten planen und Dataset-Versionen mithilfe von ClearML Data verwalten. Erkunde den ClearML Integrationsleitfaden für umfassende Details.

Lokales Logging

Trainingsergebnisse werden automatisch mit TensorBoard geloggt und als CSV Dateien innerhalb des spezifischen Experiment-Verzeichnisses (z. B. runs/train/exp) gespeichert. Geloggte Daten beinhalten:

• 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 (PR) Kurven.
• Confusion matrices for detailed class-wise performance analysis.

Die results.csv Datei wird nach jeder Epoche aktualisiert und als results.png geplottet, sobald das Training abgeschlossen ist. Du kannst auch jede results.csv Datei manuell mithilfe 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 beinhalten:

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

Unterstützte Umgebungen

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

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

Projektstatus

Dieses Badge zeigt an, dass alle YOLOv5 GitHub Actions Continuous Integration (CI) Tests erfolgreich bestanden werden. Diese strengen CI-Tests decken die Kernfunktionen ab, einschließlich Training, Validierung, Inferenz, Export und Benchmarks, über macOS, Windows und Ubuntu Betriebssysteme hinweg. Tests werden alle 24 Stunden und bei jedem Code-Commit automatisch ausgeführt, was konsistente Stabilität und optimale Leistung sicherstellt.

FAQ

Wie trainiere ich YOLOv5 mit meinem benutzerdefinierten Dataset?

Das Training von YOLOv5 mit einem benutzerdefinierten Dataset beinhaltet mehrere wichtige Schritte:

1. Bereite deinen Datensatz vor: Sammle Bilder und annotiere sie. Stelle sicher, dass die Annotationen im erforderlichen YOLO format vorliegen. Organisiere Bilder und Labels in train/ und val/ (und optional test/) Verzeichnissen. Erwäge die Nutzung von Modellen wie Google Gemini, SAM2 oder YOLOWorld, um den Labeling-Prozess zu unterstützen oder zu automatisieren (siehe Abschnitt 1.2).
2. Richte deine Umgebung ein: Klon das YOLOv5 Repository und installiere die Abhängigkeiten mit pip install -r requirements.txt.

   git clone https://github.com/ultralytics/yolov5
   cd yolov5
   pip install -r requirements.txt

3. Erstelle die Datensatzkonfiguration: Definiere Datensatzpfade, Anzahl der Klassen und Klassennamen in einer dataset.yaml Datei.
4. Starte das Training: Führe das train.py Skript aus und gib dabei die Pfade zu deiner dataset.yaml, die gewünschten vortrainierten Gewichte (z. B. yolov5s.pt), die Bildgröße, die Batch-Größe und die Anzahl der Epochen an.

   python train.py --img 640 --batch 16 --epochs 100 --data path/to/your/dataset.yaml --weights yolov5s.pt

Warum sollte ich die Ultralytics Platform für das Training meiner YOLO Modelle verwenden?

Ultralytics Platform ist eine umfassende Plattform, die darauf ausgelegt ist, den gesamten Entwicklungszyklus von YOLO Modellen zu rationalisieren, oft ohne dass eine einzige Zeile Code geschrieben werden muss. Die Hauptvorteile sind:

• Vereinfachtes Training: Trainiere Modelle ganz einfach mit vorkonfigurierten Umgebungen und einer intuitiven Benutzeroberfläche.
• Integrierte Datenverwaltung: Lade deine Datensätze hoch, verwalte Versionen und kontrolliere sie effizient direkt auf der Plattform.
• Echtzeit-Überwachung: Verfolge den Trainingsfortschritt und visualisiere Leistungsmetriken mit integrierten Tools wie Comet oder TensorBoard.
• Funktionen für die Zusammenarbeit: Erleichtert die Teamarbeit durch geteilte Ressourcen, Projektmanagement-Tools und einfaches Teilen von Modellen.
• No-Code-Bereitstellung: Stelle trainierte Modelle direkt auf verschiedenen Zielsystemen bereit.

Für eine praktische Anleitung schau dir unseren Blogbeitrag an: How to Train Your Custom Models with Ultralytics Platform.

Wie konvertiere ich meine annotierten Daten in das YOLOv5 Format?

Egal, ob du manuell annotierst oder automatisierte Tools verwendest (wie die in Abschnitt 1.2 erwähnten), die endgültigen Labels müssen im spezifischen YOLO format vorliegen, das von YOLOv5 benötigt wird:

• Erstelle für jedes Bild eine .txt Datei. Der Dateiname sollte mit dem Bildnamen übereinstimmen (z. B. entspricht image1.jpg der Datei image1.txt). Lege diese Dateien in einem labels/ Verzeichnis ab, das parallel zu deinem images/ Verzeichnis liegt (z. B. ../datasets/mydataset/labels/train/).
• Jede Zeile innerhalb einer .txt Datei repräsentiert eine Objektannotation und folgt dem Format: class_index center_x center_y width height.
• Koordinaten (center_x, center_y, width, height) müssen relativ zu den Bilddimensionen normalisiert sein (Werte zwischen 0.0 und 1.0).
• Klassenindizes sind nullbasiert (die erste Klasse ist 0, die zweite 1, usw.).

Viele manuelle Annotationstools bieten einen direkten Export ins YOLO Format an. Wenn du automatisierte Modelle verwendest, benötigst du Skripte oder Prozesse, um deren Ausgabe (z. B. Bounding-Box-Koordinaten, Segmentierungsmasken) in dieses spezifische normalisierte Textformat umzuwandeln. Stelle sicher, dass deine endgültige Datensatzstruktur dem im Leitfaden bereitgestellten Beispiel entspricht. Weitere Details findest du in unserem Data Collection and Annotation Guide.

Welche Lizenzoptionen gibt es für die Verwendung von YOLOv5 in kommerziellen Anwendungen?

Ultralytics bietet flexible Lizenzierungsoptionen an, die auf unterschiedliche Bedürfnisse zugeschnitten sind:

• AGPL-3.0 License: Diese Open-Source-Lizenz eignet sich für akademische Forschung, persönliche Projekte und Situationen, in denen die Einhaltung von Open-Source-Vorgaben akzeptabel ist. Sie schreibt vor, dass Modifikationen und abgeleitete Werke ebenfalls unter der AGPL-3.0 Open-Source-Lizenz veröffentlicht werden müssen. Überprüfe die AGPL-3.0 License details.
• Enterprise License: Eine kommerzielle Lizenz, die für Unternehmen entwickelt wurde, die YOLOv5 in ihre proprietären Produkte oder Dienstleistungen integrieren. Diese Lizenz entfernt die Open-Source-Verpflichtungen der AGPL-3.0 und ermöglicht eine Closed-Source-Distribution. Besuche unsere Licensing page für weitere Details oder um eine Enterprise License anzufragen.

Wähle die Lizenz aus, die am besten zu den Anforderungen und dem Vertriebsmodell deines Projekts passt.