Häufig gestellte Fragen (FAQ) zu Ultralytics YOLO#

Ultralytics ist ein KI-Unternehmen im Bereich Computer Vision, das sich auf hochmoderne Modelle zur Objekterkennung und Bildsegmentierung spezialisiert hat. Der Schwerpunkt liegt auf der YOLO-Familie (Du siehst nur einmal). Zum Angebot gehören:

• Open-Source-Implementierungen von YOLO26 (aktuelle Generation) und YOLO11 (vorherige Generation)
• Eine große Auswahl an vortrainierten Modellen für verschiedene Aufgaben der Computer Vision
• Ein umfassendes Python-Paket zur nahtlosen Integration von YOLO-Modellen in Projekte
• Vielseitige Werkzeuge zum Trainieren, Testen und Bereitstellen von Modellen
• Umfassende Dokumentation und eine hilfsbereite Community

Nein. YOLO27 befindet sich in der abschließenden Forschungs- und Entwicklungsphase; die Veröffentlichung wird noch in diesem Jahr erwartet, ein konkreter Termin steht jedoch nicht fest. Die Dokumentation gibt einen Ausblick auf die Funktionen, vorläufige Benchmarks und Anwendungsbeispiele für die Zeit nach der Veröffentlichung. Verwende für aktuelle Projekte weiterhin YOLO26.

Das Ultralytics-Paket lässt sich ganz einfach mit pip installieren:

pip install ultralytics

Die neueste Entwicklungsversion kannst du direkt aus dem GitHub-Repository installieren:

pip install git+https://github.com/ultralytics/ultralytics.git

Eine ausführliche Installationsanleitung findest du im Schnellstartleitfaden.

Mindestanforderungen:

• Python 3.8+
• PyTorch 1.8+
• CUDA-kompatible GPU (für GPU-Beschleunigung)

Empfohlene Konfiguration:

• Python 3.8+
• PyTorch 1.10+
• NVIDIA-GPU mit CUDA 11.2+
• 8 GB RAM oder mehr
• 50 GB freier Speicherplatz oder mehr (für die Speicherung von Datensätzen und das Modelltraining)

Hilfe bei häufigen Problemen findest du auf der Seite Häufige YOLO-Probleme.

So trainierst du ein eigenes YOLO-Modell:

1. Bereite deinen Datensatz im YOLO-Format vor (Bilder und die zugehörigen txt-Dateien mit Beschriftungen).

2. Erstelle eine YAML-Datei, in der die Struktur und Klassen deines Datensatzes beschrieben sind (siehe Beispiel für eine Dataset-YAML-Datei).

