Häufige YOLO-Probleme beheben#

Dieser Leitfaden behandelt die häufigsten Probleme, auf die du bei der Arbeit mit Ultralytics YOLO26 stößt. Sie sind nach ihrem Auftreten geordnet: Installation, Modelltraining, Vorhersage und Bereitstellung. Springe zur passenden Kategorie oder lies die FAQ, um schnelle Antworten zu finden. Jeder Eintrag beschreibt das Problem und eine konkrete Lösung, die du direkt anwenden kannst.

Häufige Probleme#

Installationsfehler#

Installationsfehler können verschiedene Ursachen haben, zum Beispiel inkompatible Versionen, fehlende Abhängigkeiten oder eine fehlerhafte Einrichtung der Umgebung. Prüfe zunächst, ob du Folgendes beachtest:

• Du verwendest wie empfohlen Python 3.8 oder höher.
• Stelle sicher, dass die richtige Version von PyTorch (1.8 oder höher) installiert ist.
• Verwende virtuelle Umgebungen, um Konflikte zu vermeiden.
• Befolge Schritt für Schritt die offizielle Installationsanleitung.

Hier findest du außerdem Lösungen für häufige Installationsprobleme.

Importfehler oder Probleme mit Abhängigkeiten#

Wenn beim Importieren von YOLO26 Fehler auftreten oder du auf Konflikte mit Abhängigkeiten stößt, probiere Folgendes:

• Neuinstallation: Eine saubere Installation kann unerwartete Probleme beheben, insbesondere nach Aktualisierungen, die die Paketstruktur oder Funktionalität ändern.
• Regelmäßig aktualisieren: Verwende die neueste Version der Bibliothek, da ältere Versionen möglicherweise nicht mit aktuellen Aktualisierungen kompatibel sind.
• Abhängigkeiten prüfen: Vergewissere dich, dass alle erforderlichen Abhängigkeiten korrekt installiert sind und kompatible Versionen haben.
• Änderungen überprüfen: Wenn du eine ältere Version installiert hast, lies in der offiziellen Dokumentation oder im Änderungsprotokoll nach, um größere strukturelle Änderungen nachzuvollziehen.

YOLO26 auf der GPU ausführen#

Wenn du Probleme hast, YOLO26 auf einer GPU auszuführen, gehe bei der Fehlersuche folgendermaßen vor:

