Häufige YOLO-Probleme beheben#

Dieser Leitfaden behandelt die häufigsten Probleme bei der Arbeit mit Ultralytics YOLO26, gruppiert danach, wo sie auftreten: Installation, Modelltraining, Vorhersage und Bereitstellung. Springe zur Kategorie, die zu deinem Fehler passt, oder durchsuche die FAQ nach schnellen Antworten. 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, etwa inkompatible Versionen, fehlende Abhängigkeiten oder falsch eingerichtete Umgebungen. Überprü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.
• Ziehe die Verwendung virtueller Umgebungen in Betracht, um Konflikte zu vermeiden.
• Befolge die offizielle Installationsanleitung Schritt für Schritt.

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

Importfehler oder Probleme mit Abhängigkeiten#

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

• 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: Überprüfe, ob alle erforderlichen Abhängigkeiten korrekt installiert sind und kompatible Versionen verwenden.
• Änderungen prüfen: Wenn du eine ältere Version installiert hast, informiere dich in der offiziellen Dokumentation oder im Änderungsprotokoll über wesentliche strukturelle Änderungen.

YOLO26 auf einer GPU ausführen#

Wenn du Schwierigkeiten hast, YOLO26 auf einer GPU auszuführen, berücksichtige die folgenden Schritte zur Fehlersuche:

• 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 prüfen.
• Integration von PyTorch und CUDA prüfen: Stelle sicher, 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 aktuell.
• Program####konfiguration: Überprüfe, ob dein Code die GPU-Nutzung anfordert. Du kannst beim Training oder bei der Vorhersage 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 unsicher, ob die Konfigurationseinstellungen in der Datei .yaml beim Modelltraining korrekt angewendet werden.

Lösung: Die Konfigurationseinstellungen in der Datei .yaml sollten bei Verwendung der Funktion model.train() angewendet werden. Befolge diese Schritte, um sicherzustellen, dass die Einstellungen korrekt übernommen werden:

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

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

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

Training mit mehreren GPUs beschleunigen#

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

Lösung: Eine Erhöhung der Batchgröße kann das Training beschleunigen, allerdings musst du die Speicherkapazität der GPU berücksichtigen. Befolge diese Schritte, um das Training mit mehreren GPUs zu beschleunigen:

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

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

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

• Passe deinen Trainingsbefehl an, um mehrere GPUs zu verwenden:

  # 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])

Parameter zur kontinuierlichen Überwachung#

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

Lösung: Der Verlust ist zwar eine wichtige zu überwachende Metrik, aber für die Optimierung der Modellleistung müssen auch andere Metriken verfolgt werden. Zu den wichtigen Metriken während des Trainings gehören:

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

Du kannst auf diese Metriken über die Trainingsprotokolle oder durch die Nutzung von Tools wie TensorBoard oder Weights & Biases zur Visualisierung zugreifen. Die Implementierung eines Early Stopping basierend auf diesen Metriken kann dir helfen, bessere Ergebnisse zu erzielen.

Tools zur Verfolgung des Trainingsfortschritts#

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

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

• TensorBoard: TensorBoard ist eine beliebte Lösung zur Visualisierung von Trainingsmetriken wie Verlust, Genauigkeit und weiteren Werten. Du kannst es in deinen YOLO26-Trainingsprozess integrieren.
• Comet: Comet bietet ein umfangreiches Werkzeug zur Verfolgung und zum Vergleich von Experimenten. Damit kannst du Metriken, Hyperparameter und sogar Modellgewichte verfolgen. Die Integration in YOLO-Modelle ist ebenfalls unkompliziert und verschafft dir einen vollständigen Überblick über deinen Experimentzyklus.
• Ultralytics Platform: Ultralytics Platform bietet eine spezialisierte Umgebung zur Verfolgung von YOLO-Modellen und eine zentrale Plattform zur Verwaltung von Metriken und Datensätzen sowie zur Zusammenarbeit mit deinem Team. Durch die gezielte Ausrichtung auf YOLO stehen dir stärker angepasste Optionen zur Verfolgung zur Verfügung.

So überprüfst du, ob das Training auf der GPU stattfindet#

Problem: Der Wert „device“ in den Trainingsprotokollen ist „null“, und du bist unsicher, ob das Training auf der GPU stattfindet.

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

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 Ordner „runs“ im Auge, um Protokolle und Metriken zu prüfen und den Trainingsfortschritt effektiv zu überwachen.

