Link to this sectionTrainiere YOLOv5 mit benutzerdefinierten Daten#

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

Link to this sectionBevor du beginnst#

Stelle zunächst sicher, dass deine Umgebung korrekt eingerichtet ist. 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 vom 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

Link to this sectionAuf benutzerdefinierten Daten trainieren#

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 unseren Leitfaden zu 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 beginnst.
4. Bereitstellen & Vorhersagen: Nutze das trainierte Modell für Inferenz auf neuen, unbekannten Daten.
5. Edge Cases sammeln: Identifiziere Szenarien, in denen das Modell schlecht abschneidet (Edge Cases) 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 Machine Learning Operations (MLOps) Zyklus, einschließlich Dataset-Verwaltung, Modelltraining und Bereitstellung.

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

Link to this sectionErstelle 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.

Link to this section1.1 Erstelle dataset.yaml#

Die Konfigurationsdatei für das Dataset (z. B. coco128.yaml) beschreibt die Struktur des Datasets, Klassennamen und Pfade zu Bildverzeichnissen. COCO128 dient als kleines Beispiel-Dataset, das die ersten 128 Bilder aus dem umfangreichen COCO Dataset umfasst. Es ist nützlich, um die Trainings-Pipeline schnell zu testen und potenzielle Probleme wie Overfitting zu diagnostizieren.

Die dataset.yaml Dateistruktur enthält:

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

Du kannst path entweder auf ein absolutes Verzeichnis setzen (z. B. /home/user/datasets/coco128) oder auf einen relativen Pfad wie ../datasets/coco128, wenn du das Training vom YOLOv5-Repository-Stammverzeichnis 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

Link to this section1.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 innerhalb von Bildern zu identifizieren und zu lokalisieren, wodurch Bounding Boxes oder Beschreibungen generiert werden, die in Labels im YOLO-Format umgewandelt werden können. Entdecke ihr Potenzial im bereitgestellten Tutorial-Notebook.
• SAM2 (Segment Anything Model 2): Foundation-Modelle, die sich auf Segmentierung konzentrieren, wie SAM2, können Objekte mit hoher Präzision identifizieren und abgrenzen. Obwohl primär für Segmentierung gedacht, können die resultierenden Masken oft in Bounding-Box-Annotationen umgewandelt werden, die für Objekterkennungsaufgaben geeignet sind.
• YOLOWorld: Dieses Modell bietet Funktionen zur Open-Vocabulary-Erkennung. Du kannst Textbeschreibungen der Objekte bereitstellen, an denen du interessiert bist, und YOLOWorld kann sie in Bildern ohne vorheriges Training auf diesen spezifischen Klassen lokalisieren. Dies kann als Ausgangspunkt für die Generierung erster Labels verwendet werden, die dann verfeinert werden können.

Die Verwendung dieser Modelle kann einen "Pre-Labeling"-Schritt bieten 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 direkt die Leistung deines trainierten YOLOv5 Modells beeinflusst. Nachdem du deine Labels generiert (und möglicherweise 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, nullbasierter Klassenindex). Wenn ein Bild keine interessierenden Objekte enthält, ist keine entsprechende *.txt Datei erforderlich.

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

• Eine Zeile pro Objekt Bounding Box.
• Jede Zeile muss enthalten: class_index x_center y_center width height.
• Die 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 repräsentiert, die zweite durch 1 usw.).

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:

Link to this section1.3 Verzeichnisse organisieren#

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

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

Link to this sectionEin Modell auswählen#

Wähle ein vortrainiertes Modell, um den Trainingsprozess zu starten. Der Beginn 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, das für Umgebungen mit begrenzten Ressourcen geeignet ist. Konsultiere die README-Tabelle für einen detaillierten Vergleich aller verfügbaren Modelle.

Link to this sectionTrainieren#

Beginne das Modelltraining mit dem train.py Skript. Wichtige Argumente sind:

• --img: Definiert die Eingabe-Bildgröße (z. B. --img 640). Größere Größen führen im Allgemeinen zu besserer 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: Gibt die Gesamtzahl der Trainings-Epochen an (z. B. --epochs 100). Eine Epoche stellt einen vollständigen Durchlauf über das gesamte Trainings-Dataset dar.
• --data: Pfad zu deiner dataset.yaml Datei (z. B. --data coco128.yaml).
• --weights: Pfad zur initialen Gewichtsdatei. Die Verwendung von vortrainierten Gewichten (z. B. --weights yolov5s.pt) wird für eine schnellere Konvergenz und bessere Ergebnisse dringend empfohlen. 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 vom 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 Logs, 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, praktische Erfahrung erkunde den Trainingsabschnitt in unseren offiziellen Tutorial-Notebooks:

Link to this sectionVisualisieren#

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

Link to this sectionComet Logging und Visualisierung#

Comet ist vollständig integriert für eine umfassende Experimentverfolgung. Visualisiere Metriken live, speichere Hyperparameter, verwalte Datasets 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!

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:

Link to this sectionClearML Logging und Automatisierung#

Die ClearML Integration ermöglicht detaillierte Experimentverfolgung, Dataset-Versionsmanagement 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 zu verbinden (entweder selbst gehostet oder über die free tier).

