Fehlerbehebung bei häufigen YOLO-Problemen#

Diese Anleitung behandelt die häufigsten Probleme, auf die du bei der Arbeit mit Ultralytics YOLO26 stößt, gruppiert nach ihrem Auftreten: installation, model training, prediction und deployment. Springe zu der Kategorie, die zu deinem Fehler passt, oder durchsuche die FAQ nach schnellen Antworten. Jeder Eintrag nennt das Problem und eine konkrete Lösung, die du direkt anwenden kannst.

Häufige Probleme#

Installationsfehler#

Installationsfehler können aus verschiedenen Gründen auftreten, wie etwa inkompatible Versionen, fehlende Abhängigkeiten oder fehlerhafte Umgebungseinrichtungen. Überprüfe zuerst, ob du Folgendes beachtest:

• Du verwendest wie empfohlen Python 3.8 oder höher.
• Stelle sicher, dass du die korrekte Version von PyTorch (1.8 oder neuer) installiert hast.
• Erwäge die Verwendung von virtuellen Umgebungen, um Konflikte zu vermeiden.
• folge der official installation guide Schritt für Schritt.

Zusätzlich findest du hier Lösungen für häufige Installationsprobleme.

Importfehler oder Probleme mit Abhängigkeiten#

Wenn du Fehler beim Importieren von YOLO26 erhältst oder auf Konflikte bei Abhängigkeiten stößt, probiere diese Schritte aus:

• Neuinstallation: Eine saubere Neuinstallation kann unerwartete Probleme lösen, insbesondere nach Updates, die die Paketstruktur oder Funktionalität verändern.
• Regelmäßige Updates: Verwende die neueste Version der Bibliothek, da ältere Versionen möglicherweise nicht mit aktuellen Updates kompatibel sind.
• Abhängigkeiten prüfen: Überprüfe, ob alle erforderlichen Abhängigkeiten korrekt installiert sind und ob sie in kompatiblen Versionen vorliegen.
• Änderungen überprüfen: Wenn du eine ältere Version installiert hast, ziehe die offizielle Dokumentation oder das Changelog zu Rate, um wichtige strukturelle Änderungen zu verstehen.

YOLO26 auf der GPU ausführen#

Wenn du Probleme dabei hast, YOLO26 auf einer GPU auszuführen, ziehe die folgenden Schritte zur Fehlerbehebung in Betracht:

• CUDA-Kompatibilität und -Installation verifizieren: Stelle sicher, dass deine GPU CUDA-kompatibel ist und CUDA korrekt installiert ist. Verwende den Befehl nvidia-smi, um den Status deiner NVIDIA-GPU und die CUDA-Version zu überprüfen.
• PyTorch- und CUDA-Integration überprüfen: Stelle sicher, dass PyTorch CUDA nutzen kann, indem du import torch; print(torch.cuda.is_available()) in einem Python-Terminal ausführst. Wenn 'True' zurückgegeben wird, ist PyTorch für die Verwendung von CUDA eingerichtet.
• Umgebungsaktivierung: Stelle sicher, dass du dich in der korrekten Umgebung befindest, in der alle notwendigen Pakete installiert sind.
• Pakete aktualisieren: Veraltete Pakete sind möglicherweise nicht mit deiner GPU kompatibel. Halte sie auf dem neuesten Stand.
• Programmkonfiguration: Prüfe, ob dein Code die Verwendung einer GPU anfordert. Du kannst das Argument device beim Ausführen des Trainings oder der Vorhersage festlegen (zum Beispiel device=0).

import torch

cap = torch.cuda.get_device_capability(0) if torch.cuda.is_available() else (0, 0)
cudnn = torch.backends.cudnn.version() or 0
ok = "not compatible" if cudnn >= 91100 and (cap[0] < 7 or (cap[0] == 7 and cap[1] < 5)) else "should be ok"
print(f"Compute capability: SM {cap[0]}.{cap[1]}, cuDNN: {cudnn} => {ok}")

Probleme beim Modelltraining#

Häufige Probleme beim Training und deren Lösungen werden unten behandelt.

Überprüfung der Konfigurationseinstellungen#

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

Lösung: Die Konfigurationseinstellungen in der Datei .yaml sollten bei der Verwendung der Funktion model.train() angewendet werden. Folge diesen Schritten, um sicherzustellen, dass diese Einstellungen korrekt angewendet werden:

• Bestätige, dass der Pfad zu deiner Konfigurationsdatei .yaml korrekt ist.

• Stelle sicher, dass du den Pfad zu deiner Datei .yaml als Argument data übergibst, wenn du model.train() aufrufst, wie unten gezeigt:

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

Beschleunigung des Trainings mit mehreren GPUs#

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

