YOLO Vision 2026:

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

Dieser FAQ-Bereich behandelt häufige Fragen und Probleme, auf die du bei der Arbeit mit Ultralytics YOLO-Repositories stoßen könntest.

FAQ#

  • Ultralytics ist ein auf computer vision spezialisiertes KI-Unternehmen für hochmoderne Objekterkennungs- und image segmentation-Modelle mit Schwerpunkt auf der YOLO-Familie (You Only Look Once). Das Angebot umfasst:

    • Open-Source-Implementierungen von YOLO26 (neueste Version) und YOLO11 (vorherige Generation)
    • Eine große Auswahl an pretrained models für verschiedene Computer-Vision-Aufgaben
    • Ein umfassendes Python package zur nahtlosen Integration von YOLO-Modellen in Projekte
    • Vielseitige tools zum Trainieren, Testen und Bereitstellen von Modellen
    • Extensive documentation und eine unterstützende Community

  • Die Installation des Ultralytics-Pakets ist ganz einfach mit pip:

    pip install ultralytics

    Für die neueste Entwicklungsversion installiere direkt aus dem GitHub-Repository:

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

    Detaillierte Installationsanweisungen findest du im quickstart guide.

  • Mindestanforderungen:

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

    Empfohlenes Setup:

    • Python 3.8+
    • PyTorch 1.10+
    • NVIDIA GPU mit CUDA 11.2+
    • 8 GB+ RAM
    • 50 GB+ freier Festplattenspeicher (für die Datensatzspeicherung und das Modelltraining)

    Zur Behebung häufiger Probleme besuche die Seite YOLO Common Issues.

  • So trainierst du ein benutzerdefiniertes YOLO-Modell:

    1. Bereite deinen Datensatz im YOLO format vor (Bilder und entsprechende txt-Label-Dateien).

    2. Erstelle eine YAML-Datei, die deine Datensatzstruktur und Klassen beschreibt (siehe dataset YAML example).

    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 fortgeschrittener Trainingsoptionen, findest du im umfassenden training guide.

  • Ultralytics bietet eine vielfältige Auswahl an vortrainierten Modellen für verschiedene Aufgaben:

    • Objekterkennung: YOLO26n, YOLO26s, YOLO26m, YOLO26l, YOLO26x
    • Instance Segmentation: YOLO26n-seg, YOLO26s-seg, YOLO26m-seg, YOLO26l-seg, YOLO26x-seg
    • Semantic Segmentation: YOLO26n-sem, YOLO26s-sem, YOLO26m-sem, YOLO26l-sem, YOLO26x-sem
    • Depth Estimation: YOLO26n-depth, YOLO26s-depth, YOLO26m-depth, YOLO26l-depth, YOLO26x-depth
    • Klassifizierung: YOLO26n-cls, YOLO26s-cls, YOLO26m-cls, YOLO26l-cls, YOLO26x-cls
    • Pose-Schätzung: YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, YOLO26l-pose, YOLO26x-pose
    • Orientierte Objekterkennung (OBB): YOLO26n-obb, YOLO26s-obb, YOLO26m-obb, YOLO26l-obb, YOLO26x-obb

    Diese Modelle variieren in Größe und Komplexität und bieten unterschiedliche Kompromisse zwischen Geschwindigkeit und accuracy. Entdecke die gesamte Palette an pretrained models, um die beste Passform für dein Projekt zu finden.

  • Um eine Inferenz mit einem trainierten Modell durchzuführen:

    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

    Für erweiterte Inferenzoptionen, einschließlich Batch-Verarbeitung und Videoinferenz, schaue dir die detaillierte prediction guide an.

  • Absolut! 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 Intel Neural Compute Stick unter Verwendung von TensorRT, ONNX oder OpenVINO.
    • Mobil: Bereite Modelle für die Bereitstellung auf Android- oder iOS-Geräten vor, indem du sie in LiteRT oder Core ML konvertierst.
    • Cloud: Nutze Frameworks wie TensorFlow Serving oder PyTorch Serve für skalierbare Cloud-Bereitstellungen.
    • Web: Implementiere Inferenz im Browser unter Verwendung von LiteRT.js oder ONNX.js.

    Ultralytics bietet Exportfunktionen, um Modelle für die Bereitstellung in verschiedene Formate zu konvertieren. Entdecke die große Auswahl an deployment options, um die beste Lösung für deinen Anwendungsfall zu finden.

  • Wichtige Unterschiede sind:

    • End-to-End NMS-Free Inference: YOLO26 ist von Haus aus End-to-End, erzeugt Vorhersagen direkt ohne Non-Maximum Suppression (NMS), reduziert die Latenz und vereinfacht die Bereitstellung.
    • DFL-Entfernung: YOLO26 entfernt das Distribution Focal Loss-Modul, was den Export vereinfacht und die Kompatibilität mit Edge- und Low-Power-Geräten verbessert.
    • MuSGD-Optimizer: Ein Hybrid aus SGD und Muon (inspiriert von Moonshot AIs Kimi K2) für stabileres Training und schnellere Konvergenz.
    • CPU-Leistung: YOLO26 bietet bis zu 43 % schnellere CPU-Inferenz, was es ideal für Geräte ohne GPUs macht.
    • Aufgabenspezifische Optimierungen: Verbesserte Segmentierung mit semantischem Verlust und Multi-Scale-Protos, RLE für präzise Pose-Schätzung und verbesserte OBB-Dekodierung mit Winkelverlust.
    • Aufgaben: Beide Modelle unterstützen object detection und Instance Segmentation, während YOLO26 zusätzlich semantic segmentation für dichte pixelbasierte Vorhersagen und monocular depth estimation für die Tiefenschätzung pro Pixel hinzufügt. Beide Modelle unterstützen zudem Klassifizierung, Pose Estimation und orientierte Objekterkennung (OBB) in einem einheitlichen Framework.

    Einen detaillierten Vergleich von Funktionen und Leistungsmetriken findest du auf der YOLO26 documentation page.

  • Ein Beitrag zu Ultralytics ist eine großartige Möglichkeit, das Projekt zu verbessern und deine Fähigkeiten zu erweitern. So kannst du mitmachen:

    1. Forke das Ultralytics-Repository auf GitHub.
    2. Erstelle einen neuen Branch für dein Feature oder deinen Bugfix.
    3. Führe deine Änderungen durch und stelle sicher, dass alle Tests bestehen.
    4. Reiche einen Pull Request mit einer klaren Beschreibung deiner Änderungen ein.
    5. Nimm am Code-Review-Prozess teil.

    Du kannst auch beitragen, indem du Fehler meldest, Funktionen vorschlägst oder die Dokumentation verbesserst. Detaillierte Richtlinien und Best Practices findest du im contributing guide.

  • Die Installation des Ultralytics-Pakets in Python ist einfach. Verwende pip, indem du den folgenden Befehl in deinem Terminal oder deiner Eingabeaufforderung ausführst:

    pip install ultralytics

    Für die neueste Entwicklungsversion installiere direkt aus dem GitHub-Repository:

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

    Für umgebungsspezifische Installationsanweisungen und Tipps zur Fehlerbehebung ziehe den umfassenden quickstart guide zu Rate.

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

    • Echtzeit-Erkennung: Effiziente Erkennung und Klassifizierung von Objekten in Echtzeitszenarien.
    • Multitasking-Fähigkeiten: Führe Objekterkennung, Instance Segmentation, semantic segmentation, monocular depth estimation, Klassifizierung, Pose Estimation und orientierte Objekterkennung (OBB) mit einem einheitlichen Framework durch.
    • Vortrainierte Modelle: Greife auf verschiedene pretrained models zu, die Geschwindigkeit und Genauigkeit für verschiedene Anwendungsfälle ausgleichen.
    • Benutzerdefiniertes Training: Passe Modelle mit der flexiblen training pipeline ganz einfach an benutzerdefinierte Datensätze an.
    • Vielfältige Deployment Options: Exportiere Modelle in verschiedene Formate wie TensorRT, ONNX und CoreML für die Bereitstellung auf unterschiedlichen Plattformen.
    • Umfassende Dokumentation: Profitiere von einer umfassenden documentation und einer unterstützenden Community für deine Computer-Vision-Workflows.

  • Die Verbesserung der Leistung deines YOLO-Modells kann durch verschiedene Techniken erreicht werden:

    1. Hyperparameter Tuning: Experimentiere mit verschiedenen Hyperparametern unter Verwendung des Hyperparameter Tuning Guide, um die Modellleistung zu optimieren.
    2. Data Augmentation: Implementiere Techniken wie Spiegeln, Skalieren, Drehen und Farbanpassungen, um deinen Trainingsdatensatz zu erweitern und die Verallgemeinerung des Modells zu verbessern.
    3. Transfer Learning: Nutze vortrainierte Modelle und stimme sie mit dem Train guide auf deinen spezifischen Datensatz ab.
    4. Export in effiziente Formate: Konvertiere dein Modell für eine schnellere Inferenz mit dem Export guide in optimierte Formate wie TensorRT oder ONNX.
    5. Benchmarking: Nutze den Benchmark Mode, um die Inferenzgeschwindigkeit und -genauigkeit systematisch zu messen und zu verbessern.

  • Ja, Ultralytics YOLO-Modelle sind für eine vielseitige Bereitstellung konzipiert, einschließlich mobiler Geräte und Edge-Geräte:

    • Mobil: Konvertiere Modelle für die nahtlose Integration in Android- oder iOS-Apps in LiteRT oder CoreML. Spezifische Anweisungen für die jeweilige Plattform findest du im LiteRT Integration Guide und CoreML Integration Guide.
    • Edge-Geräte: Optimiere die Inferenz auf Geräten wie NVIDIA Jetson oder anderer Edge-Hardware mit TensorRT oder ONNX. Der Edge TPU Integration Guide bietet detaillierte Schritte für die Edge-Bereitstellung.

    Eine umfassende Übersicht über Bereitstellungsstrategien auf verschiedenen Plattformen findest du im deployment options guide.

  • Eine Inferenz mit einem trainierten Ultralytics YOLO-Modell durchzuführen ist ganz einfach:

    1. Modell laden:

      from ultralytics import YOLO

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

    2. Inferenz ausführen:

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

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

    Für fortgeschrittene Inferenztechniken, einschließlich Batch-Verarbeitung, Videoinferenz und benutzerdefinierter Vorverarbeitung, ziehe die detaillierte prediction guide zu Rate.

  • Ultralytics bietet eine Fülle an Ressourcen, die dir beim Einstieg und der Beherrschung ihrer Tools helfen:

    • 📚 Official documentation: Umfassende Leitfäden, API-Referenzen und Best Practices.
    • 💻 GitHub repository: Quellcode, Skriptbeispiele und Beiträge aus der Community.
    • ✍️ Ultralytics blog: Ausführliche Artikel, Anwendungsfälle und technische Einblicke.
    • 💬 Community forums: Verbinde dich mit anderen Nutzern, stelle Fragen und teile deine Erfahrungen.
    • 🎥 YouTube channel: Video-Tutorials, Demos und Webinare zu verschiedenen Ultralytics-Themen.

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

    Wenn du weitere Hilfe benötigst, konsultiere die Dokumentation von Ultralytics oder wende dich über GitHub Issues oder das offizielle discussion forum an die Community.

Mitwirkende
GLglenn-jocher14PDpderrenger2RAraimbekovm2LALaughing-q2BOBovey08091AMambitious-octopus1SEsergiuwaxmann1RIRizwanMunawar1

Kommentare