• CUDA-Kompatibilität und Installation überprüfen: Stelle sicher, dass deine GPU CUDA unterstützt 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 prüfen: Vergewissere dich, dass PyTorch CUDA verwenden kann, indem du import torch; print(torch.cuda.is_available()) in einem Python-Terminal ausführst. Gibt der Befehl „True“ zurück, ist PyTorch für die Verwendung von CUDA eingerichtet.
• Umgebung aktivieren: Stelle sicher, dass du dich in der richtigen Umgebung befindest, in der alle erforderlichen 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 der GPU anfordert. Beim Training oder bei Vorhersagen kannst du das Argument device setzen (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#

Im Folgenden findest du häufige Trainingsprobleme und ihre Lösungen.

Konfigurationseinstellungen überprüfen#

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

Lösung: Dataset-Einstellungen und Trainingseinstellungen befinden sich in verschiedenen .yaml-Dateien und werden über unterschiedliche Argumente von model.train() übergeben. Gehe folgendermaßen vor, um sicherzustellen, dass diese Einstellungen korrekt angewendet werden:

• Prüfe, ob die Pfade zu deinen .yaml-Dateien korrekt sind.

• Übergib dein Dataset-.yaml (Pfade, Klassennamen, Aufteilungen) als Argument data und eine benutzerdefinierte .yaml für die Trainingseinstellungen (zum Beispiel epochs oder lr0) als Argument cfg. Direkt an model.train() übergebene Argumente haben Vorrang vor beiden:

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

Training mit mehreren GPUs beschleunigen#

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

Lösung: Eine größere Batchgröße kann das Training beschleunigen, aber du musst dabei den verfügbaren GPU-Speicher berücksichtigen. Gehe folgendermaßen vor, um das Training mit mehreren GPUs zu beschleunigen:

• Stelle sicher, dass mehrere GPUs verfügbar sind.

• Setze das Argument device auf eine Liste der GPU-Indizes, zum Beispiel device=[0,1,2,3].

• Erhöhe die Batchgröße entsprechend, um die mehreren GPUs vollständig auszulasten, ohne die Speichergrenzen zu überschreiten.

• Passe deinen Trainingsbefehl an, damit mehrere GPUs verwendet werden:

  # Passe die Batchgröße und andere Einstellungen nach Bedarf an, um die Trainingsgeschwindigkeit zu optimieren
  model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Parameter kontinuierlich überwachen#

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

Lösung: Der Loss ist zwar eine wichtige Kennzahl, doch für die Optimierung der Modellleistung solltest du auch weitere Kennzahlen erfassen. Zu den wichtigsten Kennzahlen, die während des Trainings überwacht werden sollten, gehören:

• Precision
• Recall
• Mittlere durchschnittliche Präzision (mAP)

Du kannst diese Kennzahlen den Trainingsprotokollen entnehmen oder sie mit Tools wie TensorBoard oder Weights & Biases visualisieren. Wenn du das Training anhand dieser Kennzahlen vorzeitig beendest, kannst du bessere Ergebnisse erzielen.

Tools zur Verfolgung des Trainingsfortschritts#

Problem: Du suchst nach Empfehlungen für Tools zur Verfolgung des Trainingsfortschritts.

Lösung: Zur Verfolgung und Visualisierung des Trainingsfortschritts kannst du die folgenden Tools verwenden:

• TensorBoard: TensorBoard ist ein beliebtes Tool zur Visualisierung von Trainingskennzahlen, darunter Loss, Genauigkeit und mehr. Du kannst es in deinen YOLO26-Trainingsprozess integrieren.
• Comet: Comet bietet ein umfangreiches Toolkit zur Erfassung und zum Vergleich von Experimenten. Damit kannst du Kennzahlen, Hyperparameter und sogar Modellgewichte verfolgen. Die Integration mit YOLO-Modellen ist ebenfalls unkompliziert und bietet dir einen vollständigen Überblick über den gesamten Experimentierzyklus.
• Ultralytics Platform: Die Ultralytics Platform bietet eine spezialisierte Umgebung zur Verfolgung von YOLO-Modellen. Sie stellt eine zentrale Plattform bereit, auf der du Kennzahlen und Datensätze verwalten und mit deinem Team zusammenarbeiten kannst. Da sie speziell auf YOLO ausgerichtet ist, bietet sie stärker angepasste Möglichkeiten zur Fortschrittsverfolgung.

So prüfst du, ob das Training auf der GPU ausgeführt wird#

Problem: Der Wert „device“ in den Trainingsprotokollen lautet „null“, und du bist dir nicht sicher, ob das Training auf der GPU ausgeführt wird.

Lösung: Der Wert „device“ „null“ bedeutet normalerweise, dass der Trainingsprozess automatisch eine verfügbare GPU auswählt. Das ist das Standardverhalten. Um auf einer bestimmten GPU zu trainieren, setze beim Start des Trainings das Argument device. device ist ein Trainingsargument. Wenn du es in deinem Dataset-.yaml festlegst, hat das daher keine Wirkung:

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.pt")

# # GPU 0 verwenden; device=[0, 1] für mehrere GPUs, device="cpu" für CPU
model.train(data="path/to/data.yaml", device=0)

Behalte den Ordner „runs“ im Blick. Dort findest du Protokolle und Kennzahlen, mit denen du den Trainingsfortschritt effektiv überwachen kannst.

Wichtige Aspekte für effektives Modelltraining#

Wenn du Probleme beim Modelltraining hast, solltest du Folgendes beachten.

Datensatzformat und Labels

• Bedeutung: Die Grundlage jedes Modells für maschinelles Lernen sind Qualität und Format der Trainingsdaten.
• Empfehlung: Stelle sicher, dass dein benutzerdefinierter Datensatz und die zugehörigen Labels dem erwarteten Format entsprechen. Prüfe unbedingt, ob die Annotationen korrekt und von hoher Qualität sind. Falsche oder mangelhafte Annotationen können den Lernprozess des Modells beeinträchtigen und zu unvorhersehbaren Ergebnissen führen.

Konvergenz des Modells

• Bedeutung: Die Konvergenz des Modells stellt sicher, dass es ausreichend aus den Trainingsdaten gelernt hat.
• Empfehlung: Beim Training eines Modells „von Grund auf“ musst du sicherstellen, dass es ausreichend konvergiert. Im Vergleich zur Feinabstimmung eines vorhandenen Modells kann dafür eine längere Trainingsdauer mit mehr Epochen erforderlich sein.

Lernrate und Batchgröße

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

Klassenverteilung

• Bedeutung: Die Klassenverteilung in deinem Datensatz kann die Vorhersagen des Modells beeinflussen.
• Empfehlung: Überprüfe regelmäßig die Klassenverteilung in deinem Datensatz. Bei einem Klassenungleichgewicht besteht das Risiko, dass das Modell eine Verzerrung zugunsten der häufigsten Klasse entwickelt. Diese Verzerrung kann sich in der Konfusionsmatrix zeigen, wenn das Modell überwiegend die Mehrheitsklasse vorhersagt.

Abgleich mit vortrainierten Gewichten

• Bedeutung: Die Nutzung vortrainierter Gewichte kann einen soliden Ausgangspunkt für das Modelltraining bieten, insbesondere bei begrenzten Daten.
• Empfehlung: Ziehe als Diagnoseschritt in Betracht, dein Modell mit denselben Daten zu trainieren, es jedoch mit vortrainierten Gewichten zu initialisieren. Ergibt dieser Ansatz eine aussagekräftige Konfusionsmatrix, könnte das darauf hindeuten, dass das „from scratch“ trainierte Modell weiter trainiert oder angepasst werden muss.

Probleme mit Modellvorhersagen#

Im Folgenden werden häufige Probleme bei Modellvorhersagen und ihre Lösungen behandelt.

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

Problem: Bei Vorhersagen mit einem benutzerdefinierten YOLO26-Modell gibt es Schwierigkeiten mit dem Format und der Visualisierung der Bounding-Box-Koordinaten.

Lösung:

• Koordinatenformat: YOLO26 gibt Bounding-Box-Koordinaten als absolute Pixelwerte aus. Um sie in relative Koordinaten (im Bereich von 0 bis 1) umzuwandeln, musst du sie durch die Bildabmessungen teilen. Angenommen, dein Bild ist 640x640 Pixel groß. Dann gehst du wie folgt vor:

  # Absolute Koordinaten in relative Koordinaten umwandeln
  x1 = x1 / 640  # x-Koordinaten durch die Bildbreite teilen
  x2 = x2 / 640
  y1 = y1 / 640  # y-Koordinaten durch die Bildhöhe teilen
  y2 = y2 / 640

• Dateiname: Um den Dateinamen des Bildes abzurufen, für das du Vorhersagen erstellst, lies den Bilddateipfad innerhalb deiner Vorhersageschleife aus dem Attribut path jedes Ergebnisobjekts aus (zum Beispiel result.path).

Objekte in YOLO26-Vorhersagen filtern#

Problem: Bei der Verwendung der Ultralytics-Bibliothek mit YOLO26 gibt es Schwierigkeiten damit, in den Vorhersageergebnissen nur bestimmte Objekte zu filtern und anzuzeigen.

Lösung: Um bestimmte Klassen zu erkennen, verwende das Argument classes, um die Klassen anzugeben, die in der Ausgabe enthalten sein sollen. Um beispielsweise nur Autos zu erkennen (angenommen, „Autos“ haben den Klassenindex 2):

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

Präzisionsmetriken in YOLO26 verstehen#

Problem: Unklarheit über den Unterschied zwischen der Präzision der Boxen, der Präzision der Masken und der Präzision der Konfusionsmatrix in YOLO26.

Lösung: Die Box-Präzision misst anhand von IoU (Intersection over Union), wie genau vorhergesagte Bounding-Boxen im Vergleich zu den tatsächlichen Ground-Truth-Boxen sind. Die Maskenpräzision bewertet die Übereinstimmung zwischen vorhergesagten Segmentierungsmasken und Ground-Truth-Masken bei der pixelweisen Objektklassifizierung. Die Präzision der Konfusionsmatrix hingegen bezieht sich auf die Gesamtgenauigkeit der Klassifizierung über alle Klassen hinweg und berücksichtigt nicht die geometrische Genauigkeit der Vorhersagen. Wichtig ist, dass eine Bounding-Box geometrisch genau sein kann (richtig positiv), selbst wenn die vorhergesagte Klasse falsch ist. Dadurch kann es zu Unterschieden zwischen der Box-Präzision und der Präzision der Konfusionsmatrix kommen. Diese Metriken bewerten unterschiedliche Aspekte der Modellleistung und verdeutlichen, warum je nach Aufgabe verschiedene Bewertungsmetriken erforderlich sind.

Objektabmessungen in YOLO26 extrahieren#

Problem: Es ist schwierig, Länge und Höhe erkannter Objekte in YOLO26 abzurufen, insbesondere wenn in einem Bild mehrere Objekte erkannt werden.

Lösung: Um die Abmessungen der Bounding-Box abzurufen, verwende zunächst das Ultralytics-YOLO26-Modell, um Objekte in einem Bild vorherzusagen. Extrahiere anschließend die Breiten- und Höhenangaben 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}")