Lösung: Das Erhöhen der batch size kann das Training beschleunigen, aber es ist wichtig, die Kapazität des GPU-Speichers zu berücksichtigen. Folge diesen Schritten, um das Training mit multiple GPUs zu beschleunigen:

• Stelle sicher, dass dir mehrere GPUs zur Verfügung stehen.

• Setze das Argument device auf eine Liste von GPU-Indizes, z. B. device=[0,1,2,3].

• Erhöhe die Batch-Größe entsprechend, um die mehreren GPUs voll auszunutzen, ohne die Speicherlimits zu überschreiten.

• Passe deinen Trainingsbefehl an, 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, device=[0, 1, 2, 3])

Kontinuierliche Überwachung der Parameter#

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

Lösung: Obwohl der Loss eine entscheidende Metrik zur Überwachung ist, ist es auch wichtig, andere Metriken für die Optimierung der Modellleistung zu verfolgen. Einige wichtige Metriken, die während des Trainings überwacht werden sollten, sind:

• Präzision
• Recall
• Mean Average Precision (mAP)

Du kannst auf diese Metriken in den Trainingsprotokollen zugreifen oder Tools wie TensorBoard oder wandb zur Visualisierung verwenden. Das Implementieren eines 'Early Stopping' auf Basis dieser Metriken kann dir helfen, bessere Ergebnisse zu erzielen.

Tools zur Nachverfolgung des Trainingsfortschritts#

Problem: Du suchst nach Empfehlungen für Tools, um den Fortschritt des Trainings zu verfolgen.

Lösung: Um den Trainingsfortschritt zu verfolgen und zu visualisieren, kannst du folgende Tools in Betracht ziehen:

• TensorBoard: TensorBoard ist eine beliebte Wahl zur Visualisierung von Trainingsmetriken, einschließlich Loss, accuracy und mehr. Du kannst es in deinen YOLO26-Trainingsprozess integrieren.
• Comet: Comet bietet ein umfangreiches Toolkit zur Nachverfolgung und zum Vergleich von Experimenten. Damit kannst du Metriken, Hyperparameter und sogar Modellgewichte nachverfolgen. Die Integration mit YOLO-Modellen ist ebenfalls unkompliziert und bietet dir eine vollständige Übersicht über deinen Experimentierzyklus.
• Ultralytics Platform: Ultralytics Platform bietet eine spezialisierte Umgebung zum Tracking von YOLO-Modellen und stellt dir eine zentrale Plattform zur Verwaltung von Metriken, Datensätzen und zur Zusammenarbeit mit deinem Team zur Verfügung. Angesichts des maßgeschneiderten Fokus auf YOLO bietet sie stärker angepasste Tracking-Optionen.

Wie du prüfst, ob das Training auf der GPU erfolgt#

Problem: Der 'device'-Wert in den Trainingsprotokollen ist 'null' und du bist dir unsicher, ob das Training auf der GPU läuft.

Lösung: Dass der Wert von 'device' 'null' ist, bedeutet in der Regel, dass der Trainingsprozess so eingestellt ist, dass er automatisch eine verfügbare GPU auswählt, was das Standardverhalten ist. Um auf einer bestimmten GPU zu trainieren, setze das Argument device beim Start des Trainings. device ist ein Trainingsargument, daher hat das Festlegen in deinem Dataset .yaml keine Auswirkungen:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Use GPU 0; device=[0, 1] for multiple GPUs, device="cpu" for CPU
model.train(data="path/to/data.yaml", device=0)

Behalte den 'runs'-Ordner für Protokolle und Metriken im Auge, um den Trainingsfortschritt effektiv zu überwachen.

Wichtige Überlegungen für ein effektives Modelltraining#

Hier sind einige Punkte, die du beachten solltest, falls du Probleme im Zusammenhang mit dem Modelltraining hast.

Datensatzformat und Labels

• Bedeutung: Das Fundament jedes machine learning-Modells liegt in der Qualität und dem Format der Daten, mit denen es trainiert wird.
• Empfehlung: Stelle sicher, dass dein benutzerdefinierter Datensatz und die zugehörigen Labels dem erwarteten Format entsprechen. Es ist entscheidend zu verifizieren, dass die Annotationen genau und von hoher Qualität sind. Falsche oder minderwertige Annotationen können den Lernprozess des Modells entgleisen lassen und zu unvorhersehbaren Ergebnissen führen.

Modellkonvergenz

• Bedeutung: Das Erreichen der Modellkonvergenz stellt sicher, dass das Modell ausreichend aus den training data gelernt hat.
• Empfehlung: Beim Training eines Modells 'from scratch' ist es entscheidend sicherzustellen, dass das Modell ein zufriedenstellendes Konvergenzniveau erreicht. Dies erfordert im Vergleich zum Fine-Tuning eines bestehenden Modells möglicherweise eine längere Trainingsdauer mit mehr epochs.

Learning Rate und Batch-Größe

