Link to this sectionFehlerbehebung bei häufigen YOLO-Problemen#

Dieser Leitfaden behandelt die häufigsten Probleme, auf die du bei der Arbeit mit Ultralytics YOLO26 stoßen wirst, gruppiert nach ihrem Auftreten: Installation, Modelltraining, Vorhersage und Bereitstellung. Springe zu der Kategorie, die auf deinen Fehler zutrifft, oder durchsuche das FAQ nach schnellen Antworten. Jeder Eintrag nennt das Problem und eine konkrete Lösung, die du direkt anwenden kannst.

Link to this sectionHäufige Probleme#

Link to this sectionInstallationsfehler#

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 die korrekte Version von PyTorch (1.8 oder höher) installiert ist.
• Erwäge die Verwendung von virtuellen Umgebungen, um Konflikte zu vermeiden.
• Befolge die offizielle Installationsanleitung Schritt für Schritt.

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

Link to this sectionImportfehler 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.

Link to this sectionYOLO26 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 dass CUDA korrekt installiert wurde. Nutze den Befehl nvidia-smi, um den Status deiner NVIDIA-GPU und die CUDA-Version zu prüfen.
• PyTorch- und CUDA-Integration prü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 konfiguriert.
• 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 GPU-Nutzung anfordert. Du kannst das device-Argument beim Training oder bei 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}")

Link to this sectionProbleme beim Modelltraining#

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

Link to this sectionÜberprüfung der Konfigurationseinstellungen#

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

Lösung: Die Konfigurationseinstellungen in der .yaml-Datei sollten angewendet werden, wenn du die model.train()-Funktion nutzt. Um sicherzustellen, dass diese Einstellungen korrekt übernommen werden, befolge diese Schritte:

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

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

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

Link to this sectionBeschleunigung 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: Eine Erhöhung der batch size kann das Training beschleunigen, aber es ist wichtig, die Kapazität des GPU-Speichers zu berücksichtigen. Um das Training mit mehreren GPUs zu beschleunigen, folge diesen Schritten:

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

• Setze das device-Argument 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])

Link to this sectionKontinuierliche Ü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.

Link to this sectionTools 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 für die Visualisierung von Trainingsmetriken, einschließlich Loss, accuracy und mehr. Du kannst es in deinen YOLO26-Trainingsprozess integrieren.
• Comet: Comet bietet ein umfassendes Toolkit zur Verfolgung und zum Vergleich von Experimenten. Es ermöglicht dir, Metriken, Hyperparameter und sogar Modellgewichte zu erfassen. Die Integration mit YOLO-Modellen ist ebenfalls unkompliziert und bietet dir einen vollständigen Überblick über deinen Experimentierzyklus.
• Ultralytics Platform: Die Ultralytics Platform bietet eine spezialisierte Umgebung für die Nachverfolgung von YOLO-Modellen und gibt dir eine zentrale Plattform zur Verwaltung von Metriken, Datensätzen und sogar zur Zusammenarbeit mit deinem Team. Da sie speziell auf YOLO zugeschnitten ist, bietet sie maßgeschneiderte Optionen zur Nachverfolgung.

Link to this sectionWie 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: Wenn der Wert für 'device' 'null' ist, bedeutet dies normalerweise, 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, lege das device-Argument fest, wenn du das Training startest. device ist ein Trainingsargument, daher hat das Festlegen in deiner Datensatz-.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.

Link to this sectionWichtige Ü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 Trainieren eines Modells 'von Grund auf' ist es wichtig sicherzustellen, dass das Modell einen zufriedenstellenden Konvergenzgrad erreicht. Dies kann eine längere Trainingsdauer mit mehr epochs erfordern, im Vergleich dazu, wenn du ein bestehendes Modell feinabstimmst.

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.

Link to this sectionProbleme im Zusammenhang mit Modellvorhersagen#

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

Link to this sectionBounding-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.

Link to this sectionFiltern 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

Link to this sectionVerständnis der Präzisionsmetriken in YOLO26#

Problem: Verwirrung bezüglich 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 der vorhergesagten Bounding Boxes im Vergleich zu den tatsächlichen Ground-Truth-Boxen unter Verwendung von IoU (Intersection over Union) als Metrik. Die Masken-Präzision beurteilt die Übereinstimmung zwischen vorhergesagten Segmentierungsmasken und Ground-Truth-Masken bei der pixelweisen 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 korrekt sein kann (True Positive), auch wenn die Klassenvorhersage falsch ist, was zu Unterschieden zwischen Box-Präzision und der Präzision der Konfusionsmatrix führt. Diese Metriken bewerten unterschiedliche Aspekte der Modellleistung und spiegeln die Notwendigkeit wider, verschiedene Bewertungsmetriken für unterschiedliche Aufgaben einzusetzen.