ClearML erfasst automatisch Experimentdetails, Modell-Uploads, Vergleiche, nicht übertragene Codeänderungen und installierte Pakete, was eine vollständige Reproduzierbarkeit gewährleistet. Du kannst Trainingstasks einfach auf Remote-Agenten planen und Dataset-Versionen mit ClearML Data verwalten. Erkunde den ClearML Integrationsleitfaden für umfassende Details.

Link to this sectionLokales Logging#

Trainingsergebnisse werden automatisch mit TensorBoard geloggt und als CSV Dateien im spezifischen Experimentverzeichnis (z. B. runs/train/exp) gespeichert. Geloggte Daten umfassen:

• Trainings- und Validierungsverlust sowie Leistungsmetriken.
• Beispielbilder, die angewendete Augmentationen (wie Mosaike) zeigen.
• Ground-Truth-Labels zusammen mit Modellvorhersagen zur visuellen Inspektion.
• Wichtige Bewertungsmetriken wie Precision-Recall (PR) Kurven.
• Konfusionsmatrizen für eine detaillierte klassenweise 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 Dienstprogrammfunktion 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

Link to this sectionNächste Schritte#

Nach erfolgreichem Abschluss des Trainings wird der am besten funktionierende Modell-Checkpoint (best.pt) gespeichert und ist bereit für die Bereitstellung oder weitere Verfeinerung. Potenzielle nächste Schritte sind:

• Führe Inferenz auf neuen Bildern oder Videos mit dem trainierten Modell über das CLI oder Python aus.
• Führe Validierung durch, um die Genauigkeit und Verallgemeinerungsfähigkeiten des Modells auf 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.
• Wende Hyperparameter-Tuning Techniken an, um möglicherweise zusätzliche Leistungssteigerungen herauszuholen.
• Setze die Verbesserung deines Modells fort, indem du unseren Tipps für beste Trainingsergebnisse folgst und iterativ vielfältigere und anspruchsvollere Daten basierend auf der Leistungsanalyse hinzufügst.

Link to this sectionUnterstü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-Schnellstart-Leitfaden
  • Amazon AWS: AWS-Schnellstartanleitung
  • Microsoft Azure: AzureML Schnellstartanleitung
• Lokale Einrichtung:
  • Docker: Docker Schnellstartanleitung

Link to this sectionProjektstatus#

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

Link to this sectionFAQ#

Link to this sectionWie trainiere ich YOLOv5 mit meinem eigenen Datensatz?#

Das Training von YOLOv5 mit einem benutzerdefinierten Datensatz umfasst 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 den Einsatz 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: Klone 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 Dataset-Konfiguration: Definiere die Pfade zum Datensatz, die Anzahl der Klassen und die Klassennamen in einer dataset.yaml Datei.
4. Starte das Training: Führe das train.py Skript aus und gib 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

Link to this sectionWarum sollte ich die Ultralytics Platform zum Trainieren meiner YOLO-Modelle verwenden?#

Die Ultralytics Platform ist eine umfassende Plattform, die entwickelt wurde, um den gesamten Lebenszyklus der YOLO-Modellentwicklung zu optimieren, oft ohne dass eine einzige Zeile Code geschrieben werden muss. Zu den Hauptvorteilen gehören:

• Vereinfachtes Training: Trainiere Modelle ganz einfach unter Verwendung vorkonfigurierter Umgebungen und einer intuitiven Benutzeroberfläche.
• Integriertes Datenmanagement: Lade deine Datensätze hoch, verwalte Versionen und bearbeite sie effizient innerhalb der Plattform.
• Echtzeit-Überwachung: Verfolge den Trainingsfortschritt und visualisiere Leistungsmetriken mit integrierten Tools wie Comet oder TensorBoard.
• Zusammenarbeitsfunktionen: Erleichtert die Teamarbeit durch geteilte Ressourcen, Projektmanagement-Tools und einfaches Teilen von Modellen.
• No-Code-Bereitstellung: Stelle trainierte Modelle direkt auf verschiedenen Zielplattformen bereit.

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

Link to this sectionWie 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 YOLOv5 erfordert:

• Erstelle eine .txt Datei für jedes Bild. Der Dateiname sollte dem Bildnamen entsprechen (z. B. image1.jpg entspricht 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 in 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 normalisiert sein (Werte zwischen 0.0 und 1.0), relativ zu den Dimensionen des Bildes.
• Klassenindizes sind nullbasiert (die erste Klasse ist 0, die zweite ist 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 Beispiel im Handbuch entspricht. Weitere Details findest du in unserem Data Collection and Annotation Guide.

Link to this sectionWelche Lizenzierungsoptionen gibt es für die Nutzung von YOLOv5 in kommerziellen Anwendungen?#

Ultralytics bietet flexible Lizenzierungen, die auf verschiedene 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 als Open Source bereitgestellt werden müssen. Überprüfe die AGPL-3.0 License details.
• Enterprise License: Eine kommerzielle Lizenz für Unternehmen, die YOLOv5 in eigene proprietäre Produkte oder Dienste integrieren. Diese Lizenz entbindet von den 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 deines Projekts und deinem Vertriebsmodell passt.