Wichtige Überlegungen für ein effektives Modelltraining#

Wenn du Probleme im Zusammenhang mit dem Modelltraining hast, solltest du Folgendes beachten.

Datensatzformat und Beschriftungen

• Bedeutung: Die Grundlage jedes maschinellen Lernmodells 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 Beschriftungen dem erwarteten Format entsprechen. Überprüfe unbedingt, ob die Annotationen korrekt und von hoher Qualität sind. Falsche oder unzureichende Annotationen können den Lernprozess des Modells beeinträchtigen und zu unvorhersehbaren Ergebnissen führen.

Konvergenz des Modells

• Bedeutung: Das Erreichen der Modellkonvergenz stellt sicher, dass das Modell ausreichend aus den Trainingsdaten gelernt hat.
• Empfehlung: Wenn du ein Modell „from scratch“ trainierst, musst du sicherstellen, dass es ein zufriedenstellendes Maß an Konvergenz erreicht. Im Vergleich zur Feinabstimmung eines vorhandenen Modells kann dies eine längere Trainingsdauer mit mehr Epochen erfordern.

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 Eigenschaften des Datensatzes passen, können die Leistung des Modells beeinträchtigen.

Klassenverteilung

• Bedeutung: Die Verteilung der Klassen in deinem Datensatz kann die Vorhersagetendenzen des Modells beeinflussen.
• Empfehlung: Bewerte regelmäßig die Klassenverteilung in deinem Datensatz. Bei einem Klassenungleichgewicht besteht das Risiko, dass das Modell eine Verzerrung zugunsten der häufigeren Klasse entwickelt. Diese Verzerrung kann in der Konfusionsmatrix sichtbar werden, wenn das Modell überwiegend die Mehrheitsklasse vorhersagt.

Abgleich mit vortrainierten Gewichten

• Bedeutung: Die Verwendung vortrainierter Gewichte kann einen soliden Ausgangspunkt für das Modelltraining bieten, insbesondere bei begrenzten Datenmengen.
• Empfehlung: Trainiere dein Modell zu Diagnosezwecken mit denselben Daten, initialisiere es aber mit vortrainierten Gewichten. Wenn dieser Ansatz eine gut ausgeprägte Konfusionsmatrix ergibt, könnte dies darauf hindeuten, dass das „from scratch“-Modell weiteres Training oder Anpassungen benötigt.

Probleme im Zusammenhang mit Modellvorhersagen#

Im Folgenden findest du häufige Probleme bei Modellvorhersagen und ihre Lösungen.

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 Koordinaten der Bounding Boxes.

Lösung:

• Koordinatenformat: YOLO26 liefert die Koordinaten der Bounding Boxes als absolute Pixelwerte. Um sie in relative Koordinaten (im Bereich von 0 bis 1) umzuwandeln, musst du durch die Bildabmessungen teilen. Angenommen, dein Bild ist 640 × 640 Pixel groß. Dann gehst du folgendermaßen vor:

  # 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 abzurufen, für das du eine Vorhersage erstellst, greife in deiner Vorhersageschleife direkt über das Ergebnisobjekt auf den Bilddateipfad zu.

Objekte in YOLO26-Vorhersagen filtern#

Problem: Du hast Schwierigkeiten, bei der Ausführung von YOLO26 mit der Ultralytics-Bibliothek nur bestimmte Objekte in den Vorhersageergebnissen zu filtern und anzuzeigen.

Lösung: Verwende zum Erkennen bestimmter Klassen das Argument classes, um die Klassen anzugeben, die in die Ausgabe aufgenommen werden sollen. Um beispielsweise nur Autos zu erkennen (unter der Annahme, dass „cars“ den Klassenindex 2 hat):

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 von Boxen, der Präzision von Masken und der Präzision der Konfusionsmatrix in YOLO26.

