Fehlersuche bei häufigen YOLO Problemen

YOLO Gemeinsame Probleme Bild

Einführung

Dieser Leitfaden ist ein umfassendes Hilfsmittel zur Behebung häufiger Probleme, die bei der Arbeit mit YOLOv8 in deinen Ultralytics Projekten auftreten. Mit der richtigen Anleitung ist es ein Kinderspiel, diese Probleme zu lösen und sicherzustellen, dass deine Projekte ohne unnötige Verzögerungen weiterlaufen.

Pass auf: Ultralytics YOLOv8 Allgemeine Probleme | Installationsfehler, Probleme bei der Modellschulung

Gemeinsame Probleme

Fehler bei der Installation

Installationsfehler können aus verschiedenen Gründen auftreten, z. B. wegen inkompatibler Versionen, fehlender Abhängigkeiten oder falscher Umgebungseinstellungen. Überprüfe zunächst, ob du die folgenden Punkte beachtest:

Du verwendest Python 3.8 oder höher, wie empfohlen.
Stelle sicher, dass du die richtige Version von PyTorch (1.8 oder höher) installiert hast.
Erwäge den Einsatz von virtuellen Umgebungen, um Konflikte zu vermeiden.
Folge der offiziellen Installationsanleitung Schritt für Schritt.

Außerdem findest du hier einige häufige Probleme bei der Installation und die entsprechenden Lösungen:

Importfehler oder Abhängigkeitsprobleme - Wenn du beim Import von YOLOv8 Fehler erhältst oder Probleme mit Abhängigkeiten hast, beachte die folgenden Schritte zur Fehlerbehebung:
- Neuinstallation: Manchmal kann eine Neuinstallation unerwartete Probleme beheben. Vor allem bei Bibliotheken wie Ultralytics, bei denen Aktualisierungen Änderungen an der Dateibaumstruktur oder den Funktionen mit sich bringen können.
- Regelmäßig aktualisieren: Stelle sicher, dass du die neueste Version der Bibliothek verwendest. Ältere Versionen sind möglicherweise nicht mit aktuellen Updates kompatibel, was zu Konflikten oder Problemen führen kann.
- Abhängigkeiten prüfen: Überprüfe, ob alle erforderlichen Abhängigkeiten korrekt installiert sind und die kompatiblen Versionen haben.
- Änderungen überprüfen: Wenn du ursprünglich eine ältere Version geklont oder installiert hast, solltest du dir bewusst sein, dass wichtige Aktualisierungen die Struktur oder die Funktionen der Bibliothek beeinflussen können. Sieh dir immer die offizielle Dokumentation oder die Änderungsprotokolle an, um alle wichtigen Änderungen zu verstehen.
- Denke daran, dass du deine Bibliotheken und Abhängigkeiten auf dem neuesten Stand halten musst, um ein reibungsloses und fehlerfreies Arbeiten zu gewährleisten.
YOLOv8 auf der GPU ausführen - Wenn du Probleme hast, YOLOv8 auf der GPU auszuführen, beachte die folgenden Schritte zur Fehlerbehebung:
- Überprüfe die CUDA Kompatibilität und Installation: Vergewissere dich, dass dein Grafikprozessor CUDA-kompatibel ist und dass CUDA korrekt installiert ist. Verwende die nvidia-smi um den Status deines NVIDIA Grafikprozessors und deiner CUDA Version zu überprüfen.
- Prüfe PyTorch und CUDA Integration: Stellen Sie sicher, dass PyTorch CUDA nutzen kann, indem Sie import torch; print(torch.cuda.is_available()) in einem Python Terminal. Wenn sie "True" zurückgibt, ist PyTorch für die Verwendung von CUDA eingerichtet.
- Umgebungsaktivierung: Stelle sicher, dass du dich in der richtigen Umgebung befindest, in der alle notwendigen Pakete installiert sind.
- Aktualisiere deine Pakete: Veraltete Pakete sind möglicherweise nicht mit deinem Grafikprozessor kompatibel. Halte sie auf dem neuesten Stand.
- Programmkonfiguration: Prüfe, ob das Programm oder der Code die GPU-Nutzung vorgibt. In YOLOv8 kann dies in den Einstellungen oder der Konfiguration stehen.

Fragen zur Modellausbildung

In diesem Abschnitt geht es um häufige Probleme, die während der Ausbildung auftreten, sowie um die entsprechenden Erklärungen und Lösungen.

Überprüfung der Konfigurationseinstellungen

