Trainiere YOLOv5 auf benutzerdefinierten Daten

📚 Dieser Leitfaden erklärt, wie Sie Ihren eigenen benutzerdefinierten Datensatz mit dem YOLOv5 Modell 🚀 trainieren. Das Trainieren von benutzerdefinierten Modellen ist ein grundlegender Schritt, um Computer Vision-Lösungen auf spezifische reale Anwendungen jenseits der generischen Objekterkennung zuzuschneiden.

Bevor Sie beginnen

Stellen Sie zunächst sicher, dass Sie die notwendige Umgebung eingerichtet haben. Klonen Sie das YOLOv5-Repository und installieren Sie die erforderlichen Abhängigkeiten aus requirements.txt. Ein Python>=3.8.0 Umgebung mit PyTorch>=1.8 ist essentiell. Modelle und Datensätze werden automatisch von der neuesten YOLOv5 Version heruntergeladen. Veröffentlichung 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 Objekterkennungsmodells ist ein iterativer Prozess:

1. Collect & Organize Images: Sammeln Sie Bilder, die für Ihre spezifische Aufgabe relevant sind. Hochwertige, vielfältige Daten sind entscheidend. Siehe unseren Leitfaden zur Datenerfassung und -annotation.
2. Objekte beschriften: Annotieren Sie die interessierenden Objekte in Ihren Bildern präzise.
3. Modell trainieren: Verwenden Sie die beschrifteten Daten, um Ihr YOLOv5-Modell zu trainieren. Nutzen Sie Transfer Learning, indem Sie mit vortrainierten Gewichten beginnen.
4. Deploy & Predict: Nutzen Sie das trainierte Modell für Inferenz auf neuen, unbekannten Daten.
5. Collect Edge Cases: Identifizieren Sie Szenarien, in denen das Modell schlecht abschneidet (Edge Cases), und fügen Sie ähnliche Daten zu Ihrem Datensatz hinzu, um die Robustheit zu verbessern. Wiederholen Sie den Zyklus.

Ultralytics HUB bietet eine optimierte No-Code-Lösung für diesen gesamten Machine-Learning-Operations (MLOps)-Zyklus, einschließlich Datenmengenverwaltung, Modelltraining und Bereitstellung.

Vor dem Start des Trainings ist die Vorbereitung des Datensatzes unerlässlich.

1. Dataset erstellen

YOLOv5 Modelle benötigen gelabelte Daten, um die visuellen Eigenschaften von Objektklassen zu erlernen. Die korrekte Organisation Ihres Datasets ist entscheidend.

1.1 Erstellen dataset.yaml

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

Die dataset.yaml Datei-Struktur beinhaltet:

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

Nachfolgend finden Sie 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

Während die manuelle Beschriftung mit Tools ein gängiger Ansatz ist, kann der Prozess zeitaufwendig sein. Jüngste Fortschritte bei Foundation Models bieten Möglichkeiten zur Automatisierung oder Halbautomatisierung des Annotationsprozesses, wodurch die Erstellung von Datensätzen potenziell erheblich beschleunigt wird. Hier sind einige Beispiele für Modelle, die bei der Generierung von Labels helfen können:

• Google Gemini: Große multimodale Modelle wie Gemini besitzen leistungsstarke Fähigkeiten zum Bildverständnis. Sie können aufgefordert werden, Objekte in Bildern zu identifizieren und zu lokalisieren und Begrenzungsrahmen oder Beschreibungen zu generieren, die in YOLO-Format-Labels konvertiert werden können. Entdecken Sie das Potenzial im bereitgestellten Tutorial-Notebook.
• SAM2 (Segment Anything Model 2): Foundation-Modelle, die sich auf die Segmentierung konzentrieren, wie SAM2, können Objekte mit hoher Präzision identifizieren und abgrenzen. Obwohl sie primär für die Segmentierung gedacht sind, können die resultierenden Masken oft in Begrenzungsrahmen-Annotationen umgewandelt werden, die für Objekterkennungsaufgaben geeignet sind.
• YOLOWorld: Dieses Modell bietet Erkennungsfunktionen mit offenem Vokabular. Sie können Textbeschreibungen der Objekte angeben, an denen Sie interessiert sind, und YOLOWorld kann diese in Bildern lokalisieren, ohne vorheriges Training mit 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 Schritt der "Vorab-Etikettierung" ermöglichen, wodurch der manuelle Aufwand reduziert wird. Es ist jedoch entscheidend, automatisch generierte Etiketten zu überprüfen und zu verfeinern, um Genauigkeit und Konsistenz sicherzustellen, da die Qualität die Leistung Ihres trainierten YOLOv5-Modells direkt beeinflusst. Nachdem Sie Ihre Etiketten generiert (und möglicherweise verfeinert) haben, stellen Sie sicher, dass sie den YOLO-Format: eins *.txt Datei pro Bild, wobei jede Zeile ein Objekt darstellt als class_index x_center y_center width height (normalisierte Koordinaten, nullbasierte Klasse). Wenn ein Bild keine interessierenden Objekte enthält, kein entsprechendes *.txt Datei wird benötigt.