Lösung: Die Präzision von Boxen misst die Genauigkeit vorhergesagter Bounding Boxes im Vergleich zu den tatsächlichen Ground-Truth-Boxen, wobei IoU (Intersection over Union) als Metrik verwendet wird. Die Maskenpräzision bewertet die Übereinstimmung zwischen vorhergesagten Segmentierungsmasken und Ground-Truth-Masken bei der pixelweisen Objektklassifizierung. Die Präzision der Konfusionsmatrix konzentriert sich dagegen 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 korrekt sein kann (richtig-positiv), selbst wenn die Klassenvorhersage falsch ist. Dadurch können sich die Präzision von Boxen und die Präzision der Konfusionsmatrix unterscheiden. Diese Metriken bewerten unterschiedliche Aspekte der Modellleistung und zeigen, dass für verschiedene Aufgaben unterschiedliche Bewertungsmetriken erforderlich sind.

Objektabmessungen in YOLO26 extrahieren#

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

Lösung: Um die Abmessungen der Bounding Boxes abzurufen, verwende zunächst das Ultralytics-YOLO26-Modell, um Objekte in einem Bild vorherzusagen. Extrahiere anschließend die Breiten- und Höhenangaben der Bounding Boxes 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 unerwarteter Speichernutzung oder inkonsistenten Ergebnissen auf den GPUs.

Lösung: Prüfe die standardmäßige GPU-Initialisierung. 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 die GPU bei der Bereitstellung und der Vorhersage direkt an. Verwende anschließend Tools, um die GPU-Auslastung und Speichernutzung zu überwachen und 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 maschinellen Lernmodellen in andere Formate oder auf andere Plattformen können Fehler oder unerwartetes Verhalten auftreten.

Lösung: Prüfe die unterstützten Formate und die Optionen für die einzelnen Formate in der Dokumentation zum Exportmodus und arbeite anschließend diese Prüfungen durch:

• Kompatibilitätsprüfung: Stelle sicher, dass du miteinander kompatible Versionen der Bibliotheken und Frameworks verwendest. Nicht übereinstimmende Versionen können während der Konvertierung zu unerwarteten Fehlern führen.
• Umgebung zurücksetzen: Wenn du eine interaktive Umgebung wie Jupyter oder Colab verwendest, solltest du die Umgebung nach wesentlichen Änderungen oder Installationen neu starten. Ein Neustart kann zugrunde liegende Probleme manchmal beheben.
• Offizielle Dokumentation: Lies immer die offizielle Dokumentation des Tools oder der Bibliothek, die du für die Konvertierung verwendest. Sie enthält häufig spezifische Richtlinien und bewährte Verfahren für den Modellexport.
• Unterstützung durch die Community: Suche im offiziellen Repository der Bibliothek oder des Frameworks nach ähnlichen Problemen, die von anderen Nutzern gemeldet wurden. Die Maintainer oder die Community haben möglicherweise Lösungen oder Umgehungen in Diskussionsthreads bereitgestellt.
• Regelmäßig aktualisieren: Stelle sicher, dass du die neueste Version des Tools oder der Bibliothek verwendest. Entwickler veröffentlichen häufig Updates, die bekannte Fehler beheben oder die Funktionalität verbessern.
• Schrittweise testen: Teste den Prozess vor einer vollständigen Konvertierung mit einem kleineren Modell oder Datensatz, um mögliche Probleme frühzeitig zu erkennen.

Community und Support#

Hole dir über diese Kanäle und Ressourcen Hilfe und teile deine Lösungen.

Foren und Kanäle für Hilfe#

GitHub-Issues: Das Ultralytics-Repository auf GitHub hat einen Issues-Tab, über den du Fragen stellen, Bugs melden und neue Funktionen vorschlagen kannst. Die Community und die Maintainer sind hier aktiv, und der Issues-Tab ist ein hervorragender Ort, um Hilfe bei spezifischen Problemen zu erhalten.

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

Offizielle Dokumentation und Ressourcen#

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

Fazit#

Die meisten Probleme mit YOLO26 lassen sich auf einige wenige Ursachen zurückführen: inkompatible Versionen, eine falsche Datensatzformatierung und die GPU-Konfiguration. Wenn ein Fehler hier nicht behandelt wird, suche im Tab GitHub Issues oder frage auf dem Discord-Server – wahrscheinlich hat bereits jemand eine Lösung gefunden. Bei umfangreicheren Problemen mit dem Training findest du im Leitfaden Tipps zum Modelltraining praktische Hinweise, wie du mit deinen Computer-Vision-Projekten bessere Ergebnisse erzielst.

FAQ#