Häufig gestellte Fragen (FAQ) zu Ultralytics YOLO

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

FAQ

Was ist Ultralytics und was wird angeboten?

Ultralytics ist ein Unternehmen für Computer Vision und KI, das sich auf modernste Objekterkennungs- und Image Segmentation-Modelle spezialisiert hat, mit einem Fokus auf die YOLO (You Only Look Once)-Familie. Das Angebot umfasst:

• Open-Source-Implementierungen von YOLO26 (neueste Version) und YOLO11 (vorherige Generation)
• Eine breite Palette an pretrained models für verschiedene Aufgaben im Bereich Computer Vision
• Ein umfassendes Python package für die nahtlose Integration von YOLO-Modellen in Projekte
• Vielseitige tools zum Training, Testen und Bereitstellen von Modellen
• Extensive documentation und eine hilfsbereite Community

Wie installiere ich das Ultralytics-Paket?

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

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.

Was sind die Systemanforderungen für das Ausführen von Ultralytics-Modellen?

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 Speicherung von Datensätzen und das Modelltraining)

Für die Fehlerbehebung bei häufigen Problemen besuche die Seite YOLO Common Issues.

Wie kann ich ein benutzerdefiniertes YOLO-Modell mit meinem eigenen Datensatz trainieren?

Um ein benutzerdefiniertes YOLO-Modell zu trainieren:

1. Bereite deinen Datensatz im YOLO format vor (Bilder und entsprechende Textdateien mit Labels).

2. Erstelle eine YAML-Datei, die die Struktur und die Klassen deines Datensatzes 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)

Für eine ausführlichere Anleitung, einschließlich Datenvorbereitung und fortgeschrittenen Trainingsoptionen, schau in den umfassenden training guide.

Welche vortrainierten Modelle sind in Ultralytics verfügbar?

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
• 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 unterscheiden sich in Größe und Komplexität und bieten unterschiedliche Abwägungen zwischen Geschwindigkeit und accuracy. Entdecke die gesamte Auswahl an pretrained models, um die beste Lösung für dein Projekt zu finden.

Wie führe ich eine Inferenz mit einem trainierten Ultralytics-Modell durch?

So führst du die Inferenz mit einem trainierten Modell 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

Für erweiterte Inferenzoptionen, einschließlich Batch-Verarbeitung und Video-Inferenz, schau in den detaillierten prediction guide.

Können Ultralytics-Modelle auf Edge-Geräten oder in Produktionsumgebungen bereitgestellt werden?

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

• Edge-Geräte: Optimiere die Inferenz auf Geräten wie NVIDIA Jetson oder Intel Neural Compute Stick mit TensorRT, ONNX oder OpenVINO.
• Mobil: Bereitstellung auf Android- oder iOS-Geräten durch Konvertierung der Modelle in TFLite oder Core ML.
• Cloud: Nutze Frameworks wie TensorFlow Serving oder PyTorch Serve für skalierbare Cloud-Bereitstellungen.
• Web: Implementiere In-Browser-Inferenz mit ONNX.js oder TensorFlow.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.

Was ist der Unterschied zwischen YOLO11 und YOLO26?

Die wichtigsten Unterschiede sind:

• End-to-End NMS-Free Inference: YOLO26 ist von Haus aus End-to-End und erstellt Vorhersagen direkt ohne Non-Maximum Suppression (NMS), was die Latenz reduziert und die Bereitstellung vereinfacht.
• Entfernung von DFL: YOLO26 entfernt das Distribution Focal Loss-Modul, was den Export vereinfacht und die Kompatibilität mit Edge- und stromsparenden Geräten verbessert.
• MuSGD-Optimierer: Eine hybride Lösung aus SGD und Muon (inspiriert von Moonshot AI's Kimi K2) für stabileres Training und schnellere Konvergenz.
• CPU-Leistung: YOLO26 bietet bis zu 43 % schnellere CPU-Inferenz und ist damit ideal für Geräte ohne GPU.
• 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, Instanzsegmentierung, Klassifizierung, Pose-Schätzung und orientierte Objekterkennung (OBB) in einem einheitlichen Framework.

Für einen detaillierten Vergleich der Funktionen und Leistungskennzahlen besuche die YOLO26 documentation page.

Wie kann ich zum Open-Source-Projekt von Ultralytics beitragen?

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 bestanden werden.
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.

Wie installiere ich das Ultralytics-Paket in Python?

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 modernste 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.

Was sind die Hauptfunktionen von Ultralytics YOLO?

Ultralytics YOLO bietet eine Fülle an Funktionen für fortgeschrittene Computer Vision-Aufgaben:

• Echtzeiterkennung: Objekte in Echtzeitszenarien effizient erkennen und klassifizieren.
• Multitasking-Fähigkeiten: Objekterkennung, Instanzsegmentierung, Klassifizierung und Pose-Schätzung mit einem einheitlichen Framework durchführen.
• Vortrainierte Modelle: Greife auf eine Vielzahl von pretrained models zu, die Geschwindigkeit und Genauigkeit für verschiedene Anwendungsfälle ausbalancieren.
• Benutzerdefiniertes Training: Optimiere Modelle ganz einfach mit benutzerdefinierten Datensätzen über die flexible training pipeline.
• Umfassende Deployment Options: Exportiere Modelle in verschiedene Formate wie TensorRT, ONNX und CoreML für die Bereitstellung auf verschiedenen Plattformen.
• Umfangreiche Dokumentation: Profitiere von der umfassenden documentation und einer hilfsbereiten Community für deine Computer Vision-Workflows.

Wie kann ich die Leistung meines YOLO-Modells verbessern?

Die Leistung deines YOLO-Modells lässt sich durch mehrere Techniken verbessern:

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 Generalisierung des Modells zu verbessern.
3. Transfer Learning: Nutze vortrainierte Modelle und optimiere sie für deinen spezifischen Datensatz mithilfe des Train guide.
4. Export in effiziente Formate: Konvertiere dein Modell in optimierte Formate wie TensorRT oder ONNX für eine schnellere Inferenz mithilfe des Export guide.
5. Benchmarking: Nutze den Benchmark Mode, um Inferenzgeschwindigkeit und Genauigkeit systematisch zu messen und zu verbessern.

Kann ich Ultralytics YOLO-Modelle auf Mobil- und Edge-Geräten bereitstellen?

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

• Mobil: Konvertiere Modelle in TFLite oder CoreML für eine nahtlose Integration in Android- oder iOS-Apps. Siehe den TFLite Integration Guide und den CoreML Integration Guide für plattformspezifische Anweisungen.
• 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.

Für einen umfassenden Überblick über Bereitstellungsstrategien auf verschiedenen Plattformen ziehe den deployment options guide zu Rate.

Wie kann ich die Inferenz mit einem trainierten Ultralytics YOLO-Modell durchführen?

Die Inferenz mit einem trainierten Ultralytics YOLO-Modell ist unkompliziert:

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, Video-Inferenz und benutzerdefinierter Vorverarbeitung, schau in den detaillierten prediction guide.

Wo finde ich Beispiele und Tutorials zur Verwendung von Ultralytics?

Ultralytics bietet eine Fülle von Ressourcen, die dir helfen, loszulegen und ihre Tools zu meistern:

• 📚 Offizielle Dokumentation: Umfassende Anleitungen, API-Referenzen und Best Practices.
• 💻 GitHub repository: Quellcode, Beispielskripte und Community-Beiträge.
• ✍️ Ultralytics blog: Ausführliche Artikel, Anwendungsfälle und technische Einblicke.
• 💬 Community-Foren: Vernetze dich mit anderen Benutzern, stelle Fragen und teile deine Erfahrungen.
• 🎥 YouTube-Kanal: Video-Tutorials, 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, schau in der Ultralytics-Dokumentation nach oder wende dich über GitHub Issues oder das offizielle Diskussionsforum an die Community.