Link to this sectionTrainiere 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 reale Anwendungen jenseits der allgemeinen Objekterkennung zuzuschneiden.

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 Objekterkennungsmodells ist ein iterativer Prozess:

1. Bilder sammeln & organisieren: Trage Bilder zusammen, 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: Nutze die annotierten Daten, um dein YOLOv5 Modell zu trainieren. Profitiere von Transfer Learning, indem du mit vortrainierten Gewichten startest.
4. Bereitstellen & Vorhersagen: Nutze das trainierte Modell für Inferenz an 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-Management, 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 Dataset-Konfigurationsdatei (z. B. coco128.yaml) skizziert die Struktur des Datasets, Klassennamen und Pfade zu den Bildverzeichnissen. COCO128 dient als kleines Beispiel-Dataset 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 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): Grundlagenmodelle für die Segmentierung, 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 Bounding-Box-Annotationen konvertiert werden, die für Objekterkennungsaufgaben geeignet sind.
• YOLOWorld: Dieses Modell bietet Open-Vocabulary-Erkennungsfunktionen. 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 Ausgangspunkt für die Generierung initialer 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 dargestellt. Standardmäßig erwartet YOLOv5, dass sich das Dataset-Verzeichnis (z. B. /coco128) innerhalb eines /datasets Ordners befindet, der angrenzend an das /yolov5 Repository-Verzeichnis liegt.

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. YOLOv5s ist zum Beispiel das zweitkleinste und schnellste Modell, geeignet für ressourcenbeschränkte Umgebungen. 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. Wesentliche Argumente sind:

• --img: Definiert die Bildgröße (z. B. --img 640). Größere Größen führen im Allgemeinen zu besserer Genauigkeit, benötigen 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 ein umfassendes Experiment-Tracking. 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 Funktionen von Comet in der offiziellen Dokumentation. Probiere das Comet Colab Notebook für eine Live-Demo aus:

Link to this sectionClearML Logging und Automatisierung#

Die ClearML Integration ermöglicht detailliertes Experiment-Tracking, Dataset-Versionsmanagement 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 einmal clearml-init aus, um eine Verbindung zu deinem ClearML Server herzustellen (entweder selbst gehostet oder der kostenlose Tarif).

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

Link to this sectionLokales Logging#

Trainingsergebnisse werden automatisch mit TensorBoard protokolliert und als CSV Dateien im spezifischen Experiment-Verzeichnis gespeichert (z. B. runs/train/exp). Protokollierte Daten beinhalten:

• 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 an neuen Bildern oder Videos mit dem trainierten Modell über das CLI oder Python aus.
• Führe eine Validierung durch, um die Genauigkeit und die Generalisierungsfähigkeiten des Modells auf verschiedenen Daten-Splits (z. B. einem Test-Set) zu bewerten.
• Exportiere das Modell in verschiedene Bereitstellungsformate wie ONNX, TensorFlow SavedModel oder TensorRT für eine optimierte Inferenz auf verschiedenen Plattformen.
• Nutze Techniken zur Hyperparameter-Optimierung, um potenziell zusätzliche Leistungssteigerungen herauszuholen.
• Verbessere dein Modell kontinuierlich, indem du unsere Tipps für beste Trainingsergebnisse befolgst 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-Anleitung
  • Amazon AWS: AWS Schnellstart-Anleitung
  • Microsoft Azure: AzureML Schnellstart-Leitfaden
• Lokale Einrichtung:
  • Docker: Docker Schnellstart-Leitfaden

Link to this sectionProjektstatus#

Dieses Abzeichen 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, über macOS, Windows und Ubuntu Betriebssysteme hinweg. Die Tests werden automatisch alle 24 Stunden und bei jedem Code-Commit ausgeführt, um 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 dein Dataset 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/) Verzeichnisse. Ziehe in Erwägung, Modelle wie Google Gemini, SAM2 oder YOLOWorld zu verwenden, um den Annotationsprozess 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 darauf ausgelegt ist, den gesamten YOLO-Modellentwicklungslebenszyklus zu optimieren, oft ohne dass 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. Bei der Verwendung automatisierter Modelle benötigst du Skripte oder Prozesse, um deren Ausgabe (z. B. Bounding-Box-Koordinaten, Segmentierungsmasken) in dieses spezifische normalisierte Textformat zu konvertieren. Stelle sicher, dass die Struktur deines finalen Datasets dem Beispiel im Leitfaden entspricht. Weitere Details findest du in unserem Leitfaden zur Datenerfassung und Annotation.

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.