Herausforderungen bei der Bereitstellung#

Probleme bei der GPU-Bereitstellung#

Problem: Die Bereitstellung von Modellen in einer Umgebung mit mehreren GPUs kann manchmal zu unerwartetem Verhalten führen, etwa zu unerwartetem Speicherverbrauch oder unterschiedlichen Ergebnissen auf den GPUs.

Lösung: Prüfe, ob eine GPU standardmäßig initialisiert wird. Einige Frameworks wie PyTorch initialisieren CUDA-Operationen möglicherweise auf einer Standard-GPU, bevor sie zu den vorgesehenen GPUs wechseln. Um unerwartete Standardinitialisierungen zu umgehen, gib bei der Bereitstellung und Vorhersage die GPU direkt an. Überwache anschließend mit geeigneten Tools die GPU-Auslastung und den Speicherverbrauch, 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 und beim Export#

Problem: Bei der Konvertierung oder dem Export von Machine-Learning-Modellen in andere Formate oder auf andere Plattformen können Fehler oder unerwartetes Verhalten auftreten.

Lösung: Sieh dir in der Dokumentation zum Exportmodus die unterstützten Formate und die jeweiligen Optionen an und arbeite dann die folgenden Prüfungen durch:

• Kompatibilitätsprüfung: Stelle sicher, dass du zueinander kompatible Versionen von Bibliotheken und Frameworks verwendest. Nicht übereinstimmende Versionen können bei der Konvertierung zu unerwarteten Fehlern führen.
• Umgebung zurücksetzen: Wenn du eine interaktive Umgebung wie Jupyter oder Colab verwendest, solltest du sie nach größeren Änderungen oder Installationen neu starten. Ein Neustart kann manchmal zugrunde liegende Probleme beheben.
• Offizielle Dokumentation: Richte dich immer nach der offiziellen Dokumentation des Konvertierungstools oder der verwendeten Bibliothek. Sie enthält häufig spezifische Richtlinien und bewährte Vorgehensweisen für den Modellexport.
• Unterstützung durch die Community: Sieh im offiziellen Repository der Bibliothek oder des Frameworks nach, ob andere Nutzer ähnliche Probleme gemeldet haben. Die Maintainer oder die Community haben möglicherweise Lösungen oder Umgehungen in Diskussionen vorgeschlagen.
• Regelmäßig aktualisieren: 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: Teste den Vorgang vor einer vollständigen Konvertierung mit einem kleineren Modell oder Datensatz, um mögliche Probleme frühzeitig zu erkennen.