• Bedeutung: Diese Hyperparameter spielen eine entscheidende Rolle dabei, wie das Modell während des Trainings seine Gewichte aktualisiert.
• Empfehlung: Evaluiere regelmäßig, ob die gewählte Lernrate und Batch-Größe für deinen spezifischen Datensatz optimal sind. Parameter, die nicht mit den Eigenschaften des Datensatzes harmonieren, können die Leistung des Modells behindern.

Klassenverteilung

• Bedeutung: Die Verteilung der Klassen in deinem Datensatz kann die Vorhersagetendenzen des Modells beeinflussen.
• Empfehlung: Beurteile regelmäßig die Verteilung der Klassen innerhalb deines Datensatzes. Wenn ein Klassenungleichgewicht vorliegt, besteht das Risiko, dass das Modell eine Tendenz zur häufigeren Klasse entwickelt. Diese Verzerrung kann in der Konfusionsmatrix deutlich werden, in der das Modell möglicherweise vorwiegend die Mehrheitsklasse vorhersagt.

Abgleich mit vortrainierten Gewichten

• Bedeutung: Die Nutzung von vortrainierten Gewichten kann einen soliden Ausgangspunkt für das Modelltraining bieten, insbesondere bei begrenzten Daten.
• Empfehlung: Erwäge als diagnostischen Schritt, dein Modell mit denselben Daten zu trainieren, es aber mit vortrainierten Gewichten zu initialisieren. Wenn dieser Ansatz eine wohlgeformte Konfusionsmatrix ergibt, könnte dies darauf hindeuten, dass das Modell, das 'von Grund auf' trainiert wurde, weitere Trainingsschritte oder Anpassungen benötigt.

Probleme im Zusammenhang mit Modellvorhersagen#

Häufige Probleme bei der Modellvorhersage und deren Lösungen werden unten behandelt.

Bounding-Box-Vorhersagen mit deinem benutzerdefinierten YOLO26-Modell erhalten#

Problem: Bei der Durchführung von Vorhersagen mit einem benutzerdefinierten YOLO26-Modell treten Herausforderungen mit dem Format und der Visualisierung der Bounding-Box-Koordinaten auf.

Lösung:

• Koordinatenformat: YOLO26 liefert Bounding-Box-Koordinaten in absoluten Pixelwerten. Um diese in relative Koordinaten (im Bereich von 0 bis 1) umzurechnen, musst du sie durch die Bildabmessungen teilen. Nehmen wir beispielsweise an, deine Bildgröße beträgt 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 triffst, greife direkt vom Ergebnisobjekt innerhalb deiner Vorhersageschleife auf den Bilddateipfad zu.

Filtern von Objekten in YOLO26-Vorhersagen#

Problem: Probleme beim Filtern und Anzeigen nur spezifischer Objekte in den Vorhersageergebnissen bei der Ausführung von YOLO26 mit der Ultralytics-Bibliothek.

Lösung: Um spezifische Klassen zu erkennen, verwende das 'classes'-Argument, um die Klassen anzugeben, die du in der Ausgabe enthalten haben möchtest. Um zum Beispiel nur Autos zu erkennen (unter der Annahme, dass 'Autos' den Klassenindex 2 haben):

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

Verständnis der Präzisionsmetriken in YOLO26#

Problem: Unklarheit hinsichtlich des Unterschieds zwischen Box-Präzision, Masken-Präzision und der Präzision der confusion matrix in YOLO26.

Lösung: Die Box-Präzision misst die Genauigkeit vorhergesagter Bounding-Boxen im Vergleich zu den tatsächlichen Ground-Truth-Boxen unter Verwendung von IoU (Intersection over Union) als Metrik. Die Masken-Präzision bewertet die Übereinstimmung zwischen vorhergesagten Segmentierungsmasken und Ground-Truth-Masken bei der pixelbasierten Objektklassifizierung. Die Präzision der Konfusionsmatrix hingegen konzentriert sich auf die allgemeine Klassifizierungsgenauigkeit über alle Klassen hinweg und berücksichtigt nicht die geometrische Genauigkeit der Vorhersagen. Es ist wichtig zu beachten, dass eine bounding box geometrisch genau sein kann (True Positive), selbst wenn die Klassenvorhersage falsch ist, was zu Unterschieden zwischen Box-Präzision und Konfusionsmatrix-Präzision führt. Diese Metriken bewerten unterschiedliche Aspekte der Modellleistung, was die Notwendigkeit unterschiedlicher Evaluierungsmetriken für verschiedene Aufgaben widerspiegelt.

Extrahieren von Objektabmessungen in YOLO26#

Problem: Schwierigkeiten beim Abrufen der Länge und Höhe der erkannten Objekte in YOLO26, besonders wenn mehrere Objekte in einem Bild erkannt werden.