Link to this sectionExtrahieren 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 Begrenzungsrahmen abzurufen, verwende zuerst das Ultralytics YOLO26-Modell, um Objekte in einem Bild vorherzusagen. Extrahiere anschließend die Breiten- und Höheninformationen der Begrenzungsrahmen 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}")

Link to this sectionBereitstellungsherausforderungen#

Link to this sectionProbleme 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.

Link to this sectionProbleme 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 die formatabhängigen Optionen in der Dokumentation zum Export-Modus und gehe anschließend diese Prüfpunkte 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.

Link to this sectionCommunity und Support#

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

Link to this sectionForen und Kanäle, um Hilfe zu erhalten#

GitHub Issues: Das YOLO26-Repository auf GitHub verfügt über einen Issues-Tab, auf 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 bekommen.

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

Link to this sectionOffizielle Dokumentation und Ressourcen#

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

Link to this sectionFazit#

Die meisten Probleme mit YOLO26 lassen sich auf eine Handvoll Ursachen zurückführen: Versionsunterschiede, Datensatzformatierung und GPU-Konfiguration. Wenn ein Fehler hier nicht behandelt wird, durchsuche den GitHub Issues-Tab oder frage auf dem Discord-Server – die Wahrscheinlichkeit ist hoch, dass dies bereits jemand gelöst hat. Für tiefergehende Probleme beim Training, siehe den Leitfaden zu Tipps für das Modelltraining für praktische Ratschläge, um bessere Ergebnisse mit deinen Computer-Vision-Projekten zu erzielen.

Link to this sectionFAQ#

Link to this sectionWie behebe ich Installationsfehler bei YOLO26?#

Installationsfehler können oft auf Kompatibilitätsprobleme oder fehlende Abhängigkeiten zurückzuführen sein. Stelle sicher, dass du Python 3.8 oder neuer verwendest und PyTorch 1.8 oder neuer installiert hast. Es ist vorteilhaft, virtuelle Umgebungen zu nutzen, um Konflikte zu vermeiden. Für eine schrittweise Installationsanleitung befolge unseren offiziellen Installationsleitfaden. Wenn du auf Importfehler stößt, versuche eine Neuinstallation oder aktualisiere die Bibliothek auf die neueste Version.

Link to this sectionWarum ist mein YOLO26-Modelltraining auf einer einzelnen GPU langsam?#

Das Training auf einer einzelnen GPU kann aufgrund großer Batch-Größen oder unzureichendem Speicher langsam sein. Um das Training zu beschleunigen, verwende mehrere GPUs. Stelle sicher, dass dein System über mehrere GPUs verfügt, und setze das device-Argument, z. B. device=[0,1,2,3]. Erhöhe die Batch-Größe entsprechend, um die GPUs vollständig auszulasten, ohne die Speichergrenzen zu überschreiten. Beispielbefehl:

model.train(data="/path/to/your/data.yaml", batch=32, device=[0, 1, 2, 3])

Link to this sectionWie kann ich sicherstellen, dass mein YOLO26-Modell auf der GPU trainiert wird?#

Wenn der 'device'-Wert in den Trainingsprotokollen 'null' anzeigt, bedeutet dies im Allgemeinen, dass der Trainingsprozess so eingestellt ist, dass er automatisch eine verfügbare GPU auswählt. Um explizit eine bestimmte GPU zuzuweisen, übergebe das device-Argument beim Start des Trainings, zum Beispiel yolo train data=path/to/data.yaml device=0 für die erste GPU. Nutze den Befehl nvidia-smi, um dein CUDA-Setup zu überprüfen.

Link to this sectionWie kann ich meinen YOLO26-Modelltrainingsfortschritt überwachen und verfolgen?#

Das Nachverfolgen und Visualisieren des Trainingsfortschritts kann effizient über Tools wie TensorBoard, Comet und die Ultralytics Plattform verwaltet werden. Diese Tools ermöglichen es dir, Metriken wie Loss, Präzision, Recall und mAP zu protokollieren und zu visualisieren. Die Implementierung von Early Stopping auf Basis dieser Metriken kann ebenfalls dazu beitragen, bessere Trainingsergebnisse zu erzielen.

Link to this sectionWas sollte ich tun, wenn YOLO26 mein Datensatzformat nicht erkennt?#

Stelle sicher, dass dein Datensatz und deine Labels dem erwarteten Format entsprechen. Überprüfe, ob die Annotationen präzise sind und eine hohe Qualität aufweisen. Wenn du auf Probleme stößt, schlage im Leitfaden zur Datenerfassung und Annotation nach, um Best Practices zu erfahren. Für weitere datensatzspezifische Anleitungen überprüfe den Abschnitt Datensätze in der Dokumentation.