Community und Unterstützung#

Über die folgenden Kanäle und Ressourcen erhältst du Hilfe und kannst Lösungen teilen.

Foren und Kanäle für Unterstützung#

GitHub-Issues: Das Ultralytics-Repository auf GitHub enthält einen Issues-Bereich, in dem du Fragen stellen, Fehler melden und neue Funktionen vorschlagen kannst. Die Community und die Maintainer sind dort aktiv. Der Bereich eignet sich hervorragend, um Hilfe bei konkreten Problemen zu erhalten.

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

Offizielle Dokumentation und Ressourcen#

Ultralytics-YOLO26-Dokumentation: Die offizielle Dokumentation bietet einen umfassenden Überblick über YOLO26 sowie Anleitungen zur Installation und Verwendung und zur Fehlerbehebung.

Fazit#

Die meisten Probleme mit YOLO26 gehen auf einige wenige Ursachen zurück: inkompatible Versionen, falsche Formatierung des Datensatzes und GPU-Konfiguration. Wenn ein Fehler hier nicht behandelt wird, suche im Tab GitHub Issues oder frage auf dem Discord-Server nach – wahrscheinlich hat schon jemand eine Lösung gefunden. Bei komplexeren Problemen mit dem Training findest du im Leitfaden Tipps zum Modelltraining praktische Hinweise, um mit deinen Computer-Vision-Projekten bessere Ergebnisse zu erzielen.

Häufig gestellte Fragen#