Lösung: Um die Abmessungen der Bounding-Box abzurufen, verwende zuerst das Ultralytics YOLO26-Modell, um predict objects in einem Bild auszuführen. Extrahiere dann die Breiten- und Höheninformationen der Bounding-Boxen aus den Vorhersageergebnissen.

from ultralytics import YOLO

# Load a pretrained YOLO26 model
model = YOLO("yolo26n.pt")

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

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

# 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}")

Bereitstellungsherausforderungen#

Probleme bei der GPU-Bereitstellung#

Problem: Die Bereitstellung von Modellen in einer Multi-GPU-Umgebung kann manchmal zu unerwartetem Verhalten führen, wie etwa unerwartetem Speicherverbrauch, inkonsistenten Ergebnissen über verschiedene GPUs hinweg usw.

Lösung: Prüfe die standardmäßige GPU-Initialisierung. Einige Frameworks, wie PyTorch, könnten CUDA-Operationen auf einer Standard-GPU initialisieren, bevor sie zu den vorgesehenen GPUs wechseln. Um unerwartete Standardinitialisierungen zu umgehen, gib die GPU direkt während der Bereitstellung und Vorhersage an. Nutze dann Tools, um die GPU-Auslastung und den Speicherverbrauch zu überwachen und Anomalien in Echtzeit zu identifizieren. Stelle außerdem sicher, dass du die neueste Version des Frameworks oder der Bibliothek verwendest.

Probleme bei der Modellkonvertierung/-exportierung#

Problem: Während des Prozesses der Konvertierung oder des Exports von Machine-Learning-Modellen in verschiedene Formate oder Plattformen können Benutzer auf Fehler oder unerwartetes Verhalten stoßen.

Lösung: Überprüfe die unterstützten Formate und formatbezogenen Optionen in der Dokumentation zum Export mode und arbeite dann diese Prüfungen durch:

• Kompatibilitätsprüfung: Stelle sicher, dass du Versionen von Bibliotheken und Frameworks verwendest, die miteinander kompatibel sind. Nicht übereinstimmende Versionen können während der Konvertierung zu unerwarteten Fehlern führen.
• Umgebungs-Reset: Wenn du eine interaktive Umgebung wie Jupyter oder Colab verwendest, erwäge einen Neustart deiner Umgebung nach größeren Änderungen oder Installationen. Ein Neustart kann manchmal zugrunde liegende Probleme lösen.
• Offizielle Dokumentation: Schlage immer in der offiziellen Dokumentation des Tools oder der Bibliothek nach, die du für die Konvertierung verwendest. Sie enthält oft spezifische Richtlinien und Best Practices für den Modell-Export.
• Community-Support: Prüfe das offizielle Repository der Bibliothek oder des Frameworks auf ähnliche Probleme, die von anderen Benutzern gemeldet wurden. Die Betreuer oder die Community haben möglicherweise Lösungen oder Workarounds in Diskussionsthreads bereitgestellt.
• Regelmäßige Updates: Stelle sicher, dass du die neueste Version des Tools oder der Bibliothek verwendest. Entwickler veröffentlichen regelmäßig Updates, die bekannte Fehler beheben oder die Funktionalität verbessern.
• Schrittweise testen: Bevor du eine vollständige Konvertierung durchführst, teste den Prozess mit einem kleineren Modell oder Datensatz, um potenzielle Probleme frühzeitig zu identifizieren.

Community und Support#

Erhalte Hilfe und teile Lösungen über diese Kanäle und Ressourcen.

Foren und Kanäle, um Hilfe zu erhalten#

GitHub-Issues: Das YOLO26-Repository auf GitHub verfügt über einen Issues-Tab, in dem du Fragen stellen, Fehler melden und neue Funktionen vorschlagen kannst. Die Community und die Maintainer sind hier aktiv, und es ist ein großartiger Ort, um Hilfe bei spezifischen Problemen zu erhalten.

Ultralytics-Discord-Server: Ultralytics verfügt über einen Discord-Server, auf dem du dich mit anderen Benutzern und den Entwicklern austauschen kannst.

Offizielle Dokumentation und Ressourcen#

Ultralytics YOLO26 Docs: Die official documentation bietet einen umfassenden Überblick über YOLO26 sowie Anleitungen zu Installation, Verwendung und Fehlerbehebung.

Fazit#

Die meisten YOLO26-Probleme gehen auf einige wenige Ursachen zurück: Versionskonflikte, Dataset-Formatierung und GPU-Konfiguration. Wenn ein Fehler hier nicht behandelt wird, suche im Tab GitHub Issues oder frage auf dem Discord server nach – die Chancen stehen gut, dass ihn bereits jemand gelöst hat. Für tiefergehende training-Probleme findest du im Leitfaden Model Training Tips praktische Ratschläge, um bessere Ergebnisse bei deinen computer vision-Projekten zu erzielen.

FAQ#