Ausgabe: Du bist dir nicht sicher, ob die Konfigurationseinstellungen in der .yaml Datei während der Modellschulung korrekt angewendet werden.

Lösung: Die Konfigurationseinstellungen in der .yaml Datei angewendet werden sollte, wenn die model.train() Funktion. Um sicherzustellen, dass diese Einstellungen richtig angewendet werden, befolge diese Schritte:

Bestätigen Sie, dass der Pfad zu Ihrem .yaml Konfigurationsdatei korrekt ist.
Stellen Sie sicher, dass Sie den Pfad zu Ihrem .yaml Datei als die data Argument beim Aufruf von model.train()wie unten dargestellt:

model.train(data='/path/to/your/data.yaml', batch=4)

Beschleunigung der Ausbildung mit mehreren GPUs

Problem: Das Training ist auf einem einzelnen Grafikprozessor langsam und du möchtest den Prozess mit mehreren GPUs beschleunigen.

Lösung: Die Erhöhung der Stapelgröße kann das Training beschleunigen, aber es ist wichtig, die Speicherkapazität der GPU zu berücksichtigen. Um das Training mit mehreren GPUs zu beschleunigen, befolge diese Schritte:

Stelle sicher, dass du mehrere GPUs zur Verfügung hast.
Ändere deine .yaml-Konfigurationsdatei, um die Anzahl der zu verwendenden GPUs anzugeben, z. B. gpus: 4.
Erhöhe die Stapelgröße entsprechend, um die mehreren GPUs voll auszunutzen, ohne die Speichergrenzen zu überschreiten.
Ändere deinen Trainingsbefehl, um mehrere GPUs zu nutzen:

# Adjust the batch size and other settings as needed to optimize training speed
model.train(data='/path/to/your/data.yaml', batch=32, multi_scale=True)

Parameter für die kontinuierliche Überwachung

Problem: Du möchtest wissen, welche Parameter neben dem Verlust während des Trainings kontinuierlich überwacht werden sollten.

Lösung: Auch wenn der Verlust eine wichtige Kennzahl ist, die überwacht werden muss, ist es wichtig, auch andere Kennzahlen zur Optimierung der Modellleistung zu verfolgen. Einige wichtige Kennzahlen, die während der Ausbildung überwacht werden sollten, sind:

Präzision
Rückruf
Mittlere durchschnittliche Präzision (mAP)

Du kannst diese Metriken aus den Trainingsprotokollen abrufen oder Tools wie TensorBoard oder wandb zur Visualisierung verwenden. Ein frühzeitiges Stoppen auf der Grundlage dieser Metriken kann dir helfen, bessere Ergebnisse zu erzielen.

Tools zur Verfolgung des Trainingsfortschritts

Problem: Du suchst nach Empfehlungen für Tools, mit denen du den Trainingsfortschritt verfolgen kannst.

Lösung: Um den Trainingsfortschritt zu verfolgen und zu visualisieren, kannst du die folgenden Tools verwenden:

TensorBoard: TensorBoard ist eine beliebte Wahl für die Visualisierung von Trainingsmetriken, einschließlich Verlust, Genauigkeit und mehr. Du kannst es in deinen YOLOv8 Trainingsprozess integrieren.
Comet: Comet bietet ein umfangreiches Toolkit für die Nachverfolgung und den Vergleich von Experimenten. Damit kannst du Metriken, Hyperparameter und sogar Modellgewichte verfolgen. Die Integration mit YOLO Modellen ist ebenfalls unkompliziert und bietet dir einen vollständigen Überblick über deinen Experimentierzyklus.
Ultralytics HUB: Ultralytics HUB bietet eine spezielle Umgebung für die Nachverfolgung von YOLO Modellen und bietet dir eine zentrale Plattform für die Verwaltung von Metriken, Datensätzen und sogar für die Zusammenarbeit mit deinem Team. Da der Schwerpunkt auf YOLO liegt, bietet es mehr maßgeschneiderte Tracking-Optionen.

Jedes dieser Werkzeuge bietet seine eigenen Vorteile, daher solltest du bei deiner Entscheidung die besonderen Anforderungen deines Projekts berücksichtigen.

So überprüfst du, ob die Ausbildung auf dem Grafikprozessor stattfindet

Problem: Der Wert "Gerät" in den Trainingsprotokollen ist "null" und du bist dir nicht sicher, ob das Training auf der GPU stattfindet.

