Add Docs languages zh, es, ru, pt, fr, de, ja, ko (#6316)
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com> Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
Glenn Jocher
GitHub
parent
e3a538bbde
commit
48e70f0921
144 changed files with 17632 additions and 76 deletions
94
docs/de/modes/benchmark.md
Normal file
94
docs/de/modes/benchmark.md
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
---
|
||||
comments: true
|
||||
description: Lernen Sie, wie Sie die Geschwindigkeit und Genauigkeit von YOLOv8 über verschiedene Exportformate hinweg profilieren können; erhalten Sie Einblicke in mAP50-95, Genauigkeit_top5 Kennzahlen und mehr.
|
||||
keywords: Ultralytics, YOLOv8, Benchmarking, Geschwindigkeitsprofilierung, Genauigkeitsprofilierung, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, YOLO-Exportformate
|
||||
---
|
||||
|
||||
# Modell-Benchmarking mit Ultralytics YOLO
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO-Ökosystem und Integrationen">
|
||||
|
||||
## Einführung
|
||||
|
||||
Nachdem Ihr Modell trainiert und validiert wurde, ist der nächste logische Schritt, seine Leistung in verschiedenen realen Szenarien zu bewerten. Der Benchmark-Modus in Ultralytics YOLOv8 dient diesem Zweck, indem er einen robusten Rahmen für die Beurteilung von Geschwindigkeit und Genauigkeit Ihres Modells über eine Reihe von Exportformaten hinweg bietet.
|
||||
|
||||
## Warum ist Benchmarking entscheidend?
|
||||
|
||||
- **Informierte Entscheidungen:** Erhalten Sie Einblicke in die Kompromisse zwischen Geschwindigkeit und Genauigkeit.
|
||||
- **Ressourcenzuweisung:** Verstehen Sie, wie sich verschiedene Exportformate auf unterschiedlicher Hardware verhalten.
|
||||
- **Optimierung:** Erfahren Sie, welches Exportformat die beste Leistung für Ihren spezifischen Anwendungsfall bietet.
|
||||
- **Kosteneffizienz:** Nutzen Sie Hardware-Ressourcen basierend auf den Benchmark-Ergebnissen effizienter.
|
||||
|
||||
### Schlüsselmetriken im Benchmark-Modus
|
||||
|
||||
- **mAP50-95:** Für Objekterkennung, Segmentierung und Posenschätzung.
|
||||
- **accuracy_top5:** Für die Bildklassifizierung.
|
||||
- **Inferenzzeit:** Zeit, die für jedes Bild in Millisekunden benötigt wird.
|
||||
|
||||
### Unterstützte Exportformate
|
||||
|
||||
- **ONNX:** Für optimale CPU-Leistung
|
||||
- **TensorRT:** Für maximale GPU-Effizienz
|
||||
- **OpenVINO:** Für die Optimierung von Intel-Hardware
|
||||
- **CoreML, TensorFlow SavedModel, und mehr:** Für vielfältige Deployment-Anforderungen.
|
||||
|
||||
!!! tip "Tipp"
|
||||
|
||||
* Exportieren Sie in ONNX oder OpenVINO für bis zu 3x CPU-Beschleunigung.
|
||||
* Exportieren Sie in TensorRT für bis zu 5x GPU-Beschleunigung.
|
||||
|
||||
## Anwendungsbeispiele
|
||||
|
||||
Führen Sie YOLOv8n-Benchmarks auf allen unterstützten Exportformaten einschließlich ONNX, TensorRT usw. durch. Siehe den Abschnitt Argumente unten für eine vollständige Liste der Exportargumente.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics.utils.benchmarks import benchmark
|
||||
|
||||
# Benchmark auf GPU
|
||||
benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
|
||||
```
|
||||
|
||||
## Argumente
|
||||
|
||||
Argumente wie `model`, `data`, `imgsz`, `half`, `device` und `verbose` bieten Benutzern die Flexibilität, die Benchmarks auf ihre spezifischen Bedürfnisse abzustimmen und die Leistung verschiedener Exportformate mühelos zu vergleichen.
|
||||
|
||||
| Schlüssel | Wert | Beschreibung |
|
||||
|-----------|---------|--------------------------------------------------------------------------------------|
|
||||
| `model` | `None` | Pfad zur Modelldatei, z. B. yolov8n.pt, yolov8n.yaml |
|
||||
| `data` | `None` | Pfad zur YAML, die das Benchmarking-Dataset referenziert (unter `val`-Kennzeichnung) |
|
||||
| `imgsz` | `640` | Bildgröße als Skalar oder Liste (h, w), z. B. (640, 480) |
|
||||
| `half` | `False` | FP16-Quantisierung |
|
||||
| `int8` | `False` | INT8-Quantisierung |
|
||||
| `device` | `None` | Gerät zum Ausführen, z. B. CUDA device=0 oder device=0,1,2,3 oder device=cpu |
|
||||
| `verbose` | `False` | bei Fehlern nicht fortsetzen (bool), oder Wertebereichsschwelle (float) |
|
||||
|
||||
## Exportformate
|
||||
|
||||
Benchmarks werden automatisch auf allen möglichen Exportformaten unten ausgeführt.
|
||||
|
||||
| Format | `format`-Argument | Modell | Metadaten | Argumente |
|
||||
|--------------------------------------------------------------------|-------------------|---------------------------|-----------|-----------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
|
||||
|
||||
Vollständige Details zum `export` finden Sie auf der [Export](https://docs.ultralytics.com/modes/export/)-Seite.
|
||||
108
docs/de/modes/export.md
Normal file
108
docs/de/modes/export.md
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
---
|
||||
comments: true
|
||||
description: Schritt-für-Schritt-Anleitung zum Exportieren Ihrer YOLOv8-Modelle in verschiedene Formate wie ONNX, TensorRT, CoreML und mehr für den Einsatz.
|
||||
keywords: YOLO, YOLOv8, Ultralytics, Modell-Export, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, Modell exportieren
|
||||
---
|
||||
|
||||
# Modell-Export mit Ultralytics YOLO
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO Ökosystem und Integrationen">
|
||||
|
||||
## Einführung
|
||||
|
||||
Das ultimative Ziel des Trainierens eines Modells besteht darin, es für reale Anwendungen einzusetzen. Der Exportmodus in Ultralytics YOLOv8 bietet eine vielseitige Palette von Optionen für den Export Ihres trainierten Modells in verschiedene Formate, sodass es auf verschiedenen Plattformen und Geräten eingesetzt werden kann. Dieser umfassende Leitfaden soll Sie durch die Nuancen des Modell-Exports führen und zeigen, wie Sie maximale Kompatibilität und Leistung erzielen können.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/WbomGeoOT_k?si=aGmuyooWftA0ue9X"
|
||||
title="YouTube-Video-Player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Ansehen:</strong> Wie man ein benutzerdefiniertes trainiertes Ultralytics YOLOv8-Modell exportiert und Live-Inferenz auf der Webcam ausführt.
|
||||
</p>
|
||||
|
||||
## Warum den Exportmodus von YOLOv8 wählen?
|
||||
|
||||
- **Vielseitigkeit:** Export in verschiedene Formate einschließlich ONNX, TensorRT, CoreML und mehr.
|
||||
- **Leistung:** Bis zu 5-fache GPU-Beschleunigung mit TensorRT und 3-fache CPU-Beschleunigung mit ONNX oder OpenVINO.
|
||||
- **Kompatibilität:** Machen Sie Ihr Modell universell einsetzbar in zahlreichen Hardware- und Softwareumgebungen.
|
||||
- **Benutzerfreundlichkeit:** Einfache CLI- und Python-API für schnellen und unkomplizierten Modell-Export.
|
||||
|
||||
### Schlüsselfunktionen des Exportmodus
|
||||
|
||||
Hier sind einige der herausragenden Funktionen:
|
||||
|
||||
- **Ein-Klick-Export:** Einfache Befehle für den Export in verschiedene Formate.
|
||||
- **Batch-Export:** Export von Modellen, die Batch-Inferenz unterstützen.
|
||||
- **Optimiertes Inferenzverhalten:** Exportierte Modelle sind für schnellere Inferenzzeiten optimiert.
|
||||
- **Tutorial-Videos:** Ausführliche Anleitungen und Tutorials für ein reibungsloses Exporterlebnis.
|
||||
|
||||
!!! tip "Tipp"
|
||||
|
||||
* Exportieren Sie nach ONNX oder OpenVINO für bis zu 3-fache CPU-Beschleunigung.
|
||||
* Exportieren Sie nach TensorRT für bis zu 5-fache GPU-Beschleunigung.
|
||||
|
||||
## Nutzungsbeispiele
|
||||
|
||||
Exportieren Sie ein YOLOv8n-Modell in ein anderes Format wie ONNX oder TensorRT. Weitere Informationen zu den Exportargumenten finden Sie im Abschnitt „Argumente“ unten.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Laden eines Modells
|
||||
model = YOLO('yolov8n.pt') # offizielles Modell laden
|
||||
model = YOLO('path/to/best.pt') # benutzerdefiniertes trainiertes Modell laden
|
||||
|
||||
# Exportieren des Modells
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n.pt format=onnx # offizielles Modell exportieren
|
||||
yolo export model=path/to/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren
|
||||
```
|
||||
|
||||
## Argumente
|
||||
|
||||
Exporteinstellungen für YOLO-Modelle beziehen sich auf verschiedene Konfigurationen und Optionen, die verwendet werden, um das Modell zu speichern oder für den Einsatz in anderen Umgebungen oder Plattformen zu exportieren. Diese Einstellungen können die Leistung, Größe und Kompatibilität des Modells mit verschiedenen Systemen beeinflussen. Zu den gängigen Exporteinstellungen von YOLO gehören das Format der exportierten Modelldatei (z. B. ONNX, TensorFlow SavedModel), das Gerät, auf dem das Modell ausgeführt wird (z. B. CPU, GPU) und das Vorhandensein zusätzlicher Funktionen wie Masken oder mehrere Labels pro Box. Andere Faktoren, die den Exportprozess beeinflussen können, sind die spezifische Aufgabe, für die das Modell verwendet wird, und die Anforderungen oder Einschränkungen der Zielumgebung oder -plattform. Es ist wichtig, diese Einstellungen sorgfältig zu berücksichtigen und zu konfigurieren, um sicherzustellen, dass das exportierte Modell für den beabsichtigten Einsatzzweck optimiert ist und in der Zielumgebung effektiv eingesetzt werden kann.
|
||||
|
||||
| Schlüssel | Wert | Beschreibung |
|
||||
|-------------|-----------------|----------------------------------------------------------|
|
||||
| `format` | `'torchscript'` | Format für den Export |
|
||||
| `imgsz` | `640` | Bildgröße als Skalar oder (h, w)-Liste, z.B. (640, 480) |
|
||||
| `keras` | `False` | Verwendung von Keras für TensorFlow SavedModel-Export |
|
||||
| `optimize` | `False` | TorchScript: Optimierung für mobile Geräte |
|
||||
| `half` | `False` | FP16-Quantisierung |
|
||||
| `int8` | `False` | INT8-Quantisierung |
|
||||
| `dynamic` | `False` | ONNX/TensorRT: dynamische Achsen |
|
||||
| `simplify` | `False` | ONNX/TensorRT: Vereinfachung des Modells |
|
||||
| `opset` | `None` | ONNX: Opset-Version (optional, Standardwert ist neueste) |
|
||||
| `workspace` | `4` | TensorRT: Arbeitsbereichgröße (GB) |
|
||||
| `nms` | `False` | CoreML: Hinzufügen von NMS |
|
||||
|
||||
## Exportformate
|
||||
|
||||
Verfügbare YOLOv8-Exportformate finden Sie in der Tabelle unten. Sie können in jedes Format exportieren, indem Sie das `format`-Argument verwenden, z. B. `format='onnx'` oder `format='engine'`.
|
||||
|
||||
| Format | `format`-Argument | Modell | Metadaten | Argumente |
|
||||
|--------------------------------------------------------------------|-------------------|---------------------------|-----------|-----------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
|
||||
74
docs/de/modes/index.md
Normal file
74
docs/de/modes/index.md
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
---
|
||||
comments: true
|
||||
description: Vom Training bis zum Tracking - Nutzen Sie YOLOv8 von Ultralytics optimal. Erhalten Sie Einblicke und Beispiele für jeden unterstützten Modus, einschließlich Validierung, Export und Benchmarking.
|
||||
keywords: Ultralytics, YOLOv8, Maschinelles Lernen, Objekterkennung, Training, Validierung, Vorhersage, Export, Tracking, Benchmarking
|
||||
---
|
||||
|
||||
# Ultralytics YOLOv8 Modi
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO-Ökosystem und Integrationen">
|
||||
|
||||
## Einführung
|
||||
|
||||
Ultralytics YOLOv8 ist nicht nur ein weiteres Objekterkennungsmodell; es ist ein vielseitiges Framework, das den gesamten Lebenszyklus von Machine-Learning-Modellen abdeckt - von der Dateneingabe und dem Modelltraining über die Validierung und Bereitstellung bis hin zum Tracking in der realen Welt. Jeder Modus dient einem bestimmten Zweck und ist darauf ausgelegt, Ihnen die Flexibilität und Effizienz zu bieten, die für verschiedene Aufgaben und Anwendungsfälle erforderlich ist.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/j8uQc0qB91s?si=dhnGKgqvs7nPgeaM"
|
||||
title="YouTube-Videoplayer" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Anschauen:</strong> Ultralytics Modi Tutorial: Trainieren, Validieren, Vorhersagen, Exportieren & Benchmarking.
|
||||
</p>
|
||||
|
||||
### Modi im Überblick
|
||||
|
||||
Das Verständnis der verschiedenen **Modi**, die Ultralytics YOLOv8 unterstützt, ist entscheidend, um das Beste aus Ihren Modellen herauszuholen:
|
||||
|
||||
- **Train**-Modus: Verfeinern Sie Ihr Modell mit angepassten oder vorgeladenen Datensätzen.
|
||||
- **Val**-Modus: Eine Nachtrainingsprüfung zur Validierung der Modellleistung.
|
||||
- **Predict**-Modus: Entfesseln Sie die Vorhersagekraft Ihres Modells mit realen Daten.
|
||||
- **Export**-Modus: Machen Sie Ihr Modell in verschiedenen Formaten einsatzbereit.
|
||||
- **Track**-Modus: Erweitern Sie Ihr Objekterkennungsmodell um Echtzeit-Tracking-Anwendungen.
|
||||
- **Benchmark**-Modus: Analysieren Sie die Geschwindigkeit und Genauigkeit Ihres Modells in verschiedenen Einsatzumgebungen.
|
||||
|
||||
Dieser umfassende Leitfaden soll Ihnen einen Überblick und praktische Einblicke in jeden Modus geben, um Ihnen zu helfen, das volle Potenzial von YOLOv8 zu nutzen.
|
||||
|
||||
## [Trainieren](train.md)
|
||||
|
||||
Der Trainingsmodus wird verwendet, um ein YOLOv8-Modell mit einem angepassten Datensatz zu trainieren. In diesem Modus wird das Modell mit dem angegebenen Datensatz und den Hyperparametern trainiert. Der Trainingsprozess beinhaltet die Optimierung der Modellparameter, damit es die Klassen und Standorte von Objekten in einem Bild genau vorhersagen kann.
|
||||
|
||||
[Trainingsbeispiele](train.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Validieren](val.md)
|
||||
|
||||
Der Validierungsmodus wird genutzt, um ein YOLOv8-Modell nach dem Training zu bewerten. In diesem Modus wird das Modell auf einem Validierungsset getestet, um seine Genauigkeit und Generalisierungsleistung zu messen. Dieser Modus kann verwendet werden, um die Hyperparameter des Modells für eine bessere Leistung zu optimieren.
|
||||
|
||||
[Validierungsbeispiele](val.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Vorhersagen](predict.md)
|
||||
|
||||
Der Vorhersagemodus wird verwendet, um mit einem trainierten YOLOv8-Modell Vorhersagen für neue Bilder oder Videos zu treffen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Benutzer kann Bilder oder Videos zur Inferenz bereitstellen. Das Modell sagt die Klassen und Standorte von Objekten in den Eingabebildern oder -videos voraus.
|
||||
|
||||
[Vorhersagebeispiele](predict.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Exportieren](export.md)
|
||||
|
||||
Der Exportmodus wird verwendet, um ein YOLOv8-Modell in ein Format zu exportieren, das für die Bereitstellung verwendet werden kann. In diesem Modus wird das Modell in ein Format konvertiert, das von anderen Softwareanwendungen oder Hardwaregeräten verwendet werden kann. Dieser Modus ist nützlich, wenn das Modell in Produktionsumgebungen eingesetzt wird.
|
||||
|
||||
[Exportbeispiele](export.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Verfolgen](track.md)
|
||||
|
||||
Der Trackingmodus wird zur Echtzeitverfolgung von Objekten mit einem YOLOv8-Modell verwendet. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Benutzer kann einen Live-Videostream für das Echtzeitobjekttracking bereitstellen. Dieser Modus ist nützlich für Anwendungen wie Überwachungssysteme oder selbstfahrende Autos.
|
||||
|
||||
[Trackingbeispiele](track.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Benchmarking](benchmark.md)
|
||||
|
||||
Der Benchmark-Modus wird verwendet, um die Geschwindigkeit und Genauigkeit verschiedener Exportformate für YOLOv8 zu profilieren. Die Benchmarks liefern Informationen über die Größe des exportierten Formats, seine `mAP50-95`-Metriken (für Objekterkennung, Segmentierung und Pose)
|
||||
oder `accuracy_top5`-Metriken (für Klassifizierung) und die Inferenzzeit in Millisekunden pro Bild für verschiedene Exportformate wie ONNX, OpenVINO, TensorRT und andere. Diese Informationen können den Benutzern dabei helfen, das optimale Exportformat für ihren spezifischen Anwendungsfall basierend auf ihren Anforderungen an Geschwindigkeit und Genauigkeit auszuwählen.
|
||||
|
||||
[Benchmarkbeispiele](benchmark.md){ .md-button .md-button--primary}
|
||||
226
docs/de/modes/predict.md
Normal file
226
docs/de/modes/predict.md
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
---
|
||||
comments: true
|
||||
description: Erkunden Sie, wie der YOLOv8-Prognosemodus für verschiedene Aufgaben verwendet werden kann. Erfahren Sie mehr über verschiedene Inferenzquellen wie Bilder, Videos und Datenformate.
|
||||
keywords: Ultralytics, YOLOv8, Vorhersagemodus, Inferenzquellen, Vorhersageaufgaben, Streaming-Modus, Bildverarbeitung, Videoverarbeitung, maschinelles Lernen, KI
|
||||
---
|
||||
|
||||
# Modellvorhersage mit Ultralytics YOLO
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO Ökosystem und Integrationen">
|
||||
|
||||
## Einführung
|
||||
|
||||
Im Bereich des maschinellen Lernens und der Computer Vision wird der Prozess des Verstehens visueller Daten als 'Inferenz' oder 'Vorhersage' bezeichnet. Ultralytics YOLOv8 bietet eine leistungsstarke Funktion, die als **Prognosemodus** bekannt ist und für eine hochleistungsfähige, echtzeitfähige Inferenz auf einer breiten Palette von Datenquellen zugeschnitten ist.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/QtsI0TnwDZs?si=ljesw75cMO2Eas14"
|
||||
title="YouTube Video Player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Anschauen:</strong> Wie man die Ausgaben vom Ultralytics YOLOv8 Modell für individuelle Projekte extrahiert.
|
||||
</p>
|
||||
|
||||
## Anwendungen in der realen Welt
|
||||
|
||||
| Herstellung | Sport | Sicherheit |
|
||||
|:---------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|
|
||||
|  |  |  |
|
||||
| Erkennung von Fahrzeugersatzteilen | Erkennung von Fußballspielern | Erkennung von stürzenden Personen |
|
||||
|
||||
## Warum Ultralytics YOLO für Inferenz nutzen?
|
||||
|
||||
Hier sind Gründe, warum Sie den Prognosemodus von YOLOv8 für Ihre verschiedenen Inferenzanforderungen in Betracht ziehen sollten:
|
||||
|
||||
- **Vielseitigkeit:** Fähig, Inferenzen auf Bilder, Videos und sogar Live-Streams zu machen.
|
||||
- **Leistung:** Entwickelt für Echtzeit-Hochgeschwindigkeitsverarbeitung ohne Genauigkeitsverlust.
|
||||
- **Einfache Bedienung:** Intuitive Python- und CLI-Schnittstellen für schnelle Einsatzbereitschaft und Tests.
|
||||
- **Hohe Anpassbarkeit:** Verschiedene Einstellungen und Parameter, um das Verhalten der Modellinferenz entsprechend Ihren spezifischen Anforderungen zu optimieren.
|
||||
|
||||
### Schlüsselfunktionen des Prognosemodus
|
||||
|
||||
Der Prognosemodus von YOLOv8 ist robust und vielseitig konzipiert und verfügt über:
|
||||
|
||||
- **Kompatibilität mit mehreren Datenquellen:** Ganz gleich, ob Ihre Daten in Form von Einzelbildern, einer Bildersammlung, Videodateien oder Echtzeit-Videostreams vorliegen, der Prognosemodus deckt alles ab.
|
||||
- **Streaming-Modus:** Nutzen Sie die Streaming-Funktion, um einen speichereffizienten Generator von `Results`-Objekten zu erzeugen. Aktivieren Sie dies, indem Sie `stream=True` in der Aufrufmethode des Predictors einstellen.
|
||||
- **Batchverarbeitung:** Die Möglichkeit, mehrere Bilder oder Videoframes in einem einzigen Batch zu verarbeiten, wodurch die Inferenzzeit weiter verkürzt wird.
|
||||
- **Integrationsfreundlich:** Dank der flexiblen API leicht in bestehende Datenpipelines und andere Softwarekomponenten zu integrieren.
|
||||
|
||||
Ultralytics YOLO-Modelle geben entweder eine Python-Liste von `Results`-Objekten zurück, oder einen speichereffizienten Python-Generator von `Results`-Objekten, wenn `stream=True` beim Inferenzvorgang an das Modell übergeben wird:
|
||||
|
||||
!!! Beispiel "Predict"
|
||||
|
||||
=== "Gibt eine Liste mit `stream=False` zurück"
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein Modell laden
|
||||
model = YOLO('yolov8n.pt') # vortrainiertes YOLOv8n Modell
|
||||
|
||||
# Batch-Inferenz auf einer Liste von Bildern ausführen
|
||||
results = model(['im1.jpg', 'im2.jpg']) # gibt eine Liste von Results-Objekten zurück
|
||||
|
||||
# Ergebnisliste verarbeiten
|
||||
for result in results:
|
||||
boxes = result.boxes # Boxes-Objekt für Bbox-Ausgaben
|
||||
masks = result.masks # Masks-Objekt für Segmentierungsmasken-Ausgaben
|
||||
keypoints = result.keypoints # Keypoints-Objekt für Pose-Ausgaben
|
||||
probs = result.probs # Probs-Objekt für Klassifizierungs-Ausgaben
|
||||
```
|
||||
|
||||
=== "Gibt einen Generator mit `stream=True` zurück"
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein Modell laden
|
||||
model = YOLO('yolov8n.pt') # vortrainiertes YOLOv8n Modell
|
||||
|
||||
# Batch-Inferenz auf einer Liste von Bildern ausführen
|
||||
results = model(['im1.jpg', 'im2.jpg'], stream=True) # gibt einen Generator von Results-Objekten zurück
|
||||
|
||||
# Generator von Ergebnissen verarbeiten
|
||||
for result in results:
|
||||
boxes = result.boxes # Boxes-Objekt für Bbox-Ausgaben
|
||||
masks = result.masks # Masks-Objekt für Segmentierungsmasken-Ausgaben
|
||||
keypoints = result.keypoints # Keypoints-Objekt für Pose-Ausgaben
|
||||
probs = result.probs # Probs-Objekt für Klassifizierungs-Ausgaben
|
||||
```
|
||||
|
||||
## Inferenzquellen
|
||||
|
||||
YOLOv8 kann verschiedene Arten von Eingabequellen für die Inferenz verarbeiten, wie in der folgenden Tabelle gezeigt. Die Quellen umfassen statische Bilder, Videostreams und verschiedene Datenformate. Die Tabelle gibt ebenfalls an, ob jede Quelle im Streaming-Modus mit dem Argument `stream=True` ✅ verwendet werden kann. Der Streaming-Modus ist vorteilhaft für die Verarbeitung von Videos oder Live-Streams, da er einen Generator von Ergebnissen statt das Laden aller Frames in den Speicher erzeugt.
|
||||
|
||||
!!! Tipp "Tipp"
|
||||
|
||||
Verwenden Sie `stream=True` für die Verarbeitung langer Videos oder großer Datensätze, um den Speicher effizient zu verwalten. Bei `stream=False` werden die Ergebnisse für alle Frames oder Datenpunkte im Speicher gehalten, was bei großen Eingaben schnell zu Speicherüberläufen führen kann. Im Gegensatz dazu verwendet `stream=True` einen Generator, der nur die Ergebnisse des aktuellen Frames oder Datenpunkts im Speicher behält, was den Speicherverbrauch erheblich reduziert und Speicherüberlaufprobleme verhindert.
|
||||
|
||||
| Quelle | Argument | Typ | Hinweise |
|
||||
|--------------------|--------------------------------------------|-------------------|------------------------------------------------------------------------------------------------|
|
||||
| Bild | `'image.jpg'` | `str` oder `Path` | Einzelbilddatei. |
|
||||
| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL zu einem Bild. |
|
||||
| Bildschirmaufnahme | `'screen'` | `str` | Eine Bildschirmaufnahme erstellen. |
|
||||
| PIL | `Image.open('im.jpg')` | `PIL.Image` | HWC-Format mit RGB-Kanälen. |
|
||||
| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | HWC-Format mit BGR-Kanälen `uint8 (0-255)`. |
|
||||
| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | HWC-Format mit BGR-Kanälen `uint8 (0-255)`. |
|
||||
| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | BCHW-Format mit RGB-Kanälen `float32 (0.0-1.0)`. |
|
||||
| CSV | `'sources.csv'` | `str` oder `Path` | CSV-Datei mit Pfaden zu Bildern, Videos oder Verzeichnissen. |
|
||||
| video ✅ | `'video.mp4'` | `str` oder `Path` | Videodatei in Formaten wie MP4, AVI, usw. |
|
||||
| Verzeichnis ✅ | `'path/'` | `str` oder `Path` | Pfad zu einem Verzeichnis mit Bildern oder Videos. |
|
||||
| glob ✅ | `'path/*.jpg'` | `str` | Glob-Muster, um mehrere Dateien zu finden. Verwenden Sie das `*` Zeichen als Platzhalter. |
|
||||
| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL zu einem YouTube-Video. |
|
||||
| stream ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL für Streaming-Protokolle wie RTSP, RTMP, TCP oder eine IP-Adresse. |
|
||||
| Multi-Stream ✅ | `'list.streams'` | `str` oder `Path` | `*.streams` Textdatei mit einer Stream-URL pro Zeile, z.B. 8 Streams laufen bei Batch-Größe 8. |
|
||||
|
||||
Untenstehend finden Sie Codebeispiele für die Verwendung jedes Quelltyps:
|
||||
|
||||
!!! Beispiel "Vorhersagequellen"
|
||||
|
||||
=== "Bild"
|
||||
Führen Sie die Inferenz auf einer Bilddatei aus.
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein vortrainiertes YOLOv8n Modell laden
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Pfad zur Bilddatei definieren
|
||||
quell = 'Pfad/zum/Bild.jpg'
|
||||
|
||||
# Inferenz auf der Quelle ausführen
|
||||
ergebnisse = model(quell) # Liste von Results-Objekten
|
||||
```
|
||||
|
||||
=== "Bildschirmaufnahme"
|
||||
Führen Sie die Inferenz auf dem aktuellen Bildschirminhalt als Screenshot aus.
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein vortrainiertes YOLOv8n Modell laden
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Aktuellen Screenshot als Quelle definieren
|
||||
quell = 'Bildschirm'
|
||||
|
||||
# Inferenz auf der Quelle ausführen
|
||||
ergebnisse = model(quell) # Liste von Results-Objekten
|
||||
```
|
||||
|
||||
=== "URL"
|
||||
Führen Sie die Inferenz auf einem Bild oder Video aus, das über eine URL remote gehostet wird.
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein vortrainiertes YOLOv8n Modell laden
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Remote-Bild- oder Video-URL definieren
|
||||
quell = 'https://ultralytics.com/images/bus.jpg'
|
||||
|
||||
# Inferenz auf der Quelle ausführen
|
||||
ergebnisse = model(quell) # Liste von Results-Objekten
|
||||
```
|
||||
|
||||
=== "PIL"
|
||||
Führen Sie die Inferenz auf einem Bild aus, das mit der Python Imaging Library (PIL) geöffnet wurde.
|
||||
```python
|
||||
from PIL import Image
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein vortrainiertes YOLOv8n Modell laden
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Ein Bild mit PIL öffnen
|
||||
quell = Image.open('Pfad/zum/Bild.jpg')
|
||||
|
||||
# Inferenz auf der Quelle ausführen
|
||||
ergebnisse = model(quell) # Liste von Results-Objekten
|
||||
```
|
||||
|
||||
=== "OpenCV"
|
||||
Führen Sie die Inferenz auf einem Bild aus, das mit OpenCV gelesen wurde.
|
||||
```python
|
||||
import cv2
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein vortrainiertes YOLOv8n Modell laden
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Ein Bild mit OpenCV lesen
|
||||
quell = cv2.imread('Pfad/zum/Bild.jpg')
|
||||
|
||||
# Inferenz auf der Quelle ausführen
|
||||
ergebnisse = model(quell) # Liste von Results-Objekten
|
||||
```
|
||||
|
||||
=== "numpy"
|
||||
Führen Sie die Inferenz auf einem Bild aus, das als numpy-Array dargestellt wird.
|
||||
```python
|
||||
import numpy as np
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein vortrainiertes YOLOv8n Modell laden
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Ein zufälliges numpy-Array der HWC-Form (640, 640, 3) mit Werten im Bereich [0, 255] und Typ uint8 erstellen
|
||||
quell = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8')
|
||||
|
||||
# Inferenz auf der Quelle ausführen
|
||||
ergebnisse = model(quell) # Liste von Results-Objekten
|
||||
```
|
||||
|
||||
=== "torch"
|
||||
Führen Sie die Inferenz auf einem Bild aus, das als PyTorch-Tensor dargestellt wird.
|
||||
```python
|
||||
import torch
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein vortrainiertes YOLOv8n Modell laden
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Ein zufälliger torch-Tensor der BCHW-Form (1, 3, 640, 640) mit Werten im Bereich [0, 1] und Typ float32 erstellen
|
||||
quell = torch.rand(1, 3, 640, 640, dtype=torch.float32)
|
||||
|
||||
# Inferenz auf der Quelle ausführen
|
||||
ergebnisse = model(quell) # Liste von Results-Objekten
|
||||
200
docs/de/modes/track.md
Normal file
200
docs/de/modes/track.md
Normal file
|
|
@ -0,0 +1,200 @@
|
|||
---
|
||||
comments: true
|
||||
description: Erfahren Sie, wie Sie Ultralytics YOLO für Objektverfolgung in Videostreams verwenden. Anleitungen zum Einsatz verschiedener Tracker und zur Anpassung von Tracker-Konfigurationen.
|
||||
keywords: Ultralytics, YOLO, Objektverfolgung, Videostreams, BoT-SORT, ByteTrack, Python-Anleitung, CLI-Anleitung
|
||||
---
|
||||
|
||||
# Multi-Objektverfolgung mit Ultralytics YOLO
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418637-1d6250fd-1515-4c10-a844-a32818ae6d46.png" alt="Beispiele für Multi-Objektverfolgung">
|
||||
|
||||
Objektverfolgung im Bereich der Videoanalytik ist eine essentielle Aufgabe, die nicht nur den Standort und die Klasse von Objekten innerhalb des Frames identifiziert, sondern auch eine eindeutige ID für jedes erkannte Objekt, während das Video fortschreitet, erhält. Die Anwendungsmöglichkeiten sind grenzenlos – von Überwachung und Sicherheit bis hin zur Echtzeitsportanalytik.
|
||||
|
||||
## Warum Ultralytics YOLO für Objektverfolgung wählen?
|
||||
|
||||
Die Ausgabe von Ultralytics Trackern ist konsistent mit der standardmäßigen Objekterkennung, bietet aber zusätzlich Objekt-IDs. Dies erleichtert das Verfolgen von Objekten in Videostreams und das Durchführen nachfolgender Analysen. Hier sind einige Gründe, warum Sie Ultralytics YOLO für Ihre Objektverfolgungsaufgaben in Betracht ziehen sollten:
|
||||
|
||||
- **Effizienz:** Verarbeitung von Videostreams in Echtzeit ohne Einbußen bei der Genauigkeit.
|
||||
- **Flexibilität:** Unterstützt mehrere Tracking-Algorithmen und -Konfigurationen.
|
||||
- **Benutzerfreundlichkeit:** Einfache Python-API und CLI-Optionen für schnelle Integration und Bereitstellung.
|
||||
- **Anpassbarkeit:** Einfache Verwendung mit individuell trainierten YOLO-Modellen, ermöglicht Integration in branchenspezifische Anwendungen.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/hHyHmOtmEgs?si=VNZtXmm45Nb9s-N-"
|
||||
title="YouTube-Videoplayer" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Ansehen:</strong> Objekterkennung und -verfolgung mit Ultralytics YOLOv8.
|
||||
</p>
|
||||
|
||||
## Anwendungen in der realen Welt
|
||||
|
||||
| Transportwesen | Einzelhandel | Aquakultur |
|
||||
|:------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------:|
|
||||
|  |  |  |
|
||||
| Fahrzeugverfolgung | Personenverfolgung | Fischverfolgung |
|
||||
|
||||
## Eigenschaften auf einen Blick
|
||||
|
||||
Ultralytics YOLO erweitert seine Objekterkennungsfunktionen, um eine robuste und vielseitige Objektverfolgung bereitzustellen:
|
||||
|
||||
- **Echtzeitverfolgung:** Nahtloses Verfolgen von Objekten in Videos mit hoher Bildfrequenz.
|
||||
- **Unterstützung mehrerer Tracker:** Auswahl aus einer Vielzahl etablierter Tracking-Algorithmen.
|
||||
- **Anpassbare Tracker-Konfigurationen:** Anpassen des Tracking-Algorithmus an spezifische Anforderungen durch Einstellung verschiedener Parameter.
|
||||
|
||||
## Verfügbare Tracker
|
||||
|
||||
Ultralytics YOLO unterstützt die folgenden Tracking-Algorithmen. Sie können aktiviert werden, indem Sie die entsprechende YAML-Konfigurationsdatei wie `tracker=tracker_type.yaml` übergeben:
|
||||
|
||||
* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Verwenden Sie `botsort.yaml`, um diesen Tracker zu aktivieren.
|
||||
* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Verwenden Sie `bytetrack.yaml`, um diesen Tracker zu aktivieren.
|
||||
|
||||
Der Standardtracker ist BoT-SORT.
|
||||
|
||||
## Verfolgung
|
||||
|
||||
Um den Tracker auf Videostreams auszuführen, verwenden Sie ein trainiertes Erkennungs-, Segmentierungs- oder Posierungsmodell wie YOLOv8n, YOLOv8n-seg und YOLOv8n-pose.
|
||||
|
||||
!!! beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Laden Sie ein offizielles oder individuelles Modell
|
||||
model = YOLO('yolov8n.pt') # Laden Sie ein offizielles Erkennungsmodell
|
||||
model = YOLO('yolov8n-seg.pt') # Laden Sie ein offizielles Segmentierungsmodell
|
||||
model = YOLO('yolov8n-pose.pt') # Laden Sie ein offizielles Posierungsmodell
|
||||
model = YOLO('path/to/best.pt') # Laden Sie ein individuell trainiertes Modell
|
||||
|
||||
# Führen Sie die Verfolgung mit dem Modell durch
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Verfolgung mit Standardtracker
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Verfolgung mit ByteTrack-Tracker
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Führen Sie die Verfolgung mit verschiedenen Modellen über die Befehlszeilenschnittstelle durch
|
||||
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Erkennungsmodell
|
||||
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Segmentierungsmodell
|
||||
yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Posierungsmodell
|
||||
yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Individuell trainiertes Modell
|
||||
|
||||
# Verfolgung mit ByteTrack-Tracker
|
||||
yolo track model=path/to/best.pt tracker="bytetrack.yaml"
|
||||
```
|
||||
|
||||
Wie in der obigen Nutzung zu sehen ist, ist die Verfolgung für alle Detect-, Segment- und Pose-Modelle verfügbar, die auf Videos oder Streaming-Quellen ausgeführt werden.
|
||||
|
||||
## Konfiguration
|
||||
|
||||
### Tracking-Argumente
|
||||
|
||||
Die Tracking-Konfiguration teilt Eigenschaften mit dem Predict-Modus, wie `conf`, `iou` und `show`. Für weitere Konfigurationen siehe die Seite des [Predict](https://docs.ultralytics.com/modes/predict/)-Modells.
|
||||
|
||||
!!! beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Konfigurieren Sie die Tracking-Parameter und führen Sie den Tracker aus
|
||||
model = YOLO('yolov8n.pt')
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Konfigurieren Sie die Tracking-Parameter und führen Sie den Tracker über die Befehlszeilenschnittstelle aus
|
||||
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
|
||||
```
|
||||
|
||||
### Tracker-Auswahl
|
||||
|
||||
Ultralytics ermöglicht es Ihnen auch, eine modifizierte Tracker-Konfigurationsdatei zu verwenden. Hierfür kopieren Sie einfach eine Tracker-Konfigurationsdatei (zum Beispiel `custom_tracker.yaml`) von [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) und ändern jede Konfiguration (außer dem `tracker_type`), wie es Ihren Bedürfnissen entspricht.
|
||||
|
||||
!!! beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Laden Sie das Modell und führen Sie den Tracker mit einer individuellen Konfigurationsdatei aus
|
||||
model = YOLO('yolov8n.pt')
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Laden Sie das Modell und führen Sie den Tracker mit einer individuellen Konfigurationsdatei über die Befehlszeilenschnittstelle aus
|
||||
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
|
||||
```
|
||||
|
||||
Für eine umfassende Liste der Tracking-Argumente siehe die Seite [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers).
|
||||
|
||||
## Python-Beispiele
|
||||
|
||||
### Persistierende Tracks-Schleife
|
||||
|
||||
Hier ist ein Python-Skript, das OpenCV (`cv2`) und YOLOv8 verwendet, um Objektverfolgung in Videoframes durchzuführen. Dieses Skript setzt voraus, dass Sie die notwendigen Pakete (`opencv-python` und `ultralytics`) bereits installiert haben. Das Argument `persist=True` teilt dem Tracker mit, dass das aktuelle Bild oder Frame das nächste in einer Sequenz ist und Tracks aus dem vorherigen Bild im aktuellen Bild erwartet werden.
|
||||
|
||||
!!! beispiel "Streaming-For-Schleife mit Tracking"
|
||||
|
||||
```python
|
||||
import cv2
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Laden Sie das YOLOv8-Modell
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Öffnen Sie die Videodatei
|
||||
video_path = "path/to/video.mp4"
|
||||
cap = cv2.VideoCapture(video_path)
|
||||
|
||||
# Schleife durch die Videoframes
|
||||
while cap.isOpened():
|
||||
# Einen Frame aus dem Video lesen
|
||||
success, frame = cap.read()
|
||||
|
||||
if success:
|
||||
# Führen Sie YOLOv8-Tracking im Frame aus, wobei Tracks zwischen Frames beibehalten werden
|
||||
results = model.track(frame, persist=True)
|
||||
|
||||
# Visualisieren Sie die Ergebnisse im Frame
|
||||
annotated_frame = results[0].plot()
|
||||
|
||||
# Zeigen Sie den kommentierten Frame an
|
||||
cv2.imshow("YOLOv8-Tracking", annotated_frame)
|
||||
|
||||
# Beenden Sie die Schleife, wenn 'q' gedrückt wird
|
||||
if cv2.waitKey(1) & 0xFF == ord("q"):
|
||||
break
|
||||
else:
|
||||
# Beenden Sie die Schleife, wenn das Ende des Videos erreicht ist
|
||||
break
|
||||
|
||||
# Geben Sie das Videoaufnahmeobjekt frei und schließen Sie das Anzeigefenster
|
||||
cap.release()
|
||||
cv2.destroyAllWindows()
|
||||
```
|
||||
|
||||
Bitte beachten Sie die Änderung von `model(frame)` zu `model.track(frame)`, welche die Objektverfolgung anstelle der einfachen Erkennung aktiviert. Dieses modifizierte Skript führt den Tracker auf jedem Frame des Videos aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von 'q' beendet werden.
|
||||
|
||||
## Neue Tracker beisteuern
|
||||
|
||||
Sind Sie versiert in der Multi-Objektverfolgung und haben erfolgreich einen Tracking-Algorithmus mit Ultralytics YOLO implementiert oder angepasst? Wir laden Sie ein, zu unserem Trackers-Bereich in [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) beizutragen! Ihre realen Anwendungen und Lösungen könnten für Benutzer, die an Tracking-Aufgaben arbeiten, von unschätzbarem Wert sein.
|
||||
|
||||
Indem Sie zu diesem Bereich beitragen, helfen Sie, das Spektrum verfügbarer Tracking-Lösungen innerhalb des Ultralytics YOLO-Frameworks zu erweitern und fügen eine weitere Funktionsschicht für die Gemeinschaft hinzu.
|
||||
|
||||
Um Ihren Beitrag einzuleiten, sehen Sie bitte in unserem [Contributing Guide](https://docs.ultralytics.com/help/contributing) für umfassende Anweisungen zur Einreichung eines Pull Requests (PR) 🛠️. Wir sind gespannt darauf, was Sie beitragen!
|
||||
|
||||
Gemeinsam verbessern wir die Tracking-Fähigkeiten des Ultralytics YOLO-Ökosystems 🙏!
|
||||
206
docs/de/modes/train.md
Normal file
206
docs/de/modes/train.md
Normal file
|
|
@ -0,0 +1,206 @@
|
|||
---
|
||||
comments: true
|
||||
description: Schritt-für-Schritt-Leitfaden zum Trainieren von YOLOv8-Modellen mit Ultralytics YOLO, einschließlich Beispielen für Single-GPU- und Multi-GPU-Training
|
||||
keywords: Ultralytics, YOLOv8, YOLO, Objekterkennung, Trainingsmodus, benutzerdefinierter Datensatz, GPU-Training, Multi-GPU, Hyperparameter, CLI-Beispiele, Python-Beispiele
|
||||
---
|
||||
|
||||
# Modelltraining mit Ultralytics YOLO
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO Ökosystem und Integrationen">
|
||||
|
||||
## Einleitung
|
||||
|
||||
Das Training eines Deep-Learning-Modells beinhaltet das Einspeisen von Daten und die Anpassung seiner Parameter, so dass es genaue Vorhersagen treffen kann. Der Trainingsmodus in Ultralytics YOLOv8 ist für das effektive und effiziente Training von Objekterkennungsmodellen konzipiert und nutzt dabei die Fähigkeiten moderner Hardware voll aus. Dieser Leitfaden zielt darauf ab, alle Details zu vermitteln, die Sie benötigen, um mit dem Training Ihrer eigenen Modelle unter Verwendung des robusten Funktionssatzes von YOLOv8 zu beginnen.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
|
||||
title="YouTube-Videoplayer" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Video anschauen:</strong> Wie man ein YOLOv8-Modell auf Ihrem benutzerdefinierten Datensatz in Google Colab trainiert.
|
||||
</p>
|
||||
|
||||
## Warum Ultralytics YOLO für das Training wählen?
|
||||
|
||||
Hier einige überzeugende Gründe, sich für den Trainingsmodus von YOLOv8 zu entscheiden:
|
||||
|
||||
- **Effizienz:** Machen Sie das Beste aus Ihrer Hardware, egal ob Sie auf einem Single-GPU-Setup sind oder über mehrere GPUs skalieren.
|
||||
- **Vielseitigkeit:** Training auf benutzerdefinierten Datensätzen zusätzlich zu den bereits verfügbaren Datensätzen wie COCO, VOC und ImageNet.
|
||||
- **Benutzerfreundlich:** Einfache, aber leistungsstarke CLI- und Python-Schnittstellen für ein unkompliziertes Trainingserlebnis.
|
||||
- **Flexibilität der Hyperparameter:** Eine breite Palette von anpassbaren Hyperparametern, um die Modellleistung zu optimieren.
|
||||
|
||||
### Schlüsselfunktionen des Trainingsmodus
|
||||
|
||||
Die folgenden sind einige bemerkenswerte Funktionen von YOLOv8s Trainingsmodus:
|
||||
|
||||
- **Automatischer Datensatz-Download:** Standarddatensätze wie COCO, VOC und ImageNet werden bei der ersten Verwendung automatisch heruntergeladen.
|
||||
- **Multi-GPU-Unterstützung:** Skalieren Sie Ihr Training nahtlos über mehrere GPUs, um den Prozess zu beschleunigen.
|
||||
- **Konfiguration der Hyperparameter:** Die Möglichkeit zur Modifikation der Hyperparameter über YAML-Konfigurationsdateien oder CLI-Argumente.
|
||||
- **Visualisierung und Überwachung:** Echtzeit-Tracking von Trainingsmetriken und Visualisierung des Lernprozesses für bessere Einsichten.
|
||||
|
||||
!!! Tipp "Tipp"
|
||||
|
||||
* YOLOv8-Datensätze wie COCO, VOC, ImageNet und viele andere werden automatisch bei der ersten Verwendung heruntergeladen, d.h. `yolo train data=coco.yaml`
|
||||
|
||||
## Nutzungsbeispiele
|
||||
|
||||
Trainieren Sie YOLOv8n auf dem COCO128-Datensatz für 100 Epochen bei einer Bildgröße von 640. Das Trainingsgerät kann mit dem Argument `device` spezifiziert werden. Wenn kein Argument übergeben wird, wird GPU `device=0` verwendet, wenn verfügbar, sonst wird `device=cpu` verwendet. Siehe den Abschnitt Argumente unten für eine vollständige Liste der Trainingsargumente.
|
||||
|
||||
!!! Beispiel "Beispiel für Single-GPU- und CPU-Training"
|
||||
|
||||
Das Gerät wird automatisch ermittelt. Wenn eine GPU verfügbar ist, dann wird diese verwendet, sonst beginnt das Training auf der CPU.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Laden Sie ein Modell
|
||||
model = YOLO('yolov8n.yaml') # bauen Sie ein neues Modell aus YAML
|
||||
model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen für das Training)
|
||||
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # bauen Sie aus YAML und übertragen Sie Gewichte
|
||||
|
||||
# Trainieren Sie das Modell
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Bauen Sie ein neues Modell aus YAML und beginnen Sie das Training von Grund auf
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
|
||||
|
||||
# Beginnen Sie das Training von einem vortrainierten *.pt Modell
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
|
||||
# Bauen Sie ein neues Modell aus YAML, übertragen Sie vortrainierte Gewichte darauf und beginnen Sie das Training
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Multi-GPU-Training
|
||||
|
||||
Multi-GPU-Training ermöglicht eine effizientere Nutzung von verfügbaren Hardware-Ressourcen, indem die Trainingslast über mehrere GPUs verteilt wird. Diese Funktion ist über sowohl die Python-API als auch die Befehlszeilenschnittstelle verfügbar. Um das Multi-GPU-Training zu aktivieren, geben Sie die GPU-Geräte-IDs an, die Sie verwenden möchten.
|
||||
|
||||
!!! Beispiel "Beispiel für Multi-GPU-Training"
|
||||
|
||||
Um mit 2 GPUs zu trainieren, verwenden Sie die folgenden Befehle für CUDA-Geräte 0 und 1. Erweitern Sie dies bei Bedarf auf zusätzliche GPUs.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Laden Sie ein Modell
|
||||
model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen für das Training)
|
||||
|
||||
# Trainieren Sie das Modell mit 2 GPUs
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Beginnen Sie das Training von einem vortrainierten *.pt Modell unter Verwendung der GPUs 0 und 1
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
|
||||
```
|
||||
|
||||
### Apple M1- und M2-MPS-Training
|
||||
|
||||
Mit der Unterstützung für Apple M1- und M2-Chips, die in den Ultralytics YOLO-Modellen integriert ist, ist es jetzt möglich, Ihre Modelle auf Geräten zu trainieren, die das leistungsstarke Metal Performance Shaders (MPS)-Framework nutzen. MPS bietet eine leistungsstarke Methode zur Ausführung von Berechnungs- und Bildverarbeitungsaufgaben auf Apples benutzerdefinierten Siliziumchips.
|
||||
|
||||
Um das Training auf Apple M1- und M2-Chips zu ermöglichen, sollten Sie 'mps' als Ihr Gerät angeben, wenn Sie den Trainingsprozess starten. Unten ist ein Beispiel, wie Sie dies in Python und über die Befehlszeile tun könnten:
|
||||
|
||||
!!! Beispiel "MPS-Training Beispiel"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Laden Sie ein Modell
|
||||
model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen für das Training)
|
||||
|
||||
# Trainieren Sie das Modell mit 2 GPUs
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Beginnen Sie das Training von einem vortrainierten *.pt Modell unter Verwendung der GPUs 0 und 1
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
|
||||
```
|
||||
|
||||
Indem sie die Rechenleistung der M1/M2-Chips nutzen, ermöglicht dies eine effizientere Verarbeitung der Trainingsaufgaben. Für detailliertere Anleitungen und fortgeschrittene Konfigurationsoptionen beziehen Sie sich bitte auf die [PyTorch MPS-Dokumentation](https://pytorch.org/docs/stable/notes/mps.html).
|
||||
|
||||
## Protokollierung
|
||||
|
||||
Beim Training eines YOLOv8-Modells kann es wertvoll sein, die Leistung des Modells im Laufe der Zeit zu verfolgen. Hier kommt die Protokollierung ins Spiel. Ultralytics' YOLO unterstützt drei Typen von Loggern - Comet, ClearML und TensorBoard.
|
||||
|
||||
Um einen Logger zu verwenden, wählen Sie ihn aus dem Dropdown-Menü im obigen Codeausschnitt aus und führen ihn aus. Der ausgewählte Logger wird installiert und initialisiert.
|
||||
|
||||
### Comet
|
||||
|
||||
[Comet](https://www.comet.ml/site/) ist eine Plattform, die Datenwissenschaftlern und Entwicklern erlaubt, Experimente und Modelle zu verfolgen, zu vergleichen, zu erklären und zu optimieren. Es bietet Funktionen wie Echtzeitmetriken, Code-Diffs und das Verfolgen von Hyperparametern.
|
||||
|
||||
Um Comet zu verwenden:
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
# pip installieren comet_ml
|
||||
import comet_ml
|
||||
|
||||
comet_ml.init()
|
||||
```
|
||||
|
||||
Vergessen Sie nicht, sich auf der Comet-Website anzumelden und Ihren API-Schlüssel zu erhalten. Sie müssen diesen zu Ihren Umgebungsvariablen oder Ihrem Skript hinzufügen, um Ihre Experimente zu protokollieren.
|
||||
|
||||
### ClearML
|
||||
|
||||
[ClearML](https://www.clear.ml/) ist eine Open-Source-Plattform, die das Verfolgen von Experimenten automatisiert und hilft, Ressourcen effizient zu teilen. Sie ist darauf ausgelegt, Teams bei der Verwaltung, Ausführung und Reproduktion ihrer ML-Arbeiten effizienter zu unterstützen.
|
||||
|
||||
Um ClearML zu verwenden:
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
# pip installieren clearml
|
||||
import clearml
|
||||
|
||||
clearml.browser_login()
|
||||
```
|
||||
|
||||
Nach dem Ausführen dieses Skripts müssen Sie sich auf dem Browser bei Ihrem ClearML-Konto anmelden und Ihre Sitzung authentifizieren.
|
||||
|
||||
### TensorBoard
|
||||
|
||||
[TensorBoard](https://www.tensorflow.org/tensorboard) ist ein Visualisierungstoolset für TensorFlow. Es ermöglicht Ihnen, Ihren TensorFlow-Graphen zu visualisieren, quantitative Metriken über die Ausführung Ihres Graphen zu plotten und zusätzliche Daten wie Bilder zu zeigen, die durch ihn hindurchgehen.
|
||||
|
||||
Um TensorBoard in [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb) zu verwenden:
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "CLI"
|
||||
```bash
|
||||
load_ext tensorboard
|
||||
tensorboard --logdir ultralytics/runs # ersetzen Sie mit Ihrem 'runs' Verzeichnis
|
||||
```
|
||||
|
||||
Um TensorBoard lokal auszuführen, führen Sie den folgenden Befehl aus und betrachten Sie die Ergebnisse unter http://localhost:6006/.
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "CLI"
|
||||
```bash
|
||||
tensorboard --logdir ultralytics/runs # ersetzen Sie mit Ihrem 'runs' Verzeichnis
|
||||
```
|
||||
|
||||
Dies lädt TensorBoard und weist es an, das Verzeichnis zu verwenden, in dem Ihre Trainingsprotokolle gespeichert sind.
|
||||
|
||||
Nachdem Sie Ihren Logger eingerichtet haben, können Sie mit Ihrem Modelltraining fortfahren. Alle Trainingsmetriken werden automatisch in Ihrer gewählten Plattform protokolliert, und Sie können auf diese Protokolle zugreifen, um die Leistung Ihres Modells im Laufe der Zeit zu überwachen, verschiedene Modelle zu vergleichen und Bereiche für Verbesserungen zu identifizieren.
|
||||
86
docs/de/modes/val.md
Normal file
86
docs/de/modes/val.md
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
---
|
||||
comments: true
|
||||
description: Anleitung zur Validierung von YOLOv8-Modellen. Erfahren Sie, wie Sie die Leistung Ihrer YOLO-Modelle mit Validierungseinstellungen und Metriken in Python und CLI-Beispielen bewerten können.
|
||||
keywords: Ultralytics, YOLO-Dokumente, YOLOv8, Validierung, Modellbewertung, Hyperparameter, Genauigkeit, Metriken, Python, CLI
|
||||
---
|
||||
|
||||
# Modellvalidierung mit Ultralytics YOLO
|
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO-Ökosystem und Integrationen">
|
||||
|
||||
## Einführung
|
||||
|
||||
Die Validierung ist ein kritischer Schritt im Machine-Learning-Prozess, der es Ihnen ermöglicht, die Qualität Ihrer trainierten Modelle zu bewerten. Der Val-Modus in Ultralytics YOLOv8 bietet eine robuste Suite von Tools und Metriken zur Bewertung der Leistung Ihrer Objekterkennungsmodelle. Dieser Leitfaden dient als umfassende Ressource, um zu verstehen, wie Sie den Val-Modus effektiv nutzen können, um sicherzustellen, dass Ihre Modelle sowohl genau als auch zuverlässig sind.
|
||||
|
||||
## Warum mit Ultralytics YOLO validieren?
|
||||
|
||||
Hier sind die Vorteile der Verwendung des Val-Modus von YOLOv8:
|
||||
|
||||
- **Präzision:** Erhalten Sie genaue Metriken wie mAP50, mAP75 und mAP50-95, um Ihr Modell umfassend zu bewerten.
|
||||
- **Bequemlichkeit:** Nutzen Sie integrierte Funktionen, die Trainingseinstellungen speichern und so den Validierungsprozess vereinfachen.
|
||||
- **Flexibilität:** Validieren Sie Ihr Modell mit den gleichen oder verschiedenen Datensätzen und Bildgrößen.
|
||||
- **Hyperparameter-Tuning:** Verwenden Sie Validierungsmetriken, um Ihr Modell für eine bessere Leistung zu optimieren.
|
||||
|
||||
### Schlüsselfunktionen des Val-Modus
|
||||
|
||||
Dies sind die bemerkenswerten Funktionen, die der Val-Modus von YOLOv8 bietet:
|
||||
|
||||
- **Automatisierte Einstellungen:** Modelle erinnern sich an ihre Trainingskonfigurationen für eine unkomplizierte Validierung.
|
||||
- **Unterstützung mehrerer Metriken:** Bewerten Sie Ihr Modell anhand einer Reihe von Genauigkeitsmetriken.
|
||||
- **CLI- und Python-API:** Wählen Sie zwischen Befehlszeilenschnittstelle oder Python-API basierend auf Ihrer Präferenz für die Validierung.
|
||||
- **Datenkompatibilität:** Funktioniert nahtlos mit Datensätzen, die während der Trainingsphase sowie mit benutzerdefinierten Datensätzen verwendet wurden.
|
||||
|
||||
!!! tip "Tipp"
|
||||
|
||||
* YOLOv8-Modelle speichern automatisch ihre Trainingseinstellungen, sodass Sie ein Modell mit der gleichen Bildgröße und dem ursprünglichen Datensatz leicht validieren können, indem Sie einfach `yolo val model=yolov8n.pt` oder `model('yolov8n.pt').val()` ausführen
|
||||
|
||||
## Beispielverwendung
|
||||
|
||||
Validieren Sie die Genauigkeit des trainierten YOLOv8n-Modells auf dem COCO128-Datensatz. Es muss kein Argument übergeben werden, da das `model` seine Trainings-`data` und Argumente als Modellattribute speichert. Siehe Abschnitt „Argumente“ unten für eine vollständige Liste der Exportargumente.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n.pt') # ein offizielles Modell laden
|
||||
model = YOLO('path/to/best.pt') # ein benutzerdefiniertes Modell laden
|
||||
|
||||
# Modell validieren
|
||||
metrics = model.val() # keine Argumente benötigt, Datensatz und Einstellungen gespeichert
|
||||
metrics.box.map # map50-95
|
||||
metrics.box.map50 # map50
|
||||
metrics.box.map75 # map75
|
||||
metrics.box.maps # eine Liste enthält map50-95 jeder Kategorie
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect val model=yolov8n.pt # offizielles Modell validieren
|
||||
yolo detect val model=path/to/best.pt # benutzerdefiniertes Modell validieren
|
||||
```
|
||||
|
||||
## Argumente
|
||||
|
||||
Validierungseinstellungen für YOLO-Modelle beziehen sich auf verschiedene Hyperparameter und Konfigurationen, die verwendet werden, um die Leistung des Modells an einem Validierungsdatensatz zu bewerten. Diese Einstellungen können die Leistung, Geschwindigkeit und Genauigkeit des Modells beeinflussen. Einige gängige YOLO-Validierungseinstellungen umfassen die Batch-Größe, die Häufigkeit der Validierung während des Trainings und die Metriken zur Bewertung der Modellleistung. Andere Faktoren, die den Validierungsprozess beeinflussen können, sind die Größe und Zusammensetzung des Validierungsdatensatzes und die spezifische Aufgabe, für die das Modell verwendet wird. Es ist wichtig, diese Einstellungen sorgfältig abzustimmen und zu experimentieren, um sicherzustellen, dass das Modell auf dem Validierungsdatensatz gut funktioniert sowie Überanpassung zu erkennen und zu verhindern.
|
||||
|
||||
| Key | Value | Beschreibung |
|
||||
|---------------|---------|---------------------------------------------------------------------------------|
|
||||
| `data` | `None` | Pfad zur Datendatei, z.B. coco128.yaml |
|
||||
| `imgsz` | `640` | Größe der Eingabebilder als ganzzahlige Zahl |
|
||||
| `batch` | `16` | Anzahl der Bilder pro Batch (-1 für AutoBatch) |
|
||||
| `save_json` | `False` | Ergebnisse in JSON-Datei speichern |
|
||||
| `save_hybrid` | `False` | hybride Version der Labels speichern (Labels + zusätzliche Vorhersagen) |
|
||||
| `conf` | `0.001` | Objekterkennungsschwelle für Zuversichtlichkeit |
|
||||
| `iou` | `0.6` | Schwellenwert für IoU (Intersection over Union) für NMS |
|
||||
| `max_det` | `300` | maximale Anzahl an Vorhersagen pro Bild |
|
||||
| `half` | `True` | Halbpräzision verwenden (FP16) |
|
||||
| `device` | `None` | Gerät zur Ausführung, z.B. CUDA device=0/1/2/3 oder device=cpu |
|
||||
| `dnn` | `False` | OpenCV DNN für ONNX-Inf erenz nutzen |
|
||||
| `plots` | `False` | Diagramme während des Trainings anzeigen |
|
||||
| `rect` | `False` | rechteckige Validierung mit jeder Batch-Charge für minimale Polsterung |
|
||||
| `split` | `val` | Zu verwendende Daten-Teilmenge für Validierung, z.B. 'val', 'test' oder 'train' |
|
||||
|
|
||||
Loading…
Add table
Add a link
Reference in a new issue