3. Starte das Training mit folgendem Python-Code:

   from ultralytics import YOLO
   
   # Ein Modell laden
   model = YOLO("yolo26n.yaml")  # ein neues Modell von Grund auf erstellen
   model = YOLO("yolo26n.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)
   
   # Das Modell trainieren
   results = model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

Eine ausführlichere Anleitung zu Datenaufbereitung und erweiterten Trainingsoptionen findest du im umfassenden Leitfaden zum Training.

Ultralytics bietet eine vielfältige Auswahl vortrainierter Modelle für verschiedene Aufgaben:

• Objekterkennung: YOLO26n, YOLO26s, YOLO26m, YOLO26l, YOLO26x
• Instanzsegmentierung: YOLO26n-seg, YOLO26s-seg, YOLO26m-seg, YOLO26l-seg, YOLO26x-seg
• Semantische Segmentierung: YOLO26n-sem, YOLO26s-sem, YOLO26m-sem, YOLO26l-sem, YOLO26x-sem
• Tiefenschätzung: YOLO26n-depth, YOLO26s-depth, YOLO26m-depth, YOLO26l-depth, YOLO26x-depth
• Klassifizierung: YOLO26n-cls, YOLO26s-cls, YOLO26m-cls, YOLO26l-cls, YOLO26x-cls
• Posenschätzung: YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, YOLO26l-pose, YOLO26x-pose
• Oriented Detection (OBB): YOLO26n-obb, YOLO26s-obb, YOLO26m-obb, YOLO26l-obb, YOLO26x-obb

Diese Modelle unterscheiden sich in Größe und Komplexität und bieten verschiedene Kompromisse zwischen Geschwindigkeit und Genauigkeit. Entdecke die vollständige Auswahl an vortrainierten Modellen, um das passende Modell für dein Projekt zu finden.

So führst du mit einem trainierten Modell eine Inferenz durch:

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("path/to/your/model.pt")

# Inferenz ausführen
results = model("path/to/image.jpg")

# Ergebnisse verarbeiten
for r in results:
    print(r.boxes)  # BBox-Vorhersagen ausgeben
    print(r.masks)  # Maskenvorhersagen ausgeben
    print(r.probs)  # Klassenwahrscheinlichkeiten ausgeben

Erweiterte Inferenzoptionen, einschließlich Stapelverarbeitung und Videoinferenz, findest du im ausführlichen Leitfaden zu Vorhersagen.

Auf jeden Fall! Ultralytics-Modelle sind für den vielseitigen Einsatz auf verschiedenen Plattformen konzipiert:

• Edge-Geräte: Optimiere die Inferenz auf Geräten wie NVIDIA Jetson oder Raspberry Pi mit TensorRT, ONNX oder OpenVINO.
• Mobilgeräte: Stelle Modelle auf Android- oder iOS-Geräten bereit, indem du sie in LiteRT oder CoreML umwandelst.
• Cloud: Nutze Frameworks wie TensorFlow Serving oder TorchServe für skalierbare Cloud-Bereitstellungen.
• Web: Implementiere Inferenz im Browser mit ONNX Runtime Web.

Ultralytics bietet Exportfunktionen, mit denen du Modelle für den Einsatz in verschiedene Formate umwandeln kannst. Entdecke die vielfältigen Bereitstellungsoptionen, um die beste Lösung für deinen Anwendungsfall zu finden.

Zu den wichtigsten Unterschieden gehören:

• End-to-End-Inferenz ohne NMS: YOLO26 ermöglicht Inferenz ohne NMS mit nms=False. Der standardmäßige One-to-Many-Pfad verwendet NMS für höhere Genauigkeit.
• Entfernung von DFL: YOLO26 entfernt das Distribution-Focal-Loss-Modul. Das vereinfacht den Export und verbessert die Kompatibilität mit Edge-Geräten und Geräten mit geringem Stromverbrauch.
• MuSGD-Optimierer: Eine Kombination aus SGD und Muon (inspiriert von Kimi K2 von Moonshot AI), die für stabileres Training und schnellere Konvergenz sorgt.
• CPU-Leistung: YOLO26n läuft bei der ONNX-Inferenz auf der CPU (Intel Xeon CPU @ 2.00 GHz) bis zu 43 % schneller als YOLO11n und eignet sich daher ideal für Geräte ohne GPU.
• Aufgabenspezifische Optimierungen: verbesserte Segmentierung mit semantischem Loss und Protos mit mehreren Maßstäben, RLE für präzise Pose-Schätzung und verbesserte OBB-Dekodierung mit Winkel-Loss.
• Aufgaben: Beide Modelle unterstützen Objekterkennung und Instanzsegmentierung, während YOLO26 zusätzlich semantische Segmentierung für dichte Vorhersagen auf Pixelebene und monokulare Tiefenschätzung für die Tiefe jedes Pixels bietet. Beide Modelle unterstützen außerdem Klassifizierung, Pose-Schätzung und orientierte Objekterkennung (OBB) in einem einheitlichen Framework.

Eine ausführliche Gegenüberstellung der Funktionen und Leistungskennzahlen findest du auf der Dokumentationsseite zu YOLO26.

Beiträge zu Ultralytics sind eine gute Möglichkeit, das Projekt zu verbessern und deine Fähigkeiten auszubauen. So kannst du mitwirken:

1. Erstelle einen Fork des Ultralytics-Repositorys auf GitHub.
2. Erstelle einen neuen Branch für dein Feature oder deine Fehlerbehebung.
3. Nimm deine Änderungen vor und stelle sicher, dass alle Tests erfolgreich sind.
4. Reiche einen Pull Request mit einer klaren Beschreibung deiner Änderungen ein.
5. Beteilige dich am Code-Review-Prozess.

Du kannst auch mitwirken, indem du Fehler meldest, Funktionen vorschlägst oder die Dokumentation verbesserst. Detaillierte Richtlinien und bewährte Vorgehensweisen findest du im Leitfaden zum Mitwirken.

Ultralytics YOLO bietet zahlreiche Funktionen für anspruchsvolle Aufgaben der Bildverarbeitung:

• Echtzeit-Erkennung: Erkenne und klassifiziere Objekte effizient in Echtzeitszenarien.
• Multitasking-Funktionen: Führe Objekterkennung, Instanzsegmentierung, semantische Segmentierung, monokulare Tiefenschätzung, Klassifizierung, Pose-Schätzung und orientierte Objekterkennung (OBB) in einem einheitlichen Framework aus.
• Vortrainierte Modelle: Nutze eine Auswahl an vortrainierten Modellen, die für verschiedene Anwendungsfälle Geschwindigkeit und Genauigkeit in Einklang bringen.
• Individuelles Training: Passe Modelle mit der flexiblen Trainingspipeline ganz einfach an eigene Datensätze an.
• Vielfältige Bereitstellungsoptionen: Exportiere Modelle für den Einsatz auf verschiedenen Plattformen in Formate wie TensorRT, ONNX und CoreML.
• Umfassende Dokumentation: Profitiere von einer ausführlichen Dokumentation und einer hilfsbereiten Community für deine Arbeitsabläufe in der Bildverarbeitung.

Die Leistung deines YOLO-Modells lässt sich mit verschiedenen Methoden steigern:

1. Hyperparameter-Abstimmung: Probiere verschiedene Hyperparameter mithilfe des Leitfadens zur Hyperparameter-Abstimmung aus, um die Modellleistung zu optimieren.
2. Datenerweiterung: Nutze Techniken wie Spiegeln, Skalieren, Drehen und Farbanpassungen, um deinen Trainingsdatensatz zu erweitern und die Generalisierungsfähigkeit des Modells zu verbessern.
3. Transferlernen: Nutze vortrainierte Modelle und passe sie mithilfe des Trainingsleitfadens an deinen konkreten Datensatz an.
4. Export in effiziente Formate: Wandle dein Modell für schnellere Inferenz in optimierte Formate wie TensorRT oder ONNX um. Eine Anleitung dazu findest du im Exportleitfaden.
5. Benchmarking: Nutze den Benchmark-Modus, um Inferenzgeschwindigkeit und Genauigkeit systematisch zu messen und zu verbessern.

Ultralytics bietet zahlreiche Ressourcen, die dir den Einstieg erleichtern und dir helfen, die Tools sicher zu beherrschen:

• 📚 Offizielle Dokumentation: Umfassende Anleitungen, API-Referenzen und bewährte Vorgehensweisen.
• 💻 GitHub-Repository: Quellcode, Beispielskripte und Beiträge aus der Community.
• ✍️ Ultralytics-Blog: Ausführliche Artikel, Anwendungsfälle und technische Einblicke.
• 💬 Community-Foren: Tausche dich mit anderen Nutzern aus, stelle Fragen und teile deine Erfahrungen.
• 🎥 YouTube-Kanal: Video-Tutorials, Demos und Webinare zu verschiedenen Themen rund um Ultralytics.

Diese Ressourcen bieten Codebeispiele, Anwendungsfälle aus der Praxis und Schritt-für-Schritt-Anleitungen für verschiedene Aufgaben mit Ultralytics-Modellen.

Wenn du weitere Unterstützung benötigst, sieh in der Ultralytics-Dokumentation nach oder wende dich über GitHub-Issues oder das offizielle Diskussionsforum an die Community.