Lösung: Wenn der "device"-Wert "null" ist, bedeutet das in der Regel, dass der Trainingsprozess automatisch eine verfügbare GPU verwendet, was die Standardeinstellung ist. Um sicherzustellen, dass das Training auf einem bestimmten Grafikprozessor stattfindet, kannst du den "device"-Wert in deiner .yaml-Konfigurationsdatei manuell auf den GPU-Index setzen (z.B. "0" für den ersten Grafikprozessor):

device: 0

Dadurch wird der Trainingsprozess explizit der angegebenen GPU zugewiesen. Wenn du auf der CPU trainieren möchtest, setze "device" auf "cpu".

Behalte den Ordner "Läufe" für Protokolle und Messwerte im Auge, um den Trainingsfortschritt effektiv zu überwachen.

Wichtige Überlegungen für eine wirksame Modellschulung

Hier sind einige Dinge, die du beachten solltest, wenn du Probleme mit der Modellausbildung hast.

Format und Beschriftung der Datensätze

Wichtigkeit: Die Grundlage eines jeden maschinellen Lernmodells liegt in der Qualität und dem Format der Daten, auf denen es trainiert wird.
Empfehlung: Stelle sicher, dass dein benutzerdefinierter Datensatz und die dazugehörigen Beschriftungen dem erwarteten Format entsprechen. Es ist wichtig zu überprüfen, dass die Beschriftungen korrekt und von hoher Qualität sind. Falsche oder minderwertige Beschriftungen können den Lernprozess des Modells stören und zu unvorhersehbaren Ergebnissen führen.

Modell Konvergenz

Wichtigkeit: Das Erreichen der Modellkonvergenz stellt sicher, dass das Modell ausreichend aus den Trainingsdaten gelernt hat.
Empfehlung: Wenn du ein Modell "von Grund auf" trainierst, musst du unbedingt sicherstellen, dass das Modell einen zufriedenstellenden Grad an Konvergenz erreicht. Dies kann eine längere Trainingsdauer mit mehr Epochen erforderlich machen, als wenn du ein bestehendes Modell fein abstimmst.

Lernrate und Stapelgröße

Wichtigkeit: Diese Hyperparameter spielen eine entscheidende Rolle dabei, wie das Modell seine Gewichte während des Trainings aktualisiert.
Empfehlung: Überprüfe regelmäßig, ob die gewählte Lernrate und Batchgröße für deinen spezifischen Datensatz optimal sind. Parameter, die nicht mit den Eigenschaften des Datensatzes übereinstimmen, können die Leistung des Modells beeinträchtigen.

Klassenverteilung

Wichtigkeit: Die Verteilung der Klassen in deinem Datensatz kann die Vorhersagetendenzen des Modells beeinflussen.
Empfehlung: Überprüfe regelmäßig die Verteilung der Klassen innerhalb deines Datensatzes. Wenn es ein Ungleichgewicht zwischen den Klassen gibt, besteht die Gefahr, dass das Modell eine Tendenz zur vorherrschenden Klasse entwickelt. Diese Verzerrung kann sich in der Konfusionsmatrix zeigen, wenn das Modell überwiegend die Mehrheitsklasse vorhersagt.

Cross-Check mit vortrainierten Gewichten

Wichtigkeit: Die Nutzung von vortrainierten Gewichten kann einen soliden Ausgangspunkt für das Modelltraining bieten, vor allem wenn die Daten begrenzt sind.
Empfehlung: Als Diagnoseschritt solltest du dein Modell mit denselben Daten trainieren, es aber mit vorher trainierten Gewichten initialisieren. Wenn dieser Ansatz zu einer wohlgeformten Konfusionsmatrix führt, könnte dies darauf hindeuten, dass das Modell "von Grund auf" weiter trainiert oder angepasst werden muss.

In diesem Abschnitt geht es um häufige Probleme, die bei der Modellvorhersage auftreten.

Bounding Box-Vorhersagen mit deinem benutzerdefinierten Modell YOLOv8

Problem: Wenn du Vorhersagen mit einem benutzerdefinierten Modell von YOLOv8 durchführst, gibt es Probleme mit dem Format und der Visualisierung der Bounding-Box-Koordinaten.

Lösung:

Koordinatenformat: YOLOv8 bietet Bounding-Box-Koordinaten in absoluten Pixelwerten. Um diese in relative Koordinaten (von 0 bis 1) umzuwandeln, musst du durch die Bildgröße dividieren. Nehmen wir zum Beispiel an, dein Bild hat die Größe 640x640. Dann würdest du Folgendes tun:

# Convert absolute coordinates to relative coordinates
x1 = x1 / 640  # Divide x-coordinates by image width
x2 = x2 / 640
y1 = y1 / 640  # Divide y-coordinates by image height
y2 = y2 / 640

Dateiname: Um den Dateinamen des Bildes zu erhalten, für das du eine Vorhersage machst, greifst du in deiner Vorhersageschleife direkt auf den Pfad der Bilddatei im Ergebnisobjekt zu.

Filterung von Objekten in YOLOv8 Vorhersagen

Problem: Probleme beim Filtern und Anzeigen nur bestimmter Objekte in den Vorhersageergebnissen, wenn YOLOv8 mit der Bibliothek Ultralytics ausgeführt wird.

Lösung: Um bestimmte Klassen zu erkennen, gibst du mit dem Argument classes die Klassen an, die du in der Ausgabe berücksichtigen willst. Um zum Beispiel nur Autos zu erkennen (unter der Annahme, dass "Autos" den Klassenindex 2 haben):

yolo task=detect mode=segment model=yolov8n-seg.pt source='path/to/car.mp4' show=True classes=2

Das Verständnis von Präzisionsmetriken in YOLOv8

Problem: Verwirrung bezüglich des Unterschieds zwischen der Genauigkeit der Box, der Genauigkeit der Maske und der Genauigkeit der Konfusionsmatrix in YOLOv8.

Lösung: Die Box-Präzision misst die Genauigkeit der vorhergesagten Bounding-Boxen im Vergleich zu den tatsächlichen Bounding-Boxen unter Verwendung der Metrik IoU (Intersection over Union). Die Maskenpräzision bewertet die Übereinstimmung zwischen den vorhergesagten Segmentierungsmasken und den tatsächlichen Masken bei der pixelbasierten Objektklassifizierung. Die Genauigkeit der Konfusionsmatrix hingegen konzentriert sich auf die Gesamtklassifizierungsgenauigkeit über alle Klassen hinweg und berücksichtigt nicht die geometrische Genauigkeit der Vorhersagen. Es ist wichtig zu wissen, dass eine Bounding Box auch dann geometrisch genau sein kann (true positive), wenn die Klassenvorhersage falsch ist, was zu Unterschieden zwischen Box Precision und Confusion Matrix Precision führt. Diese Metriken bewerten unterschiedliche Aspekte der Leistung eines Modells und spiegeln damit die Notwendigkeit unterschiedlicher Bewertungsmetriken für verschiedene Aufgaben wider.

Extrahieren von Objektdimensionen in YOLOv8

Problem: Es ist schwierig, die Länge und Höhe der erkannten Objekte in YOLOv8 abzurufen, vor allem, wenn mehrere Objekte in einem Bild erkannt werden.

Lösung: Um die Abmessungen der Begrenzungsrahmen zu ermitteln, verwende zunächst das Modell Ultralytics YOLOv8 , um Objekte in einem Bild vorherzusagen. Dann extrahierst du die Breiten- und Höheninformationen der Bounding Boxes aus den Vorhersageergebnissen.

from ultralytics import YOLO

# Load a pre-trained YOLOv8 model
model = YOLO('yolov8n.pt')

# Specify the source image
source = 'https://ultralytics.com/images/bus.jpg'

# Make predictions
results = model.predict(source, save=True, imgsz=320, conf=0.5)

# Extract bounding box dimensions
boxes = results[0].boxes.xywh.cpu()
for box in boxes:
    x, y, w, h = box
    print(f"Width of Box: {w}, Height of Box: {h}")

Herausforderungen bei der Bereitstellung

Probleme bei der GPU-Bereitstellung

Problem: Der Einsatz von Modellen in einer Multi-GPU-Umgebung kann manchmal zu unerwartetem Verhalten führen, z. B. zu unerwarteter Speichernutzung, inkonsistenten Ergebnissen auf verschiedenen GPUs usw.

Lösung: Prüfe, ob die GPU standardmäßig initialisiert wird. Einige Frameworks wie PyTorch initialisieren CUDA-Operationen möglicherweise auf einer Standard-GPU, bevor sie zu den vorgesehenen GPUs übergehen. Um unerwartete Standardinitialisierungen zu umgehen, gib die GPU direkt bei der Bereitstellung und Vorhersage an. Verwende dann Tools zur Überwachung der GPU-Auslastung und der Speichernutzung, um Anomalien in Echtzeit zu erkennen. Stelle außerdem sicher, dass du die neueste Version des Frameworks oder der Bibliothek verwendest.

