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
127
docs/de/datasets/index.md
Normal file
127
docs/de/datasets/index.md
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
---
|
||||
comments: true
|
||||
description: Erkunden Sie verschiedene von Ultralytics unterstützte Computer Vision Datensätze für Objekterkennung, Segmentierung, Posenschätzung, Bildklassifizierung und Multi-Objekt-Verfolgung.
|
||||
keywords: Computer Vision, Datensätze, Ultralytics, YOLO, Objekterkennung, Instanzsegmentierung, Posenschätzung, Bildklassifizierung, Multi-Objekt-Verfolgung
|
||||
---
|
||||
|
||||
# Übersicht über Datensätze
|
||||
|
||||
Ultralytics bietet Unterstützung für verschiedene Datensätze an, um Computervisionsaufgaben wie Erkennung, Instanzsegmentierung, Posenschätzung, Klassifizierung und Verfolgung mehrerer Objekte zu erleichtern. Unten finden Sie eine Liste der wichtigsten Ultralytics-Datensätze, gefolgt von einer Zusammenfassung jeder Computervisionsaufgabe und den jeweiligen Datensätzen.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Unsere mehrsprachige Dokumentation befindet sich derzeit im Aufbau und wir arbeiten intensiv an deren Verbesserung. Vielen Dank für Ihre Geduld! 🙏
|
||||
|
||||
## [Erkennungsdatensätze](../../datasets/detect/index.md)
|
||||
|
||||
Die Objekterkennung mittels Bounding Box ist eine Computervisionstechnik, die das Erkennen und Lokalisieren von Objekten in einem Bild anhand des Zeichnens einer Bounding Box um jedes Objekt beinhaltet.
|
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md): Ein Datensatz mit 3D-Tracking- und Bewegungsvorhersagedaten aus städtischen Umgebungen mit umfassenden Annotationen.
|
||||
- [COCO](../../datasets/detect/coco.md): Ein umfangreicher Datensatz für Objekterkennung, Segmentierung und Beschreibung mit über 200.000 beschrifteten Bildern.
|
||||
- [COCO8](../../datasets/detect/coco8.md): Enthält die ersten 4 Bilder aus COCO Train und COCO Val, geeignet für schnelle Tests.
|
||||
- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Ein Datensatz mit Bildern von Weizenköpfen aus aller Welt für Objekterkennungs- und Lokalisierungsaufgaben.
|
||||
- [Objects365](../../datasets/detect/objects365.md): Ein hochwertiger, großer Datensatz für Objekterkennung mit 365 Objektkategorien und über 600.000 annotierten Bildern.
|
||||
- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Ein umfassender Datensatz von Google mit 1,7 Millionen Trainingsbildern und 42.000 Validierungsbildern.
|
||||
- [SKU-110K](../../datasets/detect/sku-110k.md): Ein Datensatz mit dichter Objekterkennung in Einzelhandelsumgebungen mit über 11.000 Bildern und 1,7 Millionen Bounding Boxen.
|
||||
- [VisDrone](../../datasets/detect/visdrone.md): Ein Datensatz mit Objekterkennungs- und Multi-Objekt-Tracking-Daten aus Drohnenaufnahmen mit über 10.000 Bildern und Videosequenzen.
|
||||
- [VOC](../../datasets/detect/voc.md): Der Pascal Visual Object Classes (VOC) Datensatz für Objekterkennung und Segmentierung mit 20 Objektklassen und über 11.000 Bildern.
|
||||
- [xView](../../datasets/detect/xview.md): Ein Datensatz für Objekterkennung in Überwachungsbildern mit 60 Objektkategorien und über 1 Million annotierten Objekten.
|
||||
|
||||
## [Datensätze für Instanzsegmentierung](../../datasets/segment/index.md)
|
||||
|
||||
Die Instanzsegmentierung ist eine Computervisionstechnik, die das Identifizieren und Lokalisieren von Objekten in einem Bild auf Pixelebene beinhaltet.
|
||||
|
||||
- [COCO](../../datasets/segment/coco.md): Ein großer Datensatz für Objekterkennung, Segmentierung und Beschreibungsaufgaben mit über 200.000 beschrifteten Bildern.
|
||||
- [COCO8-seg](../../datasets/segment/coco8-seg.md): Ein kleinerer Datensatz für Instanzsegmentierungsaufgaben, der eine Teilmenge von 8 COCO-Bildern mit Segmentierungsannotationen enthält.
|
||||
|
||||
## [Posenschätzung](../../datasets/pose/index.md)
|
||||
|
||||
Die Posenschätzung ist eine Technik, die verwendet wird, um die Position des Objekts relativ zur Kamera oder zum Weltkoordinatensystem zu bestimmen.
|
||||
|
||||
- [COCO](../../datasets/pose/coco.md): Ein großer Datensatz mit menschlichen Pose-Annotationen für Posenschätzungsaufgaben.
|
||||
- [COCO8-pose](../../datasets/pose/coco8-pose.md): Ein kleinerer Datensatz für Posenschätzungsaufgaben, der eine Teilmenge von 8 COCO-Bildern mit menschlichen Pose-Annotationen enthält.
|
||||
- [Tiger-pose](../../datasets/pose/tiger-pose.md): Ein kompakter Datensatz bestehend aus 263 Bildern, die auf Tiger fokussiert sind, mit Annotationen von 12 Schlüsselpunkten pro Tiger für Posenschätzungsaufgaben.
|
||||
|
||||
## [Bildklassifizierung](../../datasets/classify/index.md)
|
||||
|
||||
Die Bildklassifizierung ist eine Computervisionsaufgabe, bei der ein Bild basierend auf seinem visuellen Inhalt in eine oder mehrere vordefinierte Klassen oder Kategorien eingeteilt wird.
|
||||
|
||||
- [Caltech 101](../../datasets/classify/caltech101.md): Enthält Bilder von 101 Objektkategorien für Bildklassifizierungsaufgaben.
|
||||
- [Caltech 256](../../datasets/classify/caltech256.md): Eine erweiterte Version von Caltech 101 mit 256 Objektkategorien und herausfordernderen Bildern.
|
||||
- [CIFAR-10](../../datasets/classify/cifar10.md): Ein Datensatz mit 60.000 32x32 Farbbildern in 10 Klassen, mit 6.000 Bildern pro Klasse.
|
||||
- [CIFAR-100](../../datasets/classify/cifar100.md): Eine erweiterte Version von CIFAR-10 mit 100 Objektkategorien und 600 Bildern pro Klasse.
|
||||
- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Ein Datensatz mit 70.000 Graustufenbildern von 10 Modekategorien für Bildklassifizierungsaufgaben.
|
||||
- [ImageNet](../../datasets/classify/imagenet.md): Ein großer Datensatz für Objekterkennung und Bildklassifizierung mit über 14 Millionen Bildern und 20.000 Kategorien.
|
||||
- [ImageNet-10](../../datasets/classify/imagenet10.md): Ein kleinerer Teildatensatz von ImageNet mit 10 Kategorien für schnelleres Experimentieren und Testen.
|
||||
- [Imagenette](../../datasets/classify/imagenette.md): Ein kleinerer Teildatensatz von ImageNet, der 10 leicht unterscheidbare Klassen für ein schnelleres Training und Testen enthält.
|
||||
- [Imagewoof](../../datasets/classify/imagewoof.md): Ein herausfordernderer Teildatensatz von ImageNet mit 10 Hundezuchtkategorien für Bildklassifizierungsaufgaben.
|
||||
- [MNIST](../../datasets/classify/mnist.md): Ein Datensatz mit 70.000 Graustufenbildern von handgeschriebenen Ziffern für Bildklassifizierungsaufgaben.
|
||||
|
||||
## [Orientierte Bounding Boxes (OBB)](../../datasets/obb/index.md)
|
||||
|
||||
Orientierte Bounding Boxes (OBB) ist eine Methode in der Computervision für die Erkennung von geneigten Objekten in Bildern mithilfe von rotierten Bounding Boxen, die oft auf Luft- und Satellitenbilder angewendet wird.
|
||||
|
||||
- [DOTAv2](../../datasets/obb/dota-v2.md): Ein beliebter OBB-Datensatz für Luftbildaufnahmen mit 1,7 Millionen Instanzen und 11.268 Bildern.
|
||||
|
||||
## [Multi-Objekt-Verfolgung](../../datasets/track/index.md)
|
||||
|
||||
Die Verfolgung mehrerer Objekte ist eine Computervisionstechnik, die das Erkennen und Verfolgen mehrerer Objekte über die Zeit in einer Videosequenz beinhaltet.
|
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md): Ein Datensatz mit 3D-Tracking- und Bewegungsvorhersagedaten aus städtischen Umgebungen mit umfassenden Annotationen für Multi-Objekt-Verfolgungsaufgaben.
|
||||
- [VisDrone](../../datasets/detect/visdrone.md): Ein Datensatz mit Daten zur Objekterkennung und Multi-Objekt-Verfolgung aus Drohnenaufnahmen mit über 10.000 Bildern und Videosequenzen.
|
||||
|
||||
## Neue Datensätze beitragen
|
||||
|
||||
Das Bereitstellen eines neuen Datensatzes umfasst mehrere Schritte, um sicherzustellen, dass er gut in die bestehende Infrastruktur integriert werden kann. Unten finden Sie die notwendigen Schritte:
|
||||
|
||||
### Schritte um einen neuen Datensatz beizutragen
|
||||
|
||||
1. **Bilder sammeln**: Sammeln Sie die Bilder, die zum Datensatz gehören. Diese können von verschiedenen Quellen gesammelt werden, wie öffentlichen Datenbanken oder Ihrer eigenen Sammlung.
|
||||
|
||||
2. **Bilder annotieren**: Annotieren Sie diese Bilder mit Bounding Boxen, Segmenten oder Schlüsselpunkten, je nach Aufgabe.
|
||||
|
||||
3. **Annotationen exportieren**: Konvertieren Sie diese Annotationen in das von Ultralytics unterstützte YOLO *.txt-Dateiformat.
|
||||
|
||||
4. **Datensatz organisieren**: Ordnen Sie Ihren Datensatz in die richtige Ordnerstruktur an. Sie sollten übergeordnete Verzeichnisse `train/` und `val/` haben, und innerhalb dieser je ein Unterverzeichnis `images/` und `labels/`.
|
||||
|
||||
```
|
||||
dataset/
|
||||
├── train/
|
||||
│ ├── images/
|
||||
│ └── labels/
|
||||
└── val/
|
||||
├── images/
|
||||
└── labels/
|
||||
```
|
||||
|
||||
5. **Eine `data.yaml`-Datei erstellen**: Erstellen Sie in Ihrem Stammverzeichnis des Datensatzes eine Datei `data.yaml`, die den Datensatz, die Klassen und andere notwendige Informationen beschreibt.
|
||||
|
||||
6. **Bilder optimieren (Optional)**: Wenn Sie die Größe des Datensatzes für eine effizientere Verarbeitung reduzieren möchten, können Sie die Bilder mit dem untenstehenden Code optimieren. Dies ist nicht erforderlich, wird aber für kleinere Datensatzgrößen und schnellere Download-Geschwindigkeiten empfohlen.
|
||||
|
||||
7. **Datensatz zippen**: Komprimieren Sie das gesamte Datensatzverzeichnis in eine Zip-Datei.
|
||||
|
||||
8. **Dokumentation und PR**: Erstellen Sie eine Dokumentationsseite, die Ihren Datensatz beschreibt und wie er in das bestehende Framework passt. Danach reichen Sie einen Pull Request (PR) ein. Weitere Details zur Einreichung eines PR finden Sie in den [Ultralytics Beitragshinweisen](https://docs.ultralytics.com/help/contributing).
|
||||
|
||||
### Beispielcode zum Optimieren und Zippen eines Datensatzes
|
||||
|
||||
!!! example "Optimieren und Zippen eines Datensatzes"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from pathlib import Path
|
||||
from ultralytics.data.utils import compress_one_image
|
||||
from ultralytics.utils.downloads import zip_directory
|
||||
|
||||
# Definieren des Verzeichnisses des Datensatzes
|
||||
path = Path('Pfad/zum/Datensatz')
|
||||
|
||||
# Bilder im Datensatz optimieren (optional)
|
||||
for f in path.rglob('*.jpg'):
|
||||
compress_one_image(f)
|
||||
|
||||
# Datensatz in 'Pfad/zum/Datensatz.zip' zippen
|
||||
zip_directory(path)
|
||||
```
|
||||
|
||||
Indem Sie diesen Schritten folgen, können Sie einen neuen Datensatz beitragen, der gut in die bestehende Struktur von Ultralytics integriert wird.
|
||||
82
docs/de/index.md
Normal file
82
docs/de/index.md
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
---
|
||||
comments: true
|
||||
description: Entdecken Sie einen vollständigen Leitfaden zu Ultralytics YOLOv8, einem schnellen und präzisen Modell zur Objekterkennung und Bildsegmentierung. Installations-, Vorhersage-, Trainingstutorials und mehr.
|
||||
keywords: Ultralytics, YOLOv8, Objekterkennung, Bildsegmentierung, maschinelles Lernen, Deep Learning, Computer Vision, YOLOv8 Installation, YOLOv8 Vorhersage, YOLOv8 Training, YOLO-Geschichte, YOLO-Lizenzen
|
||||
---
|
||||
|
||||
<div align="center">
|
||||
<p>
|
||||
<a href="https://yolovision.ultralytics.com" target="_blank">
|
||||
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Ultralytics YOLO Banner"></a>
|
||||
</p>
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://youtube.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Ultralytics Instagram"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
|
||||
<br>
|
||||
<br>
|
||||
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml/badge.svg" alt="Ultralytics CI"></a>
|
||||
<a href="https://codecov.io/github/ultralytics/ultralytics"><img src="https://codecov.io/github/ultralytics/ultralytics/branch/main/graph/badge.svg?token=HHW7IIVFVY" alt="Ultralytics Code Coverage"></a>
|
||||
<a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="YOLOv8 Zitation"></a>
|
||||
<a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Docker Ziehungen"></a>
|
||||
<br>
|
||||
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Auf Gradient ausführen"/></a>
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="In Colab öffnen"></a>
|
||||
<a href="https://www.kaggle.com/ultralytics/yolov8"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="In Kaggle öffnen"></a>
|
||||
</div>
|
||||
|
||||
Wir stellen [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics) vor, die neueste Version des renommierten Echtzeit-Modells zur Objekterkennung und Bildsegmentierung. YOLOv8 basiert auf den neuesten Erkenntnissen im Bereich Deep Learning und Computer Vision und bietet eine unvergleichliche Leistung hinsichtlich Geschwindigkeit und Genauigkeit. Sein optimiertes Design macht es für verschiedene Anwendungen geeignet und leicht an verschiedene Hardwareplattformen anpassbar, von Edge-Geräten bis hin zu Cloud-APIs.
|
||||
|
||||
Erkunden Sie die YOLOv8-Dokumentation, eine umfassende Ressource, die Ihnen helfen soll, seine Funktionen und Fähigkeiten zu verstehen und zu nutzen. Ob Sie ein erfahrener Machine-Learning-Praktiker sind oder neu in diesem Bereich, dieses Hub zielt darauf ab, das Potenzial von YOLOv8 in Ihren Projekten zu maximieren
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Unsere mehrsprachige Dokumentation wird derzeit entwickelt und wir arbeiten intensiv an ihrer Verbesserung. Wir danken für Ihre Geduld! 🙏
|
||||
|
||||
## Wo Sie beginnen sollten
|
||||
|
||||
- **Installieren** Sie `ultralytics` mit pip und starten Sie in wenigen Minuten [:material-clock-fast: Loslegen](quickstart.md){ .md-button }
|
||||
- **Vorhersagen** Sie neue Bilder und Videos mit YOLOv8 [:octicons-image-16: Auf Bilder vorhersagen](modes/predict.md){ .md-button }
|
||||
- **Trainieren** Sie ein neues YOLOv8-Modell mit Ihrem eigenen benutzerdefinierten Datensatz [:fontawesome-solid-brain: Ein Modell trainieren](modes/train.md){ .md-button }
|
||||
- **Erforschen** Sie YOLOv8-Aufgaben wie Segmentieren, Klassifizieren, Posenschätzung und Verfolgen [:material-magnify-expand: Aufgaben erkunden](tasks/index.md){ .md-button }
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
|
||||
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 Sie ein YOLOv8-Modell auf Ihrem eigenen Datensatz in <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb" target="_blank">Google Colab</a> trainieren.
|
||||
</p>
|
||||
|
||||
## YOLO: Eine kurze Geschichte
|
||||
|
||||
[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), ein beliebtes Modell zur Objekterkennung und Bildsegmentierung, wurde von Joseph Redmon und Ali Farhadi an der Universität von Washington entwickelt. Seit seiner Einführung im Jahr 2015 erfreut es sich aufgrund seiner hohen Geschwindigkeit und Genauigkeit großer Beliebtheit.
|
||||
|
||||
- [YOLOv2](https://arxiv.org/abs/1612.08242), veröffentlicht im Jahr 2016, verbesserte das Originalmodell durch die Einführung von Batch-Normalisierung, Ankerkästen und Dimensionsclustern.
|
||||
- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), eingeführt im Jahr 2018, erhöhte die Leistung des Modells weiter mit einem effizienteren Backbone-Netzwerk, mehreren Ankern und räumlichem Pyramid-Pooling.
|
||||
- [YOLOv4](https://arxiv.org/abs/2004.10934) wurde 2020 veröffentlicht und brachte Neuerungen wie Mosaic-Datenerweiterung, einen neuen ankerfreien Erkennungskopf und eine neue Verlustfunktion.
|
||||
- [YOLOv5](https://github.com/ultralytics/yolov5) verbesserte die Leistung des Modells weiter und führte neue Funktionen ein, wie Hyperparameter-Optimierung, integriertes Experiment-Tracking und automatischen Export in beliebte Exportformate.
|
||||
- [YOLOv6](https://github.com/meituan/YOLOv6) wurde 2022 von [Meituan](https://about.meituan.com/) als Open Source zur Verfügung gestellt und wird in vielen autonomen Lieferrobotern des Unternehmens eingesetzt.
|
||||
- [YOLOv7](https://github.com/WongKinYiu/yolov7) führte zusätzliche Aufgaben ein, wie Posenschätzung auf dem COCO-Keypoints-Datensatz.
|
||||
- [YOLOv8](https://github.com/ultralytics/ultralytics) ist die neueste Version von YOLO von Ultralytics. Als Spitzenmodell der neuesten Generation baut YOLOv8 auf dem Erfolg vorheriger Versionen auf und führt neue Funktionen und Verbesserungen für erhöhte Leistung, Flexibilität und Effizienz ein. YOLOv8 unterstützt eine vollständige Palette an Vision-KI-Aufgaben, einschließlich [Erkennung](tasks/detect.md), [Segmentierung](tasks/segment.md), [Posenschätzung](tasks/pose.md), [Verfolgung](modes/track.md) und [Klassifizierung](tasks/classify.md). Diese Vielseitigkeit ermöglicht es Benutzern, die Fähigkeiten von YOLOv8 in verschiedenen Anwendungen und Domänen zu nutzen.
|
||||
|
||||
## YOLO-Lizenzen: Wie wird Ultralytics YOLO lizenziert?
|
||||
|
||||
Ultralytics bietet zwei Lizenzoptionen, um unterschiedliche Einsatzszenarien zu berücksichtigen:
|
||||
|
||||
- **AGPL-3.0-Lizenz**: Diese [OSI-geprüfte](https://opensource.org/licenses/) Open-Source-Lizenz ist ideal für Studenten und Enthusiasten und fördert offene Zusammenarbeit und Wissensaustausch. Weitere Details finden Sie in der [LIZENZ](https://github.com/ultralytics/ultralytics/blob/main/LICENSE)-Datei.
|
||||
- **Enterprise-Lizenz**: Für die kommerzielle Nutzung konzipiert, ermöglicht diese Lizenz die problemlose Integration von Ultralytics-Software und KI-Modellen in kommerzielle Produkte und Dienstleistungen und umgeht die Open-Source-Anforderungen der AGPL-3.0. Wenn Ihr Szenario die Einbettung unserer Lösungen in ein kommerzielles Angebot beinhaltet, kontaktieren Sie uns über [Ultralytics-Lizenzierung](https://ultralytics.com/license).
|
||||
|
||||
Unsere Lizenzstrategie ist darauf ausgerichtet sicherzustellen, dass jegliche Verbesserungen an unseren Open-Source-Projekten der Gemeinschaft zurückgegeben werden. Wir halten die Prinzipien von Open Source in Ehren ❤️ und es ist unser Anliegen, dass unsere Beiträge auf Weisen genutzt und erweitert werden können, die für alle vorteilhaft sind.
|
||||
94
docs/de/models/index.md
Normal file
94
docs/de/models/index.md
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
---
|
||||
comments: true
|
||||
description: Entdecken Sie die Vielfalt der von Ultralytics unterstützten Modelle der YOLO-Familie, SAM, MobileSAM, FastSAM, YOLO-NAS und RT-DETR Modelle. Beginnen Sie mit Beispielen für die Verwendung in CLI und Python.
|
||||
keywords: Ultralytics, Dokumentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, Modelle, Architekturen, Python, CLI
|
||||
---
|
||||
|
||||
# Von Ultralytics unterstützte Modelle
|
||||
|
||||
Willkommen in der Modell-Dokumentation von Ultralytics! Wir bieten Unterstützung für eine breite Palette von Modellen, die für spezifische Aufgaben wie [Objekterkennung](../tasks/detect.md), [Instanzsegmentierung](../tasks/segment.md), [Bildklassifizierung](../tasks/classify.md), [Poseerkennung](../tasks/pose.md) und [Multi-Objekt-Tracking](../modes/track.md) zugeschnitten sind. Wenn Sie daran interessiert sind, Ihre Modellarchitektur an Ultralytics beizutragen, werfen Sie einen Blick auf unseren [Beitragenden-Leitfaden](../../help/contributing.md).
|
||||
|
||||
!!! Hinweis
|
||||
|
||||
🚧 Unsere mehrsprachige Dokumentation befindet sich derzeit im Aufbau, und wir arbeiten hart daran, sie zu verbessern. Vielen Dank für Ihre Geduld! 🙏
|
||||
|
||||
## Vorgestellte Modelle
|
||||
|
||||
Hier sind einige der wesentlichen unterstützten Modelle:
|
||||
|
||||
1. **[YOLOv3](../../models/yolov3.md)**: Die dritte Iteration der YOLO-Modellfamilie, ursprünglich von Joseph Redmon entwickelt und bekannt für ihre effiziente Echtzeit-Objekterkennung.
|
||||
2. **[YOLOv4](../../models/yolov4.md)**: Eine darknet-native Aktualisierung von YOLOv3, die 2020 von Alexey Bochkovskiy veröffentlicht wurde.
|
||||
3. **[YOLOv5](../../models/yolov5.md)**: Eine verbesserte Version der YOLO-Architektur von Ultralytics, die im Vergleich zu früheren Versionen bessere Leistungs- und Geschwindigkeitstrade-offs bietet.
|
||||
4. **[YOLOv6](../../models/yolov6.md)**: Im Jahr 2022 von [Meituan](https://about.meituan.com/) veröffentlicht und in vielen autonomen Zustellrobotern des Unternehmens verwendet.
|
||||
5. **[YOLOv7](../../models/yolov7.md)**: Im Jahr 2022 von den Autoren von YOLOv4 aktualisierte YOLO-Modelle.
|
||||
6. **[YOLOv8](../../models/yolov8.md)**: Die neueste Version der YOLO-Familie mit erweiterten Fähigkeiten wie Instanzsegmentierung, Pose-/Schlüsselpunktschätzung und Klassifizierung.
|
||||
7. **[Segment Anything Model (SAM)](../../models/sam.md)**: Metas Segment Anything Model (SAM).
|
||||
8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)**: MobileSAM für mobile Anwendungen von der Kyung Hee Universität.
|
||||
9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)**: FastSAM von der Bild- und Videoanalysegruppe des Instituts für Automatisierung, Chinesische Akademie der Wissenschaften.
|
||||
10. **[YOLO-NAS](../../models/yolo-nas.md)**: YOLO Neural Architecture Search (NAS) Modelle.
|
||||
11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)**: Baidus PaddlePaddle Realtime Detection Transformer (RT-DETR) Modelle.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/MWq1UxqTClU?si=nHAW-lYDzrz68jR0"
|
||||
title="YouTube-Video-Player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Sehen Sie:</strong> Ultralytics YOLO-Modelle in nur wenigen Zeilen Code ausführen.
|
||||
</p>
|
||||
|
||||
## Erste Schritte: Anwendungsbeispiele
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
PyTorch vortrainierte `*.pt` Modelle sowie Konfigurations-`*.yaml` Dateien können den Klassen `YOLO()`, `SAM()`, `NAS()` und `RTDETR()` übergeben werden, um in Python eine Modellinstanz zu erstellen:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Laden eines auf COCO vortrainierten YOLOv8n-Modells
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Modellinformationen anzeigen (optional)
|
||||
model.info()
|
||||
|
||||
# Das Modell mit dem COCO8-Beispieldatensatz für 100 Epochen trainieren
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Inferenz mit dem YOLOv8n-Modell am Bild 'bus.jpg' durchführen
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
CLI-Befehle sind verfügbar, um die Modelle direkt auszuführen:
|
||||
|
||||
```bash
|
||||
# Laden eines auf COCO vortrainierten YOLOv8n-Modells und Trainieren auf dem COCO8-Beispieldatensatz für 100 Epochen
|
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Laden eines auf COCO vortrainierten YOLOv8n-Modells und Durchführung der Inferenz am Bild 'bus.jpg'
|
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Neue Modelle beitragen
|
||||
|
||||
Interessiert, Ihr Modell bei Ultralytics beizutragen? Großartig! Wir sind immer offen, unser Modellportfolio zu erweitern.
|
||||
|
||||
1. **Das Repository forken**: Beginnen Sie damit, das [GitHub-Repository von Ultralytics](https://github.com/ultralytics/ultralytics) zu forken.
|
||||
|
||||
2. **Ihren Fork klonen**: Klonen Sie Ihren Fork auf Ihre lokale Maschine und erstellen Sie einen neuen Branch, um daran zu arbeiten.
|
||||
|
||||
3. **Ihr Modell implementieren**: Fügen Sie Ihr Modell gemäß den in unserem [Beitragenden-Leitfaden](../../help/contributing.md) bereitgestellten Codierstandards und Richtlinien hinzu.
|
||||
|
||||
4. **Gründlich testen**: Stellen Sie sicher, dass Sie Ihr Modell sowohl isoliert als auch als Teil der Pipeline rigoros testen.
|
||||
|
||||
5. **Einen Pull Request erstellen**: Wenn Sie mit Ihrem Modell zufrieden sind, erstellen Sie einen Pull Request zum Hauptrepository zur Überprüfung.
|
||||
|
||||
6. **Code-Überprüfung und Merging**: Nach der Überprüfung wird Ihr Modell, wenn es unseren Kriterien entspricht, in das Hauptrepository übernommen.
|
||||
|
||||
Für detaillierte Schritte konsultieren Sie unseren [Beitragenden-Leitfaden](../../help/contributing.md).
|
||||
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' |
|
||||
|
|
||||
187
docs/de/quickstart.md
Normal file
187
docs/de/quickstart.md
Normal file
|
|
@ -0,0 +1,187 @@
|
|||
---
|
||||
comments: true
|
||||
description: Entdecken Sie verschiedene Methoden zur Installation von Ultralytics mit Pip, Conda, Git und Docker. Erfahren Sie, wie Sie Ultralytics über die Befehlszeilenschnittstelle oder innerhalb Ihrer Python-Projekte verwenden können.
|
||||
keywords: Ultralytics-Installation, pip installieren Ultralytics, Docker installieren Ultralytics, Ultralytics-Befehlszeilenschnittstelle, Ultralytics Python-Schnittstelle
|
||||
---
|
||||
|
||||
## Ultralytics installieren
|
||||
|
||||
Ultralytics bietet verschiedene Installationsmethoden, darunter Pip, Conda und Docker. Installiere YOLOv8 über das `ultralytics` Pip-Paket für die neueste stabile Veröffentlichung oder indem du das [Ultralytics GitHub-Repository](https://github.com/ultralytics/ultralytics) klonst für die aktuellste Version. Docker kann verwendet werden, um das Paket in einem isolierten Container auszuführen, ohne eine lokale Installation vornehmen zu müssen.
|
||||
|
||||
!!! Beispiel "Installieren"
|
||||
|
||||
=== "Pip-Installation (empfohlen)"
|
||||
Installieren Sie das `ultralytics` Paket mit Pip oder aktualisieren Sie eine bestehende Installation, indem Sie `pip install -U ultralytics` ausführen. Besuchen Sie den Python Package Index (PyPI) für weitere Details zum `ultralytics` Paket: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
|
||||
|
||||
[](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/project/ultralytics)
|
||||
|
||||
```bash
|
||||
# Installiere das ultralytics Paket von PyPI
|
||||
pip install ultralytics
|
||||
```
|
||||
|
||||
Sie können auch das `ultralytics` Paket direkt vom GitHub [Repository](https://github.com/ultralytics/ultralytics) installieren. Dies könnte nützlich sein, wenn Sie die neueste Entwicklerversion möchten. Stellen Sie sicher, dass das Git-Kommandozeilen-Tool auf Ihrem System installiert ist. Der Befehl `@main` installiert den `main` Branch und kann zu einem anderen Branch geändert werden, z. B. `@my-branch`, oder ganz entfernt werden, um auf den `main` Branch standardmäßig zurückzugreifen.
|
||||
|
||||
```bash
|
||||
# Installiere das ultralytics Paket von GitHub
|
||||
pip install git+https://github.com/ultralytics/ultralytics.git@main
|
||||
```
|
||||
|
||||
|
||||
=== "Conda-Installation"
|
||||
Conda ist ein alternativer Paketmanager zu Pip, der ebenfalls für die Installation verwendet werden kann. Besuche Anaconda für weitere Details unter [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Ultralytics Feedstock Repository für die Aktualisierung des Conda-Pakets befindet sich unter [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
|
||||
|
||||
|
||||
[](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics)
|
||||
|
||||
```bash
|
||||
# Installiere das ultralytics Paket mit Conda
|
||||
conda install -c conda-forge ultralytics
|
||||
```
|
||||
|
||||
!!! Hinweis
|
||||
|
||||
Wenn Sie in einer CUDA-Umgebung installieren, ist es am besten, `ultralytics`, `pytorch` und `pytorch-cuda` im selben Befehl zu installieren, um dem Conda-Paketmanager zu ermöglichen, Konflikte zu lösen, oder `pytorch-cuda` als letztes zu installieren, damit es das CPU-spezifische `pytorch` Paket bei Bedarf überschreiben kann.
|
||||
```bash
|
||||
# Installiere alle Pakete zusammen mit Conda
|
||||
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
|
||||
```
|
||||
|
||||
### Conda Docker-Image
|
||||
|
||||
Ultralytics Conda Docker-Images sind ebenfalls von [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics) verfügbar. Diese Bilder basieren auf [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) und bieten eine einfache Möglichkeit, `ultralytics` in einer Conda-Umgebung zu nutzen.
|
||||
|
||||
```bash
|
||||
# Setze Image-Name als Variable
|
||||
t=ultralytics/ultralytics:latest-conda
|
||||
|
||||
# Ziehe das neuste ultralytics Image von Docker Hub
|
||||
sudo docker pull $t
|
||||
|
||||
# Führe das ultralytics Image in einem Container mit GPU-Unterstützung aus
|
||||
sudo docker run -it --ipc=host --gpus all $t # alle GPUs
|
||||
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # spezifische GPUs angeben
|
||||
```
|
||||
|
||||
=== "Git klonen"
|
||||
Klonen Sie das `ultralytics` Repository, wenn Sie einen Beitrag zur Entwicklung leisten möchten oder mit dem neuesten Quellcode experimentieren wollen. Nach dem Klonen navigieren Sie in das Verzeichnis und installieren das Paket im editierbaren Modus `-e` mit Pip.
|
||||
```bash
|
||||
# Klonen Sie das ultralytics Repository
|
||||
git clone https://github.com/ultralytics/ultralytics
|
||||
|
||||
# Navigiere zum geklonten Verzeichnis
|
||||
cd ultralytics
|
||||
|
||||
# Installiere das Paket im editierbaren Modus für die Entwicklung
|
||||
pip install -e .
|
||||
```
|
||||
|
||||
Siehe die `ultralytics` [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) Datei für eine Liste der Abhängigkeiten. Beachten Sie, dass alle oben genannten Beispiele alle erforderlichen Abhängigkeiten installieren.
|
||||
|
||||
!!! Tipp "Tipp"
|
||||
|
||||
PyTorch-Anforderungen variieren je nach Betriebssystem und CUDA-Anforderungen, daher wird empfohlen, PyTorch zuerst gemäß den Anweisungen unter [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally) zu installieren.
|
||||
|
||||
<a href="https://pytorch.org/get-started/locally/">
|
||||
<img width="800" alt="PyTorch Installationsanweisungen" src="https://user-images.githubusercontent.com/26833433/228650108-ab0ec98a-b328-4f40-a40d-95355e8a84e3.png">
|
||||
</a>
|
||||
|
||||
## Ultralytics mit CLI verwenden
|
||||
|
||||
Die Befehlszeilenschnittstelle (CLI) von Ultralytics ermöglicht einfache Einzeilige Befehle ohne die Notwendigkeit einer Python-Umgebung. CLI erfordert keine Anpassung oder Python-Code. Sie können alle Aufgaben einfach vom Terminal aus mit dem `yolo` Befehl ausführen. Schauen Sie sich den [CLI-Leitfaden](../usage/cli.md) an, um mehr über die Verwendung von YOLOv8 über die Befehlszeile zu erfahren.
|
||||
|
||||
!!! Beispiel
|
||||
|
||||
=== "Syntax"
|
||||
|
||||
Ultralytics `yolo` Befehle verwenden die folgende Syntax:
|
||||
```bash
|
||||
yolo TASK MODE ARGS
|
||||
|
||||
Wo TASK (optional) einer von [detect, segment, classify] ist
|
||||
MODE (erforderlich) einer von [train, val, predict, export, track] ist
|
||||
ARGS (optional) eine beliebige Anzahl von benutzerdefinierten 'arg=value' Paaren wie 'imgsz=320', die Vorgaben überschreiben.
|
||||
```
|
||||
Sehen Sie alle ARGS im vollständigen [Konfigurationsleitfaden](../usage/cfg.md) oder mit `yolo cfg`
|
||||
|
||||
=== "Trainieren"
|
||||
|
||||
Trainieren Sie ein Erkennungsmodell für 10 Epochen mit einer Anfangslernerate von 0.01
|
||||
```bash
|
||||
yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
|
||||
```
|
||||
|
||||
=== "Vorhersagen"
|
||||
|
||||
Vorhersagen eines YouTube-Videos mit einem vortrainierten Segmentierungsmodell bei einer Bildgröße von 320:
|
||||
```bash
|
||||
yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
|
||||
```
|
||||
|
||||
=== "Val"
|
||||
|
||||
Val ein vortrainiertes Erkennungsmodell bei Batch-Größe 1 und Bildgröße 640:
|
||||
```bash
|
||||
yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
|
||||
```
|
||||
|
||||
=== "Exportieren"
|
||||
|
||||
Exportieren Sie ein YOLOv8n-Klassifikationsmodell im ONNX-Format bei einer Bildgröße von 224 mal 128 (kein TASK erforderlich)
|
||||
```bash
|
||||
yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
|
||||
```
|
||||
|
||||
=== "Speziell"
|
||||
|
||||
Führen Sie spezielle Befehle aus, um Version, Einstellungen zu sehen, Checks auszuführen und mehr:
|
||||
```bash
|
||||
yolo help
|
||||
yolo checks
|
||||
yolo version
|
||||
yolo settings
|
||||
yolo copy-cfg
|
||||
yolo cfg
|
||||
```
|
||||
|
||||
!!! Warnung "Warnung"
|
||||
|
||||
Argumente müssen als `arg=val` Paare übergeben werden, getrennt durch ein Gleichheitszeichen `=` und durch Leerzeichen ` ` zwischen den Paaren. Verwenden Sie keine `--` Argumentpräfixe oder Kommata `,` zwischen den Argumenten.
|
||||
|
||||
- `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` ✅
|
||||
- `yolo predict model yolov8n.pt imgsz 640 conf 0.25` ❌
|
||||
- `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` ❌
|
||||
|
||||
[CLI-Leitfaden](../usage/cli.md){ .md-button .md-button--primary}
|
||||
|
||||
## Ultralytics mit Python verwenden
|
||||
|
||||
Die Python-Schnittstelle von YOLOv8 ermöglicht eine nahtlose Integration in Ihre Python-Projekte und erleichtert das Laden, Ausführen und Verarbeiten der Modellausgabe. Konzipiert für Einfachheit und Benutzerfreundlichkeit, ermöglicht die Python-Schnittstelle Benutzern, Objekterkennung, Segmentierung und Klassifizierung schnell in ihren Projekten zu implementieren. Dies macht die Python-Schnittstelle von YOLOv8 zu einem unschätzbaren Werkzeug für jeden, der diese Funktionalitäten in seine Python-Projekte integrieren möchte.
|
||||
|
||||
Benutzer können beispielsweise ein Modell laden, es trainieren, seine Leistung an einem Validierungsset auswerten und sogar in das ONNX-Format exportieren, und das alles mit nur wenigen Codezeilen. Schauen Sie sich den [Python-Leitfaden](../usage/python.md) an, um mehr über die Verwendung von YOLOv8 in Ihren_python_pro_jek_ten zu erfahren.
|
||||
|
||||
!!! Beispiel
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Erstellen Sie ein neues YOLO Modell von Grund auf
|
||||
model = YOLO('yolov8n.yaml')
|
||||
|
||||
# Laden Sie ein vortrainiertes YOLO Modell (empfohlen für das Training)
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Trainieren Sie das Modell mit dem Datensatz 'coco128.yaml' für 3 Epochen
|
||||
results = model.train(data='coco128.yaml', epochs=3)
|
||||
|
||||
# Bewerten Sie die Leistung des Modells am Validierungssatz
|
||||
results = model.val()
|
||||
|
||||
# Führen Sie eine Objekterkennung an einem Bild mit dem Modell durch
|
||||
results = model('https://ultralytics.com/images/bus.jpg')
|
||||
|
||||
# Exportieren Sie das Modell ins ONNX-Format
|
||||
success = model.export(format='onnx')
|
||||
```
|
||||
|
||||
[Python-Leitfaden](../usage/python.md){.md-button .md-button--primary}
|
||||
172
docs/de/tasks/classify.md
Normal file
172
docs/de/tasks/classify.md
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
---
|
||||
comments: true
|
||||
description: Erfahren Sie mehr über YOLOv8 Classify-Modelle zur Bildklassifizierung. Erhalten Sie detaillierte Informationen über die Liste vortrainierter Modelle und wie man Modelle trainiert, validiert, vorhersagt und exportiert.
|
||||
keywords: Ultralytics, YOLOv8, Bildklassifizierung, Vortrainierte Modelle, YOLOv8n-cls, Training, Validierung, Vorhersage, Modellexport
|
||||
---
|
||||
|
||||
# Bildklassifizierung
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418606-adf35c62-2e11-405d-84c6-b84e7d013804.png" alt="Beispiele für Bildklassifizierung">
|
||||
|
||||
Bildklassifizierung ist die einfachste der drei Aufgaben und besteht darin, ein ganzes Bild in eine von einem Satz vordefinierter Klassen zu klassifizieren.
|
||||
|
||||
Die Ausgabe eines Bildklassifizierers ist ein einzelnes Klassenlabel und eine Vertrauenspunktzahl. Bildklassifizierung ist nützlich, wenn Sie nur wissen müssen, zu welcher Klasse ein Bild gehört, und nicht wissen müssen, wo sich Objekte dieser Klasse befinden oder wie ihre genaue Form ist.
|
||||
|
||||
!!! tip "Tipp"
|
||||
|
||||
YOLOv8 Classify-Modelle verwenden den Suffix `-cls`, z.B. `yolov8n-cls.pt` und sind auf [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) vortrainiert.
|
||||
|
||||
## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
Hier werden vortrainierte YOLOv8 Classify-Modelle gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, während Classify-Modelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind.
|
||||
|
||||
[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch vom neuesten Ultralytics-[Release](https://github.com/ultralytics/assets/releases) beim ersten Gebrauch heruntergeladen.
|
||||
|
||||
| Modell | Größe<br><sup>(Pixel) | Genauigkeit<br><sup>top1 | Genauigkeit<br><sup>top5 | Geschwindigkeit<br><sup>CPU ONNX<br>(ms) | Geschwindigkeit<br><sup>A100 TensorRT<br>(ms) | Parameter<br><sup>(M) | FLOPs<br><sup>(B) bei 640 |
|
||||
|----------------------------------------------------------------------------------------------|-----------------------|--------------------------|--------------------------|------------------------------------------|-----------------------------------------------|-----------------------|---------------------------|
|
||||
| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
|
||||
| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
|
||||
| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
|
||||
| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
|
||||
| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
|
||||
|
||||
- **Genauigkeit**-Werte sind Modellgenauigkeiten auf dem [ImageNet](https://www.image-net.org/)-Datensatz Validierungsset.
|
||||
<br>Zur Reproduktion `yolo val classify data=pfad/zu/ImageNet device=0 verwenden`
|
||||
- **Geschwindigkeit** Durchschnitt über ImageNet-Validierungsbilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/de/ec2/instance-types/p4/)-Instanz.
|
||||
<br>Zur Reproduktion `yolo val classify data=pfad/zu/ImageNet batch=1 device=0|cpu verwenden`
|
||||
|
||||
## Trainieren
|
||||
|
||||
Trainieren Sie das YOLOv8n-cls-Modell auf dem MNIST160-Datensatz für 100 Epochen bei Bildgröße 64. Eine vollständige Liste der verfügbaren Argumente finden Sie auf der Seite [Konfiguration](../../usage/cfg.md).
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein Modell laden
|
||||
model = YOLO('yolov8n-cls.yaml') # ein neues Modell aus YAML erstellen
|
||||
model = YOLO('yolov8n-cls.pt') # ein vortrainiertes Modell laden (empfohlen für das Training)
|
||||
model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # aus YAML erstellen und Gewichte übertragen
|
||||
|
||||
# Das Modell trainieren
|
||||
results = model.train(data='mnist160', epochs=100, imgsz=64)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Ein neues Modell aus YAML erstellen und das Training von Grund auf starten
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
|
||||
|
||||
# Das Training von einem vortrainierten *.pt Modell starten
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
|
||||
|
||||
# Ein neues Modell aus YAML erstellen, vortrainierte Gewichte übertragen und das Training starten
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
|
||||
```
|
||||
|
||||
### Datenformat
|
||||
|
||||
Das Datenformat für YOLO-Klassifizierungsdatensätze finden Sie im Detail im [Datenleitfaden](../../datasets/classify/index.md).
|
||||
|
||||
## Validieren
|
||||
|
||||
Validieren Sie die Genauigkeit des trainierten YOLOv8n-cls-Modells auf dem MNIST160-Datensatz. Kein Argument muss übergeben werden, da das `modell` seine Trainings`daten` und Argumente als Modellattribute behält.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein Modell laden
|
||||
model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
|
||||
|
||||
# Das Modell validieren
|
||||
metrics = model.val() # keine Argumente benötigt, Datensatz und Einstellungen gespeichert
|
||||
metrics.top1 # top1 Genauigkeit
|
||||
metrics.top5 # top5 Genauigkeit
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify val model=yolov8n-cls.pt # ein offizielles Modell validieren
|
||||
yolo classify val model=pfad/zu/best.pt # ein benutzerdefiniertes Modell validieren
|
||||
```
|
||||
|
||||
## Vorhersagen
|
||||
|
||||
Verwenden Sie ein trainiertes YOLOv8n-cls-Modell, um Vorhersagen auf Bildern durchzuführen.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein Modell laden
|
||||
model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
|
||||
|
||||
# Mit dem Modell vorhersagen
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # mit offiziellem Modell vorhersagen
|
||||
yolo classify predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # mit benutzerdefiniertem Modell vorhersagen
|
||||
```
|
||||
|
||||
Vollständige Details zum `predict`-Modus finden Sie auf der Seite [Vorhersage](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
## Exportieren
|
||||
|
||||
Exportieren Sie ein YOLOv8n-cls-Modell in ein anderes Format wie ONNX, CoreML usw.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Ein Modell laden
|
||||
model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes trainiertes Modell laden
|
||||
|
||||
# Das Modell exportieren
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-cls.pt format=onnx # offizielles Modell exportieren
|
||||
yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren
|
||||
```
|
||||
|
||||
Verfügbare YOLOv8-cls Exportformate stehen in der folgenden Tabelle. Sie können direkt auf exportierten Modellen vorhersagen oder validieren, d.h. `yolo predict model=yolov8n-cls.onnx`. Nutzungsexempel werden für Ihr Modell nach Abschluss des Exports angezeigt.
|
||||
|
||||
| Format | `format`-Argument | Modell | Metadaten | Argumente |
|
||||
|--------------------------------------------------------------------|-------------------|-------------------------------|-----------|-----------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` |
|
||||
|
||||
Vollständige Details zum `export` finden Sie auf der Seite [Export](https://docs.ultralytics.com/modes/export/).
|
||||
184
docs/de/tasks/detect.md
Normal file
184
docs/de/tasks/detect.md
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
---
|
||||
comments: true
|
||||
description: Offizielle Dokumentation für YOLOv8 von Ultralytics. Erfahren Sie, wie Sie Modelle trainieren, validieren, vorhersagen und in verschiedenen Formaten exportieren. Einschließlich detaillierter Leistungsstatistiken.
|
||||
keywords: YOLOv8, Ultralytics, Objekterkennung, vortrainierte Modelle, Training, Validierung, Vorhersage, Modell-Export, COCO, ImageNet, PyTorch, ONNX, CoreML
|
||||
---
|
||||
|
||||
# Objekterkennung
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418624-5785cb93-74c9-4541-9179-d5c6782d491a.png" alt="Beispiele für Objekterkennung">
|
||||
|
||||
Objekterkennung ist eine Aufgabe, die das Identifizieren der Position und Klasse von Objekten in einem Bild oder Videostream umfasst.
|
||||
|
||||
Die Ausgabe eines Objekterkenners ist eine Menge von Begrenzungsrahmen, die die Objekte im Bild umschließen, zusammen mit Klassenbezeichnungen und Vertrauenswerten für jedes Feld. Objekterkennung ist eine gute Wahl, wenn Sie Objekte von Interesse in einer Szene identifizieren müssen, aber nicht genau wissen müssen, wo das Objekt ist oder wie seine genaue Form ist.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/5ku7npMrW40?si=6HQO1dDXunV8gekh"
|
||||
title="YouTube-Video-Player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Sehen Sie:</strong> Objekterkennung mit vortrainiertem Ultralytics YOLOv8 Modell.
|
||||
</p>
|
||||
|
||||
!!! tip "Tipp"
|
||||
|
||||
YOLOv8 Detect Modelle sind die Standard YOLOv8 Modelle, zum Beispiel `yolov8n.pt`, und sind vortrainiert auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz.
|
||||
|
||||
## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
Hier werden die vortrainierten YOLOv8 Detect Modelle gezeigt. Detect, Segment und Pose Modelle sind vortrainiert auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz, während die Classify Modelle vortrainiert sind auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz.
|
||||
|
||||
[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch von der neuesten Ultralytics [Veröffentlichung](https://github.com/ultralytics/assets/releases) bei Erstbenutzung heruntergeladen.
|
||||
|
||||
| Modell | Größe<br><sup>(Pixel) | mAP<sup>val<br>50-95 | Geschwindigkeit<br><sup>CPU ONNX<br>(ms) | Geschwindigkeit<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
|--------------------------------------------------------------------------------------|-----------------------|----------------------|------------------------------------------|-----------------------------------------------|--------------------|-------------------|
|
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
|
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
|
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
|
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
|
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
|
||||
|
||||
- **mAP<sup>val</sup>** Werte sind für Single-Modell Single-Scale auf dem [COCO val2017](http://cocodataset.org) Datensatz.
|
||||
<br>Reproduzieren mit `yolo val detect data=coco.yaml device=0`
|
||||
- **Geschwindigkeit** gemittelt über COCO Val Bilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)-Instanz.
|
||||
<br>Reproduzieren mit `yolo val detect data=coco128.yaml batch=1 device=0|cpu`
|
||||
|
||||
## Training
|
||||
|
||||
YOLOv8n auf dem COCO128-Datensatz für 100 Epochen bei Bildgröße 640 trainieren. Für eine vollständige Liste verfügbarer Argumente siehe die [Konfigurationsseite](../../usage/cfg.md).
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n.yaml') # ein neues Modell aus YAML aufbauen
|
||||
model = YOLO('yolov8n.pt') # ein vortrainiertes Modell laden (empfohlen für Training)
|
||||
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # aus YAML aufbauen und Gewichte übertragen
|
||||
|
||||
# Das Modell trainieren
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Ein neues Modell aus YAML aufbauen und Training von Grund auf starten
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
|
||||
|
||||
# Training von einem vortrainierten *.pt Modell starten
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
|
||||
# Ein neues Modell aus YAML aufbauen, vortrainierte Gewichte übertragen und Training starten
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Datenformat
|
||||
|
||||
Das Datenformat für YOLO-Erkennungsdatensätze finden Sie detailliert im [Dataset Guide](../../datasets/detect/index.md). Um Ihren vorhandenen Datensatz von anderen Formaten (wie COCO etc.) in das YOLO-Format zu konvertieren, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics.
|
||||
|
||||
## Validierung
|
||||
|
||||
Genauigkeit des trainierten YOLOv8n-Modells auf dem COCO128-Datensatz validieren. Es müssen keine Argumente übergeben werden, da das `modell` seine Trainingsdaten und Argumente als Modellattribute beibehält.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniertes Modell laden
|
||||
|
||||
# Das Modell validieren
|
||||
metrics = model.val() # keine Argumente nötig, Datensatz und Einstellungen erinnert
|
||||
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=pfad/zum/besten.pt # benutzerdefiniertes Modell validieren
|
||||
```
|
||||
|
||||
## Vorhersage
|
||||
|
||||
Ein trainiertes YOLOv8n-Modell verwenden, um Vorhersagen auf Bildern durchzuführen.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniertes Modell laden
|
||||
|
||||
# Mit dem Modell vorhersagen
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit offiziellem Modell
|
||||
yolo detect predict model=pfad/zum/besten.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit benutzerdefiniertem Modell
|
||||
```
|
||||
|
||||
Volle Details über den `predict`-Modus finden Sie auf der [Predict-Seite](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
## Export
|
||||
|
||||
Ein YOLOv8n-Modell in ein anderes Format wie ONNX, CoreML usw. exportieren.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniert trainiertes Modell laden
|
||||
|
||||
# Das Modell exportieren
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n.pt format=onnx # offizielles Modell exportieren
|
||||
yolo export model=pfad/zum/besten.pt format=onnx # benutzerdefiniert trainiertes Modell exportieren
|
||||
```
|
||||
|
||||
Verfügbare YOLOv8 Exportformate sind in der untenstehenden Tabelle aufgeführt. Sie können direkt auf den exportierten Modellen Vorhersagen treffen oder diese validieren, zum Beispiel `yolo predict model=yolov8n.onnx`. Verwendungsbeispiele werden für Ihr Modell nach Abschluss des Exports angezeigt.
|
||||
|
||||
| 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` |
|
||||
|
||||
Volle Details zum `export` finden Sie auf der [Export-Seite](https://docs.ultralytics.com/modes/export/).
|
||||
55
docs/de/tasks/index.md
Normal file
55
docs/de/tasks/index.md
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
---
|
||||
comments: true
|
||||
description: Erfahren Sie, welche grundlegenden Aufgaben im Bereich der Computer Vision YOLOv8 durchführen kann, einschließlich Erkennung, Segmentierung, Klassifizierung und Haltungsschätzung, und wie sie in Ihren KI-Projekten verwendet werden können.
|
||||
keywords: Ultralytics, YOLOv8, Erkennung, Segmentierung, Klassifizierung, Pose-Schätzung, KI-Framework, Computer Vision-Aufgaben
|
||||
---
|
||||
|
||||
# Ultralytics YOLOv8 Aufgaben
|
||||
|
||||
<br>
|
||||
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png" alt="Ultralytics YOLO unterstützte Aufgaben">
|
||||
|
||||
YOLOv8 ist ein KI-Framework, das mehrere Aufgaben im Bereich der Computer Vision **unterstützt**. Das Framework kann für die [Erkennung](detect.md), [Segmentierung](segment.md), [Klassifizierung](classify.md) und die [Pose](pose.md)-Schätzung verwendet werden. Jede dieser Aufgaben hat ein unterschiedliches Ziel und Anwendungsgebiete.
|
||||
|
||||
!!! Hinweis
|
||||
|
||||
🚧 Unsere mehrsprachigen Dokumentation befindet sich derzeit im Aufbau und wir arbeiten hart daran, sie zu verbessern. Danke für Ihre Geduld! 🙏
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/NAs-cfq9BDw"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Schauen Sie zu:</strong> Entdecken Sie Ultralytics YOLO Aufgaben: Objekterkennung, Segmentierung, Verfolgung und Pose-Schätzung.
|
||||
</p>
|
||||
|
||||
## [Erkennung](detect.md)
|
||||
|
||||
Erkennung ist die primäre von YOLOv8 unterstützte Aufgabe. Sie beinhaltet das Erkennen von Objekten in einem Bild oder Videobild und das Zeichnen von Rahmen um sie herum. Die erkannten Objekte werden anhand ihrer Merkmale in verschiedene Kategorien klassifiziert. YOLOv8 kann mehrere Objekte in einem einzelnen Bild oder Videobild mit hoher Genauigkeit und Geschwindigkeit erkennen.
|
||||
|
||||
[Beispiele für Erkennung](detect.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Segmentierung](segment.md)
|
||||
|
||||
Segmentierung ist eine Aufgabe, die das Aufteilen eines Bildes in unterschiedliche Regionen anhand des Bildinhalts beinhaltet. Jeder Region wird basierend auf ihrem Inhalt eine Markierung zugewiesen. Diese Aufgabe ist nützlich in Anwendungen wie der Bildsegmentierung und medizinischen Bildgebung. YOLOv8 verwendet eine Variante der U-Net-Architektur, um die Segmentierung durchzuführen.
|
||||
|
||||
[Beispiele für Segmentierung](segment.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Klassifizierung](classify.md)
|
||||
|
||||
Klassifizierung ist eine Aufgabe, die das Einordnen eines Bildes in verschiedene Kategorien umfasst. YOLOv8 kann genutzt werden, um Bilder anhand ihres Inhalts zu klassifizieren. Es verwendet eine Variante der EfficientNet-Architektur, um die Klassifizierung durchzuführen.
|
||||
|
||||
[Beispiele für Klassifizierung](classify.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Pose](pose.md)
|
||||
|
||||
Die Pose-/Keypoint-Erkennung ist eine Aufgabe, die das Erkennen von spezifischen Punkten in einem Bild oder Videobild beinhaltet. Diese Punkte werden als Keypoints bezeichnet und werden zur Bewegungsverfolgung oder Pose-Schätzung verwendet. YOLOv8 kann Keypoints in einem Bild oder Videobild mit hoher Genauigkeit und Geschwindigkeit erkennen.
|
||||
|
||||
[Beispiele für Posen](pose.md){ .md-button .md-button--primary}
|
||||
|
||||
## Fazit
|
||||
|
||||
YOLOv8 unterstützt mehrere Aufgaben, einschließlich Erkennung, Segmentierung, Klassifizierung und Keypoint-Erkennung. Jede dieser Aufgaben hat unterschiedliche Ziele und Anwendungsgebiete. Durch das Verständnis der Unterschiede zwischen diesen Aufgaben können Sie die geeignete Aufgabe für Ihre Anwendung im Bereich der Computer Vision auswählen.
|
||||
185
docs/de/tasks/pose.md
Normal file
185
docs/de/tasks/pose.md
Normal file
|
|
@ -0,0 +1,185 @@
|
|||
---
|
||||
comments: true
|
||||
description: Erfahren Sie, wie Sie Ultralytics YOLOv8 für Aufgaben der Pose-Schätzung verwenden können. Finden Sie vortrainierte Modelle, lernen Sie, wie man eigene trainiert, validiert, vorhersagt und exportiert.
|
||||
keywords: Ultralytics, YOLO, YOLOv8, Pose-Schätzung, Erkennung von Schlüsselpunkten, Objekterkennung, vortrainierte Modelle, maschinelles Lernen, künstliche Intelligenz
|
||||
---
|
||||
|
||||
# Pose-Schätzung
|
||||
|
||||
|
||||
|
||||
Die Pose-Schätzung ist eine Aufgabe, die das Identifizieren der Lage spezifischer Punkte in einem Bild beinhaltet, die normalerweise als Schlüsselpunkte bezeichnet werden. Die Schlüsselpunkte können verschiedene Teile des Objekts wie Gelenke, Landmarken oder andere charakteristische Merkmale repräsentieren. Die Positionen der Schlüsselpunkte sind üblicherweise als eine Gruppe von 2D `[x, y]` oder 3D `[x, y, sichtbar]` Koordinaten dargestellt.
|
||||
|
||||
Das Ergebnis eines Pose-Schätzungsmodells ist eine Gruppe von Punkten, die die Schlüsselpunkte auf einem Objekt im Bild darstellen, normalerweise zusammen mit den Konfidenzwerten für jeden Punkt. Die Pose-Schätzung eignet sich gut, wenn Sie spezifische Teile eines Objekts in einer Szene identifizieren müssen und deren Lage zueinander.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ"
|
||||
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> Pose-Schätzung mit Ultralytics YOLOv8.
|
||||
</p>
|
||||
|
||||
!!! Tipp "Tipp"
|
||||
|
||||
YOLOv8 _pose_-Modelle verwenden den Suffix `-pose`, z. B. `yolov8n-pose.pt`. Diese Modelle sind auf dem [COCO-Schlüsselpunkte](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml)-Datensatz trainiert und für eine Vielzahl von Pose-Schätzungsaufgaben geeignet.
|
||||
|
||||
## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
Hier werden vortrainierte YOLOv8 Pose-Modelle gezeigt. Erkennungs-, Segmentierungs- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, während Klassifizierungsmodelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind.
|
||||
|
||||
[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch aus der neuesten Ultralytics-[Veröffentlichung](https://github.com/ultralytics/assets/releases) bei erstmaliger Verwendung heruntergeladen.
|
||||
|
||||
| Modell | Größe<br/><sup>(Pixel) | mAP<sup>pose<br/>50-95 | mAP<sup>pose<br/>50 | Geschwindigkeit<br/><sup>CPU ONNX<br/>(ms) | Geschwindigkeit<br/><sup>A100 TensorRT<br/>(ms) | Parameter<br/><sup>(M) | FLOPs<br/><sup>(B) |
|
||||
|------------------------------------------------------------------------------------------------------|------------------------|------------------------|---------------------|--------------------------------------------|-------------------------------------------------|------------------------|--------------------|
|
||||
| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50,4 | 80,1 | 131,8 | 1,18 | 3,3 | 9,2 |
|
||||
| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60,0 | 86,2 | 233,2 | 1,42 | 11,6 | 30,2 |
|
||||
| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65,0 | 88,8 | 456,3 | 2,00 | 26,4 | 81,0 |
|
||||
| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67,6 | 90,0 | 784,5 | 2,59 | 44,4 | 168,6 |
|
||||
| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69,2 | 90,2 | 1607,1 | 3,73 | 69,4 | 263,2 |
|
||||
| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71,6 | 91,2 | 4088,7 | 10,04 | 99,1 | 1066,4 |
|
||||
|
||||
- **mAP<sup>val</sup>** Werte gelten für ein einzelnes Modell mit einfacher Skala auf dem [COCO Keypoints val2017](http://cocodataset.org)-Datensatz.
|
||||
<br>Zu reproduzieren mit `yolo val pose data=coco-pose.yaml device=0`.
|
||||
- **Geschwindigkeit** gemittelt über COCO-Validierungsbilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/de/ec2/instance-types/p4/)-Instanz.
|
||||
<br>Zu reproduzieren mit `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`.
|
||||
|
||||
## Trainieren
|
||||
|
||||
Trainieren Sie ein YOLOv8-Pose-Modell auf dem COCO128-Pose-Datensatz.
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n-pose.yaml') # ein neues Modell aus YAML bauen
|
||||
model = YOLO('yolov8n-pose.pt') # ein vortrainiertes Modell laden (empfohlen für das Training)
|
||||
model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # aus YAML bauen und Gewichte übertragen
|
||||
|
||||
# Modell trainieren
|
||||
results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Ein neues Modell aus YAML bauen und das Training von Grund auf starten
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
|
||||
|
||||
# Training von einem vortrainierten *.pt Modell starten
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
|
||||
# Ein neues Modell aus YAML bauen, vortrainierte Gewichte übertragen und das Training starten
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Datensatzformat
|
||||
|
||||
Das YOLO-Pose-Datensatzformat finden Sie detailliert im [Datensatz-Leitfaden](../../datasets/pose/index.md). Um Ihren bestehenden Datensatz aus anderen Formaten (wie COCO usw.) in das YOLO-Format zu konvertieren, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics.
|
||||
|
||||
## Validieren
|
||||
|
||||
Die Genauigkeit des trainierten YOLOv8n-Pose-Modells auf dem COCO128-Pose-Datensatz validieren. Es müssen keine Argumente übergeben werden, da das `Modell` seine Trainings`daten` und Argumente als Modellattribute beibehält.
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
|
||||
|
||||
# Modell validieren
|
||||
metrics = model.val() # keine Argumente nötig, Datensatz und Einstellungen sind gespeichert
|
||||
metrics.box.map # map50-95
|
||||
metrics.box.map50 # map50
|
||||
metrics.box.map75 # map75
|
||||
metrics.box.maps # Liste enthält map50-95 jeder Kategorie
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose val model=yolov8n-pose.pt # offizielles Modell validieren
|
||||
yolo pose val model=pfad/zu/best.pt # benutzerdefiniertes Modell validieren
|
||||
```
|
||||
|
||||
## Vorhersagen
|
||||
|
||||
Ein trainiertes YOLOv8n-Pose-Modell verwenden, um Vorhersagen auf Bildern zu machen.
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
|
||||
|
||||
# Mit dem Modell Vorhersagen machen
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild machen
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit dem offiziellen Modell machen
|
||||
yolo pose predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit dem benutzerdefinierten Modell machen
|
||||
```
|
||||
|
||||
Vollständige `predict`-Modusdetails finden Sie auf der [Vorhersage](https://docs.ultralytics.com/modes/predict/)-Seite.
|
||||
|
||||
## Exportieren
|
||||
|
||||
Ein YOLOv8n-Pose-Modell in ein anderes Format wie ONNX, CoreML usw. exportieren.
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
|
||||
|
||||
# Modell exportieren
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-pose.pt format=onnx # offizielles Modell exportieren
|
||||
yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes Modell exportieren
|
||||
```
|
||||
|
||||
Verfügbare YOLOv8-Pose-Exportformate sind in der folgenden Tabelle aufgeführt. Sie können direkt auf exportierten Modellen vorhersagen oder validieren, z. B. `yolo predict model=yolov8n-pose.onnx`. Verwendungsbeispiele werden für Ihr Modell nach Abschluss des Exports angezeigt.
|
||||
|
||||
| Format | `format` Argument | Modell | Metadaten | Argumente |
|
||||
|--------------------------------------------------------------------|-------------------|--------------------------------|-----------|-----------------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimieren` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `halb` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `workspace` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `halb`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `halb`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `halb` |
|
||||
|
||||
Vollständige `export`-Details finden Sie auf der [Export](https://docs.ultralytics.com/modes/export/)-Seite.
|
||||
188
docs/de/tasks/segment.md
Normal file
188
docs/de/tasks/segment.md
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
---
|
||||
comments: true
|
||||
description: Erfahren Sie, wie Sie Instanzsegmentierungsmodelle mit Ultralytics YOLO verwenden. Anleitungen zum Training, zur Validierung, zur Bildvorhersage und zum Export von Modellen.
|
||||
Schlagworte: yolov8, Instanzsegmentierung, Ultralytics, COCO-Datensatz, Bildsegmentierung, Objekterkennung, Modelltraining, Modellvalidierung, Bildvorhersage, Modellexport
|
||||
---
|
||||
|
||||
# Instanzsegmentierung
|
||||
|
||||
|
||||
|
||||
Instanzsegmentierung geht einen Schritt weiter als die Objekterkennung und beinhaltet die Identifizierung einzelner Objekte in einem Bild und deren Abtrennung vom Rest des Bildes.
|
||||
|
||||
Das Ergebnis eines Instanzsegmentierungsmodells ist eine Reihe von Masken oder Konturen, die jedes Objekt im Bild umreißen, zusammen mit Klassenbezeichnungen und Vertrauensscores für jedes Objekt. Instanzsegmentierung ist nützlich, wenn man nicht nur wissen muss, wo sich Objekte in einem Bild befinden, sondern auch, welche genaue Form sie haben.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/o4Zd-IeMlSY?si=37nusCzDTd74Obsp"
|
||||
title="YouTube-Video-Player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Schauen Sie:</strong> Führen Sie Segmentierung mit dem vortrainierten Ultralytics YOLOv8 Modell in Python aus.
|
||||
</p>
|
||||
|
||||
!!! Tipp "Tipp"
|
||||
|
||||
YOLOv8 Segment-Modelle verwenden das Suffix `-seg`, d.h. `yolov8n-seg.pt` und sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert.
|
||||
|
||||
## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
Hier werden vortrainierte YOLOv8 Segment-Modelle gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, während Classify-Modelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind.
|
||||
|
||||
[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) laden sich automatisch von der neuesten Ultralytics [Veröffentlichung](https://github.com/ultralytics/assets/releases) beim ersten Gebrauch herunter.
|
||||
|
||||
| Modell | Größe<br><sup>(Pixel) | mAP<sup>Kasten<br>50-95 | mAP<sup>Masken<br>50-95 | Geschwindigkeit<br><sup>CPU ONNX<br>(ms) | Geschwindigkeit<br><sup>A100 TensorRT<br>(ms) | Parameter<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
|----------------------------------------------------------------------------------------------|-----------------------|-------------------------|-------------------------|------------------------------------------|-----------------------------------------------|-----------------------|-------------------|
|
||||
| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
|
||||
| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
|
||||
| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
|
||||
| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
|
||||
| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
|
||||
|
||||
- Die **mAP<sup>val</sup>**-Werte sind für ein einzelnes Modell, einzelne Skala auf dem [COCO val2017](http://cocodataset.org)-Datensatz.
|
||||
<br>Zum Reproduzieren nutzen Sie `yolo val segment data=coco.yaml device=0`
|
||||
- Die **Geschwindigkeit** ist über die COCO-Validierungsbilder gemittelt und verwendet eine [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)-Instanz.
|
||||
<br>Zum Reproduzieren `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu`
|
||||
|
||||
## Training
|
||||
|
||||
Trainieren Sie YOLOv8n-seg auf dem COCO128-seg-Datensatz für 100 Epochen mit einer Bildgröße von 640. Eine vollständige Liste der verfügbaren Argumente finden Sie auf der Seite [Konfiguration](../../usage/cfg.md).
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n-seg.yaml') # ein neues Modell aus YAML erstellen
|
||||
model = YOLO('yolov8n-seg.pt') # ein vortrainiertes Modell laden (empfohlen für das Training)
|
||||
model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # aus YAML erstellen und Gewichte übertragen
|
||||
|
||||
# Das Modell trainieren
|
||||
results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Ein neues Modell aus YAML erstellen und das Training von vorne beginnen
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
|
||||
|
||||
# Das Training von einem vortrainierten *.pt Modell aus starten
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
|
||||
# Ein neues Modell aus YAML erstellen, vortrainierte Gewichte darauf übertragen und das Training beginnen
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Datenformat
|
||||
|
||||
Das YOLO Segmentierungsdatenformat finden Sie detailliert im [Dataset Guide](../../datasets/segment/index.md). Um Ihre vorhandenen Daten aus anderen Formaten (wie COCO usw.) in das YOLO-Format umzuwandeln, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics.
|
||||
|
||||
## Val
|
||||
|
||||
Validieren Sie die Genauigkeit des trainierten YOLOv8n-seg-Modells auf dem COCO128-seg-Datensatz. Es müssen keine Argumente übergeben werden, da das `Modell` seine Trainingsdaten und -argumente als Modellattribute behält.
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n-seg.pt') # offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes Modell laden
|
||||
|
||||
# Das Modell validieren
|
||||
metrics = model.val() # Keine Argumente erforderlich, Datensatz und Einstellungen werden behalten
|
||||
metrics.box.map # mAP50-95(B)
|
||||
metrics.box.map50 # mAP50(B)
|
||||
metrics.box.map75 # mAP75(B)
|
||||
metrics.box.maps # eine Liste enthält mAP50-95(B) für jede Kategorie
|
||||
metrics.seg.map # mAP50-95(M)
|
||||
metrics.seg.map50 # mAP50(M)
|
||||
metrics.seg.map75 # mAP75(M)
|
||||
metrics.seg.maps # eine Liste enthält mAP50-95(M) für jede Kategorie
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo segment val model=yolov8n-seg.pt # offizielles Modell validieren
|
||||
yolo segment val model=pfad/zu/best.pt # benutzerdefiniertes Modell validieren
|
||||
```
|
||||
|
||||
## Predict
|
||||
|
||||
Verwenden Sie ein trainiertes YOLOv8n-seg-Modell für Vorhersagen auf Bildern.
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n-seg.pt') # offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes Modell laden
|
||||
|
||||
# Mit dem Modell Vorhersagen treffen
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit offiziellem Modell treffen
|
||||
yolo segment predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit benutzerdefiniertem Modell treffen
|
||||
```
|
||||
|
||||
Die vollständigen Details zum `predict`-Modus finden Sie auf der Seite [Predict](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
## Export
|
||||
|
||||
Exportieren Sie ein YOLOv8n-seg-Modell in ein anderes Format wie ONNX, CoreML usw.
|
||||
|
||||
!!! Beispiel ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Modell laden
|
||||
model = YOLO('yolov8n-seg.pt') # offizielles Modell laden
|
||||
model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes trainiertes Modell laden
|
||||
|
||||
# Das Modell exportieren
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-seg.pt format=onnx # offizielles Modell exportieren
|
||||
yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren
|
||||
```
|
||||
|
||||
Die verfügbaren YOLOv8-seg-Exportformate sind in der folgenden Tabelle aufgeführt. Sie können direkt auf exportierten Modellen Vorhersagen treffen oder sie validieren, z.B. `yolo predict model=yolov8n-seg.onnx`. Verwendungsbeispiele werden für Ihr Modell nach dem Export angezeigt.
|
||||
|
||||
| Format | `format`-Argument | Modell | Metadaten | Argumente |
|
||||
|--------------------------------------------------------------------|-------------------|-------------------------------|-----------|-----------------------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimieren` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `halb` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `Arbeitsspeicher` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `halb`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `halb`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `halb` |
|
||||
|
||||
Die vollständigen Details zum `export` finden Sie auf der Seite [Export](https://docs.ultralytics.com/modes/export/).
|
||||
Loading…
Add table
Add a link
Reference in a new issue