Ultralytics YOLO27:

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

Dieser FAQ-Abschnitt behandelt häufige Fragen und Probleme, auf die du bei der Arbeit mit Ultralytics-YOLO-Repositorys stoßen kannst.

FAQ#

  • Ultralytics ist ein Computer-Vision-KI-Unternehmen, das sich auf hochmoderne Modelle zur Objekterkennung und Bildsegmentierung spezialisiert und dabei den Schwerpunkt auf die YOLO-Familie (Du siehst nur einmal) legt. Das Angebot umfasst:

  • Nein. YOLO27 durchläuft derzeit finale F&E-Arbeiten für einen voraussichtlichen Start im Laufe dieses Jahres, ein genauer Starttermin steht jedoch noch nicht fest. Die Dokumentation gibt eine Vorschau auf die Funktionen, vorläufigen Benchmarks und Beispiele für die Verwendung nach der Veröffentlichung. Nutze weiterhin YOLO26 für aktuelle Projekte.

  • Die Installation des Ultralytics-Pakets ist mit pip unkompliziert:

    pip install ultralytics

    Installiere die aktuelle Entwicklungsversion direkt aus dem GitHub-Repository:

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

    Detaillierte Installationsanweisungen 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+
    • Mindestens 8 GB RAM
    • Mindestens 50 GB freier Speicherplatz (für die Speicherung von Datensätzen und das Modelltraining)

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

  • So trainierst du ein benutzerdefiniertes YOLO-Modell:

    1. Bereite deinen Datensatz im YOLO-Format vor (Bilder und zugehörige TXT-Dateien mit Beschriftungen).

    2. Erstelle eine YAML-Datei, die die Struktur und Klassen deines Datensatzes beschreibt (siehe Beispiel für eine Datensatz-YAML-Datei).

    3. Verwende den folgenden Python-Code, um das Training zu starten:

      from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.yaml")  # build a new model from scratch
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

    Eine ausführlichere Anleitung einschließlich Datenvorbereitung und erweiterter Trainingsoptionen findest du im umfassenden Trainingsleitfaden.

  • Ultralytics bietet eine vielfältige Auswahl an vortrainierten Modellen 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
    • Klassifikation: YOLO26n-cls, YOLO26s-cls, YOLO26m-cls, YOLO26l-cls, YOLO26x-cls
    • Posenschätzung: YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, YOLO26l-pose, YOLO26x-pose
    • Orientierte Erkennung (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. Sieh dir die vollständige Auswahl an vortrainierten Modellen an, 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

# Load a model
model = YOLO("path/to/your/model.pt")

# Perform inference
results = model("path/to/image.jpg")

# Process results
for r in results:
    print(r.boxes)  # print bbox predictions
    print(r.masks)  # print mask predictions
    print(r.probs)  # print class probabilities

    Erweiterte Inferenzoptionen einschließlich Stapelverarbeitung und Videoinferenz findest du im ausführlichen Vorhersageleitfaden.

  • Auf jeden Fall! Ultralytics-Modelle sind für eine vielseitige Bereitstellung auf verschiedenen Plattformen ausgelegt:

    • 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 Core ML konvertierst.
    • Cloud: Nutze Frameworks wie TensorFlow Serving oder TorchServe für skalierbare Cloud-Deployments.
    • Web: Implementiere die Inferenz im Browser mit ONNX Runtime Web.

    Ultralytics stellt Exportfunktionen bereit, um Modelle für die Bereitstellung in verschiedene Formate zu konvertieren. Sieh dir die große Auswahl an Bereitstellungsoptionen an, um die beste Lösung für deinen Anwendungsfall zu finden.

  • Zu den wichtigsten Unterschieden gehören:

    • End-to-End NMS-Free Inference: YOLO26 bietet nms-freie Inferenz mit nms=False. Der standardmäßige One-to-Many-Pfad von YOLO26 nutzt NMS für die Genauigkeit.
    • Entfernung von DFL: YOLO26 entfernt das Modul Distribution Focal Loss, wodurch der Export vereinfacht und die Kompatibilität mit Edge-Geräten und Geräten mit geringem Energieverbrauch verbessert wird.
    • MuSGD-Optimierer: Eine Kombination aus SGD und Muon (inspiriert von Kimi K2 von Moonshot AI) für stabileres Training und schnellere Konvergenz.
    • CPU-Leistung: YOLO26n läuft bei der ONNX-Inferenz auf einer CPU (Intel Xeon CPU @ 2.00 GHz) bis zu 43 % schneller als YOLO11n und eignet sich dadurch ideal für Geräte ohne GPUs.
    • Aufgabenspezifische Optimierungen: Verbesserte Segmentierung mit semantischem Verlust und Prototypen mit mehreren Maßstäben, RLE für präzise Posenschätzung sowie verbesserte OBB-Dekodierung mit Winkelfehler.
    • 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 Tiefenwerte pro Pixel bietet. Beide Modelle unterstützen außerdem Klassifikation, Posenschätzung und die orientierte Objekterkennung (OBB) in einem einheitlichen Framework.

    Einen ausführlichen Vergleich der Funktionen und Leistungskennzahlen findest du auf der YOLO26-Dokumentationsseite.

  • Ein Beitrag zu Ultralytics ist eine gute Möglichkeit, das Projekt zu verbessern und deine Fähigkeiten auszubauen. So kannst du dich beteiligen:

    1. Erstelle auf GitHub einen Fork des Ultralytics-Repositorys.
    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 durch das Melden von Fehlern, das Vorschlagen von Funktionen oder das Verbessern der Dokumentation beitragen. Ausführliche Richtlinien und Best Practices findest du im Leitfaden für Beiträge.

  • Ultralytics YOLO bietet eine umfangreiche Auswahl an Funktionen für anspruchsvolle Computer-Vision-Aufgaben:

    • Echtzeiterkennung: Erkenne und klassifiziere Objekte effizient in Echtzeitszenarien.
    • Multitasking-Funktionen: Führe Objekterkennung, Instanzsegmentierung, semantische Segmentierung, monokulare Tiefenschätzung, Klassifikation, Posenschätzung und orientierte Objekterkennung (OBB) mit einem einheitlichen Framework durch.
    • Vortrainierte Modelle: Greife auf eine Vielzahl vortrainierter Modelle zu, die Geschwindigkeit und Genauigkeit für verschiedene Anwendungsfälle ausbalancieren.
    • Benutzerdefiniertes Training: Passe Modelle mit der flexiblen Trainingspipeline einfach an benutzerdefinierte Datensätze an.
    • Vielfältige Bereitstellungsoptionen: Exportiere Modelle für die Bereitstellung auf verschiedenen Plattformen in Formate wie TensorRT, ONNX und CoreML.
    • Umfassende Dokumentation: Profitiere von einer umfassenden Dokumentation und einer hilfsbereiten Community für deine Computer-Vision-Workflows.

  • Die Leistung deines YOLO-Modells lässt sich durch verschiedene Methoden steigern:

    1. Hyperparameter-Optimierung: Probiere mithilfe des Leitfadens zur Hyperparameter-Optimierung verschiedene Hyperparameter aus, um die Modellleistung zu optimieren.
    2. Datenerweiterung: Setze Methoden wie Spiegeln, Skalieren, Drehen und Farbanpassungen ein, um deinen Trainingsdatensatz zu erweitern und die Verallgemeinerungsfähigkeit des Modells zu verbessern.
    3. Transferlernen: Nutze vortrainierte Modelle und passe sie mit dem Trainingsleitfaden an deinen spezifischen Datensatz an.
    4. Export in effiziente Formate: Konvertiere dein Modell mit dem Exportleitfaden in optimierte Formate wie TensorRT oder ONNX, um eine schnellere Inferenz zu ermöglichen.
    5. Benchmarking: Nutze den Benchmark-Modus, um Inferenzgeschwindigkeit und Genauigkeit systematisch zu messen und zu verbessern.

  • Ultralytics stellt zahlreiche Ressourcen bereit, die dir den Einstieg erleichtern und dir helfen, die Werkzeuge sicher zu beherrschen:

    • 📚 Offizielle Dokumentation: Umfassende Leitfäden, API-Referenzen und Best Practices.
    • 💻 GitHub-Repository: Quellcode, Beispielskripte und Beiträge der Community.
    • ✍️ Ultralytics-Blog: Ausführliche Artikel, Anwendungsfälle und technische Einblicke.
    • 💬 Community-Foren: Vernetze dich mit anderen Nutzern, stelle Fragen und teile deine Erfahrungen.
    • 🎥 YouTube-Kanal: Videoanleitungen, Demos und Webinare zu verschiedenen Ultralytics-Themen.

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

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

Mitwirkende
GLglenn-jocher18RAraimbekovm3PDpderrenger2LALaughing-q2BOBovey08091AMambitious-octopus1SEsergiuwaxmann1RIRizwanMunawar1

Kommentare