Das YOLO-Format *.txt Datei-Spezifikationen sind präzise:

• Eine Zeile pro Objekt-Begrenzungsrahmen.
• Jede Zeile muss Folgendes enthalten: class_index x_center y_center width height.
• Koordinaten müssen sein normalisiert in einen Bereich zwischen 0 und 1. Um dies zu erreichen, dividieren Sie die Pixelwerte von x_center und width durch die Gesamtbreite des Bildes und dividieren 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.).

Die zum obigen Bild gehörende Beschriftungsdatei enthält zwei 'Person'-Objekte (Klassenindex 0) und ein 'tie'-Objekt (Klassenindex 27), würde wie folgt aussehen:

1.3 Verzeichnisse organisieren

Strukturieren Sie Ihre Datensätze Verzeichnis, wie unten dargestellt. Standardmäßig erwartet YOLOv5 das Datensatzverzeichnis (z. B. /coco128) sich innerhalb eines befinden muss /datasets befindet sich im Ordner benachbart zu das /yolov5 Repository-Verzeichnis.

YOLOv5 lokalisiert automatisch die Beschriftungen für jedes Bild, indem es die letzte Instanz von /images/ im Bildpfad mit /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)
            └── ...

2. Modell auswählen

Wählen Sie ein vorab trainiertes Modell, um den Trainingsprozess zu starten. 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, die jeweils Geschwindigkeit und Genauigkeit unterschiedlich ausbalancieren. Zum Beispiel ist YOLOv5s das zweitkleinste und schnellste Modell, das für ressourcenbeschränkte Umgebungen geeignet ist. In der README-Tabelle finden Sie einen detaillierten Vergleich aller verfügbaren Modelle.

3. Trainieren

Beginnen Sie mit dem Modelltraining Verwendung des train.py Skript bereitstellt. Wesentliche Argumente sind:

• --img: Definiert die Eingabe Bildgröße (z. B. --img 640). Größere Größen führen im Allgemeinen zu einer besseren Genauigkeit, erfordern aber mehr GPU-Speicher.
• --batch: Bestimmt die Batch-Größe (z. B. --batch 16). Wählen Sie die größte Größe, die Ihre GPU verarbeiten kann.
• --epochs: Gibt die Gesamtzahl der Trainings an Epochen (z. B. --epochs 100). Eine Epoche stellt einen vollständigen Durchlauf über den gesamten Trainingsdatensatz dar.
• --data: Pfad zu Ihrem dataset.yaml Datei (z. B. --data coco128.yaml), oder Auto-Modus mit angegebener Auslastungsfraktion (
• --weights: Pfad zur initialen Gewichtsdatei. Verwenden von vortrainierten Gewichten (z. B. --weights yolov5s.pt) wird dringend empfohlen, um eine schnellere Konvergenz und bessere Ergebnisse zu erzielen. Um von Grund auf neu zu trainieren (nicht empfehlenswert, es sei denn, Sie haben einen sehr großen Datensatz und spezifische Anforderungen), verwenden Sie --weights '' --cfg yolov5s.yaml.

Vortrainierte Gewichte werden automatisch von der neuesten YOLOv5-Version 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 Ordner runs/train/ Verzeichnis. Jede Trainingseinheit erstellt ein neues Unterverzeichnis (z. B. runs/train/exp, runs/train/exp2, usw.). Für eine interaktive, praktische Erfahrung erkunden Sie den Schulungsbereich in unseren offiziellen Tutorial-Notebooks:

4. Visualisieren

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

Comet-Protokollierung und -Visualisierung 🌟 NEU

Comet ist vollständig integriert für eine umfassende Experimentverfolgung. Visualisieren Sie Metriken live, speichern Sie Hyperparameter, verwalten Sie Datensätze und Modell-Checkpoints und analysieren Sie 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!

Tauchen Sie tiefer in die unterstützten Funktionen in unserem Comet Integrationsanleitung. Erfahren Sie mehr über die Möglichkeiten von Comet auf der offiziellen Dokumentation. Testen Sie das Comet Colab Notebook für eine Live-Demo:

ClearML-Protokollierung und -Automatisierung 🌟 NEU

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

• Installieren Sie das Paket: pip install clearml
• ClearML initialisieren: Ausführen clearml-init einmal, um sich mit Ihrem ClearML-Server zu verbinden (entweder selbst gehostet oder dem kostenlose Stufe), oder Auto-Modus mit angegebener Auslastungsfraktion (

ClearML erfasst automatisch Experimentdetails, Modell-Uploads, Vergleiche, nicht übertragene Codeänderungen und installierte Pakete und gewährleistet so eine vollständige Reproduzierbarkeit. Sie können Training-Aufgaben einfach auf Remote-Agenten planen und Datensatzversionen mit ClearML Data verwalten. Erkunden Sie den ClearML-Integrationsleitfaden für umfassende Details.

Lokale Protokollierung

Die Trainingsergebnisse werden automatisch protokolliert mit TensorBoard und gespeichert als CSV Dateien innerhalb des spezifischen Experimentverzeichnisses (z. B. runs/train/exp). Protokollierte Daten umfassen:

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

Die results.csv Datei wird nach jeder Epoche aktualisiert und als Diagramm dargestellt results.png sobald das Training abgeschlossen ist. Sie können auch beliebige grafisch darstellen results.csv Datei manuell mithilfe der bereitgestellten Utility-Funktion:

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 leistungsstärkste Modell-Checkpoint (best.pt) gespeichert und ist bereit für die Bereitstellung oder weitere Verfeinerung. Mögliche nächste Schritte sind:

• Führen Sie Inferenz auf neuen Bildern oder Videos mit dem trainierten Modell über die CLI oder Python aus.
• Führen Sie eine Validierung durch, um die Genauigkeit und die Generalisierungsfähigkeiten des Modells anhand verschiedener Datensplits (z. B. eines zurückgehaltenen Testdatensatzes) zu bewerten.
• Exportieren Sie das Modell in verschiedene Bereitstellungsformate wie ONNX, TensorFlow SavedModel oder TensorRT für eine optimierte Inferenz auf verschiedenen Plattformen.
• Wenden Sie Hyperparameter-Tuning-Techniken an, um potenziell zusätzliche Leistungssteigerungen zu erzielen.
• Verbessern Sie Ihr Modell kontinuierlich, indem Sie unsere Tipps für beste Trainingsergebnisse befolgen und iterativ vielfältigere und anspruchsvollere Daten auf der Grundlage von Leistungsanalysen hinzufügen.

Unterstützte Umgebungen

Ultralytics bietet sofort einsatzbereite Umgebungen, die mit wichtigen 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 Quickstart-Anleitung
  • Amazon AWS: AWS-Schnellstartanleitung
  • Microsoft Azure: AzureML-Schnellstartanleitung
• Lokale Einrichtung:
  • Docker: Docker Quickstart-Anleitung

Projektstatus

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

FAQ

Häufig gestellte Fragen

Wie trainiere ich YOLOv5 mit meinem eigenen Datensatz?

Das Training von YOLOv5 mit einem benutzerdefinierten Datensatz umfasst mehrere wichtige Schritte:

1. Bereiten Sie Ihren Datensatz vor: Sammeln Sie Bilder und annotieren Sie diese. Stellen Sie sicher, dass sich die Annotationen im erforderlichen Format befinden YOLO-Format. Organisieren Sie Bilder und Beschriftungen in train/ und val/ (und optional test/) Verzeichnisse. Erwägen Sie die Verwendung von Modellen wie Google Gemini, SAM2, oder YOLOWorld zur Unterstützung oder Automatisierung des Kennzeichnungsprozesses (siehe Abschnitt 1.2).
2. Richten Sie Ihre Umgebung ein: Klonen Sie das YOLOv5-Repository und installieren Sie die Abhängigkeiten mit pip install -r requirements.txt.

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

3. Dataset-Konfiguration erstellen: Definieren Sie Dataset-Pfade, Anzahl der Klassen und Klassennamen in einer dataset.yaml Datei gespeichert werden.
4. Training starten: Führen Sie die train.py Skript, das Pfade zu Ihren dataset.yaml, gewünschte vortrainierte Gewichte (z. B. yolov5s.pt), Bildgröße, Batch-Größe und die Anzahl der Epochen.

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

Warum sollte ich Ultralytics HUB verwenden, um meine YOLO-Modelle zu trainieren?

Ultralytics HUB ist eine umfassende Plattform, die entwickelt wurde, um den gesamten Lebenszyklus der YOLO-Modellentwicklung zu rationalisieren, oft ohne dass Code geschrieben werden muss. Zu den wichtigsten Vorteilen gehören:

• Vereinfachtes Training: Modelle lassen sich einfach mit vorkonfigurierten Umgebungen und einer intuitiven Benutzeroberfläche trainieren.
• Integriertes Datenmanagement: Laden Sie Ihre Datensätze effizient innerhalb der Plattform hoch, verwalten Sie sie und führen Sie eine Versionskontrolle durch.
• Echtzeitüberwachung: Verfolgen Sie den Trainingsfortschritt und visualisieren Sie Leistungsmetriken mithilfe integrierter Tools wie Comet oder TensorBoard.
• Collaboration Features: Fördert die Teamarbeit durch gemeinsame Ressourcen, Projektmanagement-Tools und einfaches Modell-Sharing.
• No-Code Deployment: Stellen Sie trainierte Modelle direkt auf verschiedenen Zielen bereit.

Eine praktische Anleitung finden Sie in unserem Blog-Beitrag: So trainieren Sie Ihre eigenen Modelle mit Ultralytics HUB.

Wie konvertiere ich meine annotierten Daten in das YOLOv5-Format?

Unabhängig davon, ob Sie manuell annotieren oder automatisierte Tools verwenden (wie die in Abschnitt 1.2 genannten), müssen die endgültigen Beschriftungen im spezifischen YOLO-Format vorliegen, das von YOLOv5 benötigt wird:

• Einen erstellen .txt Datei für jedes Bild. Der Dateiname sollte mit dem Bilddateinamen übereinstimmen (z. B. image1.jpg entspricht image1.txt). Platzieren Sie diese Dateien in einem labels/ Verzeichnis parallel zu Ihrem images/ Verzeichnis (z. B. ../datasets/mydataset/labels/train/), oder Auto-Modus mit angegebener Auslastungsfraktion (
• Jede Zeile innerhalb einer .txt Datei stellt eine Objektannotation dar und folgt dem Format: class_index center_x center_y width height.
• Koordinaten (center_x, center_y, width, height) muss normalisiert (Werte zwischen 0.0 und 1.0) relativ zu den Abmessungen des Bildes.
• Klassenindizes sind nullbasiert (die erste Klasse ist 0, die zweite ist 1, usw.).

Viele manuelle Annotationstools bieten den direkten Export in das YOLO-Format an. Wenn Sie automatisierte Modelle verwenden, benötigen Sie Skripte oder Prozesse, um deren Ausgabe (z. B. Begrenzungsrahmenkoordinaten, Segmentierungsmasken) in dieses spezifische normalisierte Textformat zu konvertieren. Stellen Sie sicher, dass Ihre endgültige Datensatzstruktur dem im Leitfaden bereitgestellten Beispiel entspricht. Weitere Informationen finden Sie in unserem Leitfaden zur Datenerfassung und -annotation.

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

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

• AGPL-3.0-Lizenz: Diese Open-Source-Lizenz eignet sich für akademische Forschung, persönliche Projekte und Situationen, in denen Open-Source-Konformität akzeptabel ist. Sie schreibt vor, dass Modifikationen und abgeleitete Werke ebenfalls unter AGPL-3.0 Open-Source-Lizenzen stehen müssen. Lesen Sie die AGPL-3.0-Lizenzdetails.
• Enterprise-Lizenz: Eine kommerzielle Lizenz, die für Unternehmen entwickelt wurde, die YOLOv5 in proprietäre Produkte oder Dienstleistungen integrieren. Diese Lizenz beseitigt die Open-Source-Verpflichtungen von AGPL-3.0 und ermöglicht eine Closed-Source-Distribution. Besuchen Sie unsere Lizenzierungsseite für weitere Details oder um eine Enterprise-Lizenz anzufordern.

Wählen Sie die Lizenz aus, die am besten zu den Anforderungen und dem Vertriebsmodell Ihres Projekts passt.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 2 Monaten

Kommentare