Probleme bei der Modellkonvertierung/beim Exportieren

Problem: Beim Konvertieren oder Exportieren von Machine-Learning-Modellen in verschiedene Formate oder Plattformen können Fehler oder unerwartete Verhaltensweisen auftreten.

Lösung:

Kompatibilitätsprüfung: Stelle sicher, dass du Versionen von Bibliotheken und Frameworks verwendest, die miteinander kompatibel sind. Nicht übereinstimmende Versionen können zu unerwarteten Fehlern bei der Konvertierung führen.
Umgebung zurücksetzen: Wenn du eine interaktive Umgebung wie Jupyter oder Colab verwendest, solltest du nach wichtigen Änderungen oder Installationen einen Neustart deiner Umgebung in Betracht ziehen. Ein Neustart kann manchmal die zugrunde liegenden Probleme lösen.
Offizielle Dokumentation: Beziehe dich immer auf die offizielle Dokumentation des Tools oder der Bibliothek, die du für die Konvertierung verwendest. Sie enthält oft spezielle Richtlinien und Best Practices für den Modellexport.
Community-Unterstützung: Suche im offiziellen Repository der Bibliothek oder des Frameworks nach ähnlichen Problemen, die von anderen Nutzern gemeldet wurden. Möglicherweise haben die Betreuer oder die Community in Diskussionsforen Lösungen oder Workarounds bereitgestellt.
Regelmäßig aktualisieren: Stelle sicher, dass du die neueste Version des Tools oder der Bibliothek verwendest. Die Entwickler veröffentlichen häufig Updates, die bekannte Fehler beheben oder die Funktionalität verbessern.
Teste schrittweise: Bevor du eine vollständige Umstellung durchführst, solltest du den Prozess mit einem kleineren Modell oder Datensatz testen, um mögliche Probleme frühzeitig zu erkennen.

Gemeinschaft und Unterstützung

Der Kontakt zu einer Gemeinschaft von Gleichgesinnten kann deine Erfahrungen und deinen Erfolg bei der Arbeit mit YOLOv8 erheblich verbessern. Im Folgenden findest du einige Kanäle und Ressourcen, die dir helfen können.

Foren und Kanäle, um Hilfe zu bekommen

GitHub Issues: Das Repository YOLOv8 auf GitHub hat eine Registerkarte "Issues", auf der du Fragen stellen, Fehler melden und neue Funktionen vorschlagen kannst. Die Community und die Betreuer sind hier aktiv und es ist ein guter Ort, um Hilfe bei bestimmten Problemen zu bekommen.

Ultralytics Discord-Server: Ultralytics hat einen Discord-Server, auf dem du dich mit anderen Nutzern und den Entwicklern austauschen kannst.

Offizielle Dokumentation und Ressourcen

Ultralytics YOLOv8 Docs: Die offizielle Dokumentation bietet einen umfassenden Überblick über YOLOv8 und enthält Anleitungen zur Installation, Nutzung und Fehlerbehebung.

Diese Ressourcen sollten eine solide Grundlage für die Fehlerbehebung und die Verbesserung deiner YOLOv8 Projekte sowie für den Kontakt mit anderen in der YOLOv8 Community bilden.

Fazit

Die Fehlerbehebung ist ein wesentlicher Bestandteil jedes Entwicklungsprozesses, und wenn man mit dem richtigen Wissen ausgestattet ist, kann man den Zeit- und Arbeitsaufwand für die Lösung von Problemen erheblich reduzieren. Dieser Leitfaden befasst sich mit den häufigsten Problemen, mit denen Nutzer/innen des YOLOv8 Modells im Ultralytics Ökosystem konfrontiert sind. Wenn du diese häufigen Probleme verstehst und angehst, kannst du einen reibungsloseren Projektverlauf gewährleisten und bessere Ergebnisse bei deinen Computer Vision Aufgaben erzielen.

Denk daran, dass die Ultralytics Community eine wertvolle Ressource ist. Der Austausch mit anderen Entwicklern und Experten kann zusätzliche Erkenntnisse und Lösungen liefern, die in der Standarddokumentation vielleicht nicht enthalten sind. Lerne immer weiter, experimentiere und teile deine Erfahrungen, um zum kollektiven Wissen der Gemeinschaft beizutragen.

Viel Spaß bei der Fehlersuche!

Erstellt am 2023-11-12, Aktualisiert am 2024-04-19
Autoren: RizwanMunawar (1), glenn-jocher (2)