Cleanup Docs languages (#7865)
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com>pull/7861/head
Glenn Jocher
1 year ago
committed by
GitHub
parent
6183b59d8a
commit
afb0cb1057
284 changed files with 8 additions and 40429 deletions
@ -1,127 +0,0 @@ |
||||
--- |
||||
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 "Hinweis" |
||||
|
||||
🚧 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. |
||||
@ -1,193 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erkunden Sie FastSAM, eine CNN-basierte Lösung zur Echtzeit-Segmentierung von Objekten in Bildern. Verbesserte Benutzerinteraktion, Recheneffizienz und anpassbar für verschiedene Vision-Aufgaben. |
||||
keywords: FastSAM, maschinelles Lernen, CNN-basierte Lösung, Objektsegmentierung, Echtzeillösung, Ultralytics, Vision-Aufgaben, Bildverarbeitung, industrielle Anwendungen, Benutzerinteraktion |
||||
--- |
||||
|
||||
# Fast Segment Anything Model (FastSAM) |
||||
|
||||
Das Fast Segment Anything Model (FastSAM) ist eine neuartige, Echtzeit-CNN-basierte Lösung für die Segment Anything Aufgabe. Diese Aufgabe zielt darauf ab, jedes Objekt in einem Bild auf Basis verschiedener möglicher Benutzerinteraktionen zu segmentieren. FastSAM reduziert signifikant den Rechenbedarf, während es eine wettbewerbsfähige Leistung beibehält und somit für eine Vielzahl von Vision-Aufgaben praktisch einsetzbar ist. |
||||
|
||||
 |
||||
|
||||
## Überblick |
||||
|
||||
FastSAM wurde entwickelt, um die Einschränkungen des [Segment Anything Model (SAM)](sam.md) zu beheben, einem schweren Transformer-Modell mit erheblichem Rechenressourcenbedarf. Das FastSAM teilt die Segment Anything Aufgabe in zwei aufeinanderfolgende Stufen auf: die Instanzsegmentierung und die promptgesteuerte Auswahl. In der ersten Stufe wird [YOLOv8-seg](../tasks/segment.md) verwendet, um die Segmentierungsmasken aller Instanzen im Bild zu erzeugen. In der zweiten Stufe gibt es den Bereich von Interesse aus, der dem Prompt entspricht. |
||||
|
||||
## Hauptmerkmale |
||||
|
||||
1. **Echtzeitlösung:** Durch die Nutzung der Recheneffizienz von CNNs bietet FastSAM eine Echtzeitlösung für die Segment Anything Aufgabe und eignet sich somit für industrielle Anwendungen, die schnelle Ergebnisse erfordern. |
||||
|
||||
2. **Effizienz und Leistung:** FastSAM bietet eine signifikante Reduzierung des Rechen- und Ressourcenbedarfs, ohne die Leistungsqualität zu beeinträchtigen. Es erzielt eine vergleichbare Leistung wie SAM, verwendet jedoch drastisch reduzierte Rechenressourcen und ermöglicht so eine Echtzeitanwendung. |
||||
|
||||
3. **Promptgesteuerte Segmentierung:** FastSAM kann jedes Objekt in einem Bild anhand verschiedener möglicher Benutzerinteraktionsaufforderungen segmentieren. Dies ermöglicht Flexibilität und Anpassungsfähigkeit in verschiedenen Szenarien. |
||||
|
||||
4. **Basierend auf YOLOv8-seg:** FastSAM basiert auf [YOLOv8-seg](../tasks/segment.md), einem Objektdetektor mit einem Instanzsegmentierungsmodul. Dadurch ist es in der Lage, die Segmentierungsmasken aller Instanzen in einem Bild effektiv zu erzeugen. |
||||
|
||||
5. **Wettbewerbsfähige Ergebnisse auf Benchmarks:** Bei der Objektvorschlagsaufgabe auf MS COCO erzielt FastSAM hohe Punktzahlen bei deutlich schnellerem Tempo als [SAM](sam.md) auf einer einzelnen NVIDIA RTX 3090. Dies demonstriert seine Effizienz und Leistungsfähigkeit. |
||||
|
||||
6. **Praktische Anwendungen:** Der vorgeschlagene Ansatz bietet eine neue, praktische Lösung für eine Vielzahl von Vision-Aufgaben mit sehr hoher Geschwindigkeit, die zehn- oder hundertmal schneller ist als vorhandene Methoden. |
||||
|
||||
7. **Möglichkeit zur Modellkompression:** FastSAM zeigt, dass der Rechenaufwand erheblich reduziert werden kann, indem ein künstlicher Prior in die Struktur eingeführt wird. Dadurch eröffnen sich neue Möglichkeiten für große Modellarchitekturen für allgemeine Vision-Aufgaben. |
||||
|
||||
## Verfügbare Modelle, unterstützte Aufgaben und Betriebsmodi |
||||
|
||||
In dieser Tabelle werden die verfügbaren Modelle mit ihren spezifischen vorab trainierten Gewichten, den unterstützten Aufgaben und ihrer Kompatibilität mit verschiedenen Betriebsmodi wie [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md) angezeigt. Dabei stehen ✅ Emojis für unterstützte Modi und ❌ Emojis für nicht unterstützte Modi. |
||||
|
||||
| Modelltyp | Vorab trainierte Gewichte | Unterstützte Aufgaben | Inferenz | Validierung | Training | Export | |
||||
|-----------|---------------------------|---------------------------------------------|----------|-------------|----------|--------| |
||||
| FastSAM-s | `FastSAM-s.pt` | [Instanzsegmentierung](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
| FastSAM-x | `FastSAM-x.pt` | [Instanzsegmentierung](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Beispiele für die Verwendung |
||||
|
||||
Die FastSAM-Modelle lassen sich problemlos in Ihre Python-Anwendungen integrieren. Ultralytics bietet eine benutzerfreundliche Python-API und CLI-Befehle zur Vereinfachung der Entwicklung. |
||||
|
||||
### Verwendung der Methode `predict` |
||||
|
||||
Um eine Objekterkennung auf einem Bild durchzuführen, verwenden Sie die Methode `predict` wie folgt: |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM |
||||
from ultralytics.models.fastsam import FastSAMPrompt |
||||
|
||||
# Definieren Sie die Quelle für die Inferenz |
||||
source = 'Pfad/zum/bus.jpg' |
||||
|
||||
# Erstellen Sie ein FastSAM-Modell |
||||
model = FastSAM('FastSAM-s.pt') # oder FastSAM-x.pt |
||||
|
||||
# Führen Sie die Inferenz auf einem Bild durch |
||||
everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9) |
||||
|
||||
# Bereiten Sie ein Prompt-Process-Objekt vor |
||||
prompt_process = FastSAMPrompt(source, everything_results, device='cpu') |
||||
|
||||
# Alles-Prompt |
||||
ann = prompt_process.everything_prompt() |
||||
|
||||
# Bbox Standardform [0,0,0,0] -> [x1,y1,x2,y2] |
||||
ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300]) |
||||
|
||||
# Text-Prompt |
||||
ann = prompt_process.text_prompt(text='ein Foto von einem Hund') |
||||
|
||||
# Punkt-Prompt |
||||
# Punkte Standard [[0,0]] [[x1,y1],[x2,y2]] |
||||
# Punktbezeichnung Standard [0] [1,0] 0:Hintergrund, 1:Vordergrund |
||||
ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1]) |
||||
prompt_process.plot(annotations=ann, output='./') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
```bash |
||||
# Laden Sie ein FastSAM-Modell und segmentieren Sie alles damit |
||||
yolo segment predict model=FastSAM-s.pt source=Pfad/zum/bus.jpg imgsz=640 |
||||
``` |
||||
|
||||
Dieser Code-Ausschnitt zeigt die Einfachheit des Ladens eines vorab trainierten Modells und das Durchführen einer Vorhersage auf einem Bild. |
||||
|
||||
### Verwendung von `val` |
||||
|
||||
Die Validierung des Modells auf einem Datensatz kann wie folgt durchgeführt werden: |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM |
||||
|
||||
# Erstellen Sie ein FastSAM-Modell |
||||
model = FastSAM('FastSAM-s.pt') # oder FastSAM-x.pt |
||||
|
||||
# Validieren Sie das Modell |
||||
results = model.val(data='coco8-seg.yaml') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
```bash |
||||
# Laden Sie ein FastSAM-Modell und validieren Sie es auf dem COCO8-Beispieldatensatz mit Bildgröße 640 |
||||
yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640 |
||||
``` |
||||
|
||||
Bitte beachten Sie, dass FastSAM nur die Erkennung und Segmentierung einer einzigen Objektklasse unterstützt. Das bedeutet, dass es alle Objekte als dieselbe Klasse erkennt und segmentiert. Daher müssen Sie beim Vorbereiten des Datensatzes alle Objektkategorie-IDs in 0 umwandeln. |
||||
|
||||
## Offizielle Verwendung von FastSAM |
||||
|
||||
FastSAM ist auch direkt aus dem [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM) Repository erhältlich. Hier ist ein kurzer Überblick über die typischen Schritte, die Sie unternehmen könnten, um FastSAM zu verwenden: |
||||
|
||||
### Installation |
||||
|
||||
1. Klonen Sie das FastSAM-Repository: |
||||
```shell |
||||
git clone https://github.com/CASIA-IVA-Lab/FastSAM.git |
||||
``` |
||||
|
||||
2. Erstellen und aktivieren Sie eine Conda-Umgebung mit Python 3.9: |
||||
```shell |
||||
conda create -n FastSAM python=3.9 |
||||
conda activate FastSAM |
||||
``` |
||||
|
||||
3. Navigieren Sie zum geklonten Repository und installieren Sie die erforderlichen Pakete: |
||||
```shell |
||||
cd FastSAM |
||||
pip install -r requirements.txt |
||||
``` |
||||
|
||||
4. Installieren Sie das CLIP-Modell: |
||||
```shell |
||||
pip install git+https://github.com/openai/CLIP.git |
||||
``` |
||||
|
||||
### Beispielverwendung |
||||
|
||||
1. Laden Sie eine [Modell-Sicherung](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing) herunter. |
||||
|
||||
2. Verwenden Sie FastSAM für Inferenz. Beispielbefehle: |
||||
|
||||
- Segmentieren Sie alles in einem Bild: |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg |
||||
``` |
||||
|
||||
- Segmentieren Sie bestimmte Objekte anhand eines Textprompts: |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "der gelbe Hund" |
||||
``` |
||||
|
||||
- Segmentieren Sie Objekte innerhalb eines Begrenzungsrahmens (geben Sie die Boxkoordinaten im xywh-Format an): |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]" |
||||
``` |
||||
|
||||
- Segmentieren Sie Objekte in der Nähe bestimmter Punkte: |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]" |
||||
``` |
||||
|
||||
Sie können FastSAM auch über eine [Colab-Demo](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) oder die [HuggingFace-Web-Demo](https://huggingface.co/spaces/An-619/FastSAM) testen, um eine visuelle Erfahrung zu machen. |
||||
|
||||
## Zitate und Danksagungen |
||||
|
||||
Wir möchten den Autoren von FastSAM für ihre bedeutenden Beiträge auf dem Gebiet der Echtzeit-Instanzsegmentierung danken: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{zhao2023fast, |
||||
title={Fast Segment Anything}, |
||||
author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang}, |
||||
year={2023}, |
||||
eprint={2306.12156}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Die ursprüngliche FastSAM-Arbeit ist auf [arXiv](https://arxiv.org/abs/2306.12156) zu finden. Die Autoren haben ihre Arbeit öffentlich zugänglich gemacht, und der Code ist auf [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM) verfügbar. Wir schätzen ihre Bemühungen, das Fachgebiet voranzutreiben und ihre Arbeit der breiteren Gemeinschaft zugänglich zu machen. |
||||
@ -1,98 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Entdecken Sie die vielfältige Palette an Modellen der YOLO-Familie, SAM, MobileSAM, FastSAM, YOLO-NAS und RT-DETR, die von Ultralytics unterstützt werden. Beginnen Sie mit Beispielen für die CLI- und Python-Nutzung. |
||||
keywords: Ultralytics, Dokumentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, Modelle, Architekturen, Python, CLI |
||||
--- |
||||
|
||||
# Von Ultralytics unterstützte Modelle |
||||
|
||||
Willkommen bei der Modell-Dokumentation von Ultralytics! Wir bieten Unterstützung für eine breite Palette von Modellen, die jeweils für spezifische Aufgaben wie [Objekterkennung](../tasks/detect.md), [Instanzsegmentierung](../tasks/segment.md), [Bildklassifizierung](../tasks/classify.md), [Posenschätzung](../tasks/pose.md) und [Multi-Objekt-Tracking](../modes/track.md) maßgeschneidert sind. Wenn Sie daran interessiert sind, Ihre Modellarchitektur bei Ultralytics beizutragen, sehen Sie sich unseren [Beitragenden-Leitfaden](../../help/contributing.md) an. |
||||
|
||||
!!! Note "Hinweis" |
||||
|
||||
🚧 Unsere Dokumentation in verschiedenen Sprachen ist derzeit im Aufbau und wir arbeiten hart daran, sie zu verbessern. Vielen Dank für Ihre Geduld! 🙏 |
||||
|
||||
## Vorgestellte Modelle |
||||
|
||||
Hier sind einige der wichtigsten unterstützten Modelle: |
||||
|
||||
1. **[YOLOv3](yolov3.md)**: Die dritte Iteration der YOLO-Modellfamilie, ursprünglich von Joseph Redmon, bekannt für ihre effiziente Echtzeit-Objekterkennungsfähigkeiten. |
||||
2. **[YOLOv4](yolov4.md)**: Ein dunkelnetz-natives Update von YOLOv3, veröffentlicht von Alexey Bochkovskiy im Jahr 2020. |
||||
3. **[YOLOv5](yolov5.md)**: Eine verbesserte Version der YOLO-Architektur von Ultralytics, die bessere Leistungs- und Geschwindigkeitskompromisse im Vergleich zu früheren Versionen bietet. |
||||
4. **[YOLOv6](yolov6.md)**: Veröffentlicht von [Meituan](https://about.meituan.com/) im Jahr 2022 und in vielen autonomen Lieferrobotern des Unternehmens im Einsatz. |
||||
5. **[YOLOv7](yolov7.md)**: Aktualisierte YOLO-Modelle, die 2022 von den Autoren von YOLOv4 veröffentlicht wurden. |
||||
6. **[YOLOv8](yolov8.md) NEU 🚀**: Die neueste Version der YOLO-Familie, mit erweiterten Fähigkeiten wie Instanzsegmentierung, Pose/Schlüsselpunktschätzung und Klassifizierung. |
||||
7. **[Segment Anything Model (SAM)](sam.md)**: Metas Segment Anything Model (SAM). |
||||
8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: MobileSAM für mobile Anwendungen, von der Kyung Hee University. |
||||
9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: FastSAM von der Image & Video Analysis Group, Institute of Automation, Chinesische Akademie der Wissenschaften. |
||||
10. **[YOLO-NAS](yolo-nas.md)**: YOLO Neural Architecture Search (NAS) Modelle. |
||||
11. **[Realtime Detection Transformers (RT-DETR)](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>Anschauen:</strong> Führen Sie Ultralytics YOLO-Modelle in nur wenigen Codezeilen aus. |
||||
</p> |
||||
|
||||
## Einstieg: Nutzungbeispiele |
||||
|
||||
Dieses Beispiel bietet einfache YOLO-Trainings- und Inferenzbeispiele. Für vollständige Dokumentationen über diese und andere [Modi](../modes/index.md) siehe die Dokumentationsseiten [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md). |
||||
|
||||
Beachten Sie, dass das folgende Beispiel für YOLOv8 [Detect](../tasks/detect.md) Modelle zur Objekterkennung ist. Für zusätzliche unterstützte Aufgaben siehe die Dokumentation zu [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) und [Pose](../tasks/pose.md). |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
|
||||
Vorgefertigte PyTorch `*.pt` Modelle sowie Konfigurationsdateien `*.yaml` können den Klassen `YOLO()`, `SAM()`, `NAS()` und `RTDETR()` übergeben werden, um eine Modellinstanz in Python zu erstellen: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Laden eines COCO-vortrainierten YOLOv8n Modells |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Modellinformationen anzeigen (optional) |
||||
model.info() |
||||
|
||||
# Model auf dem COCO8-Beispieldatensatz für 100 Epochen trainieren |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Inferenz mit dem YOLOv8n Modell auf das Bild 'bus.jpg' ausführen |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
CLI-Befehle sind verfügbar, um die Modelle direkt auszuführen: |
||||
|
||||
```bash |
||||
# Ein COCO-vortrainiertes YOLOv8n Modell laden und auf dem COCO8-Beispieldatensatz für 100 Epochen trainieren |
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Ein COCO-vortrainiertes YOLOv8n Modell laden und Inferenz auf das Bild 'bus.jpg' ausführen |
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Neue Modelle beitragen |
||||
|
||||
Sind Sie daran interessiert, Ihr Modell bei Ultralytics beizutragen? Großartig! Wir sind immer offen dafür, unser Modellportfolio zu erweitern. |
||||
|
||||
1. **Repository forken**: Beginnen Sie mit dem Forken des [Ultralytics GitHub-Repositorys](https://github.com/ultralytics/ultralytics). |
||||
|
||||
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 entsprechend den in unserem [Beitragenden-Leitfaden](../../help/contributing.md) bereitgestellten Kodierungsstandards und Richtlinien hinzu. |
||||
|
||||
4. **Gründlich testen**: Stellen Sie sicher, dass Sie Ihr Modell sowohl isoliert als auch als Teil des Pipelines gründlich testen. |
||||
|
||||
5. **Eine Pull-Anfrage erstellen**: Sobald Sie mit Ihrem Modell zufrieden sind, erstellen Sie eine Pull-Anfrage zum Hauptrepository zur Überprüfung. |
||||
|
||||
6. **Code-Review & Zusammenführen**: Nach der Überprüfung, wenn Ihr Modell unseren Kriterien entspricht, wird es in das Hauptrepository zusammengeführt. |
||||
|
||||
Für detaillierte Schritte konsultieren Sie unseren [Beitragenden-Leitfaden](../../help/contributing.md). |
||||
@ -1,116 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erfahren Sie mehr über MobileSAM, dessen Implementierung, den Vergleich mit dem Original-SAM und wie Sie es im Ultralytics-Framework herunterladen und testen können. Verbessern Sie Ihre mobilen Anwendungen heute. |
||||
keywords: MobileSAM, Ultralytics, SAM, mobile Anwendungen, Arxiv, GPU, API, Bildencoder, Maskendekoder, Modell-Download, Testmethode |
||||
--- |
||||
|
||||
 |
||||
|
||||
# Mobile Segment Anything (MobileSAM) |
||||
|
||||
Das MobileSAM-Paper ist jetzt auf [arXiv](https://arxiv.org/pdf/2306.14289.pdf) verfügbar. |
||||
|
||||
Eine Demonstration von MobileSAM, das auf einer CPU ausgeführt wird, finden Sie unter diesem [Demo-Link](https://huggingface.co/spaces/dhkim2810/MobileSAM). Die Leistung auf einer Mac i5 CPU beträgt etwa 3 Sekunden. Auf der Hugging Face-Demo führt die Benutzeroberfläche und CPUs mit niedrigerer Leistung zu einer langsameren Reaktion, aber die Funktion bleibt effektiv. |
||||
|
||||
MobileSAM ist in verschiedenen Projekten implementiert, darunter [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling) und [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D). |
||||
|
||||
MobileSAM wird mit einem einzigen GPU und einem 100K-Datensatz (1% der Originalbilder) in weniger als einem Tag trainiert. Der Code für dieses Training wird in Zukunft verfügbar gemacht. |
||||
|
||||
## Verfügbarkeit von Modellen, unterstützte Aufgaben und Betriebsarten |
||||
|
||||
Die folgende Tabelle zeigt die verfügbaren Modelle mit ihren spezifischen vortrainierten Gewichten, die unterstützten Aufgaben und ihre Kompatibilität mit unterschiedlichen Betriebsarten wie [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md). Unterstützte Betriebsarten werden mit ✅-Emojis und nicht unterstützte Betriebsarten mit ❌-Emojis angezeigt. |
||||
|
||||
| Modelltyp | Vortrainierte Gewichte | Unterstützte Aufgaben | Inferenz | Validierung | Training | Export | |
||||
|-----------|------------------------|---------------------------------------------|----------|-------------|----------|--------| |
||||
| MobileSAM | `mobile_sam.pt` | [Instanzsegmentierung](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Anpassung von SAM zu MobileSAM |
||||
|
||||
Da MobileSAM die gleiche Pipeline wie das Original-SAM beibehält, haben wir das ursprüngliche Preprocessing, Postprocessing und alle anderen Schnittstellen eingebunden. Personen, die derzeit das ursprüngliche SAM verwenden, können daher mit minimalem Aufwand zu MobileSAM wechseln. |
||||
|
||||
MobileSAM bietet vergleichbare Leistungen wie das ursprüngliche SAM und behält dieselbe Pipeline, mit Ausnahme eines Wechsels des Bildencoders. Konkret ersetzen wir den ursprünglichen, leistungsstarken ViT-H-Encoder (632M) durch einen kleineren Tiny-ViT-Encoder (5M). Auf einem einzelnen GPU arbeitet MobileSAM in etwa 12 ms pro Bild: 8 ms auf dem Bildencoder und 4 ms auf dem Maskendekoder. |
||||
|
||||
Die folgende Tabelle bietet einen Vergleich der Bildencoder, die auf ViT basieren: |
||||
|
||||
| Bildencoder | Original-SAM | MobileSAM | |
||||
|-----------------|--------------|-----------| |
||||
| Parameter | 611M | 5M | |
||||
| Geschwindigkeit | 452ms | 8ms | |
||||
|
||||
Sowohl das ursprüngliche SAM als auch MobileSAM verwenden denselben promptgeführten Maskendekoder: |
||||
|
||||
| Maskendekoder | Original-SAM | MobileSAM | |
||||
|-----------------|--------------|-----------| |
||||
| Parameter | 3.876M | 3.876M | |
||||
| Geschwindigkeit | 4ms | 4ms | |
||||
|
||||
Hier ist ein Vergleich der gesamten Pipeline: |
||||
|
||||
| Gesamte Pipeline (Enc+Dec) | Original-SAM | MobileSAM | |
||||
|----------------------------|--------------|-----------| |
||||
| Parameter | 615M | 9.66M | |
||||
| Geschwindigkeit | 456ms | 12ms | |
||||
|
||||
Die Leistung von MobileSAM und des ursprünglichen SAM werden sowohl mit einem Punkt als auch mit einem Kasten als Prompt demonstriert. |
||||
|
||||
 |
||||
|
||||
 |
||||
|
||||
Mit seiner überlegenen Leistung ist MobileSAM etwa 5-mal kleiner und 7-mal schneller als das aktuelle FastSAM. Weitere Details finden Sie auf der [MobileSAM-Projektseite](https://github.com/ChaoningZhang/MobileSAM). |
||||
|
||||
## Testen von MobileSAM in Ultralytics |
||||
|
||||
Wie beim ursprünglichen SAM bieten wir eine unkomplizierte Testmethode in Ultralytics an, einschließlich Modi für Punkt- und Kasten-Prompts. |
||||
|
||||
### Modell-Download |
||||
|
||||
Sie können das Modell [hier](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt) herunterladen. |
||||
|
||||
### Punkt-Prompt |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Laden Sie das Modell |
||||
model = SAM('mobile_sam.pt') |
||||
|
||||
# Vorhersage einer Segmentierung basierend auf einem Punkt-Prompt |
||||
model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1]) |
||||
``` |
||||
|
||||
### Kasten-Prompt |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Laden Sie das Modell |
||||
model = SAM('mobile_sam.pt') |
||||
|
||||
# Vorhersage einer Segmentierung basierend auf einem Kasten-Prompt |
||||
model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709]) |
||||
``` |
||||
|
||||
Wir haben `MobileSAM` und `SAM` mit derselben API implementiert. Für weitere Verwendungsinformationen sehen Sie bitte die [SAM-Seite](sam.md). |
||||
|
||||
## Zitate und Danksagungen |
||||
|
||||
Wenn Sie MobileSAM in Ihrer Forschungs- oder Entwicklungsarbeit nützlich finden, zitieren Sie bitte unser Paper: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{mobile_sam, |
||||
title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications}, |
||||
author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon}, |
||||
journal={arXiv preprint arXiv:2306.14289}, |
||||
year={2023} |
||||
} |
||||
@ -1,93 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Entdecken Sie die Funktionen und Vorteile von RT-DETR, dem effizienten und anpassungsfähigen Echtzeitobjektdetektor von Baidu, der von Vision Transformers unterstützt wird, einschließlich vortrainierter Modelle. |
||||
keywords: RT-DETR, Baidu, Vision Transformers, Objekterkennung, Echtzeitleistung, CUDA, TensorRT, IoU-bewusste Query-Auswahl, Ultralytics, Python API, PaddlePaddle |
||||
--- |
||||
|
||||
# Baidus RT-DETR: Ein Echtzeit-Objektdetektor auf Basis von Vision Transformers |
||||
|
||||
## Überblick |
||||
|
||||
Der Real-Time Detection Transformer (RT-DETR), entwickelt von Baidu, ist ein moderner End-to-End-Objektdetektor, der Echtzeitleistung mit hoher Genauigkeit bietet. Er nutzt die Leistung von Vision Transformers (ViT), um Multiskalen-Funktionen effizient zu verarbeiten, indem intra-skaliere Interaktion und eine skalenübergreifende Fusion entkoppelt werden. RT-DETR ist hoch anpassungsfähig und unterstützt flexible Anpassung der Inferenzgeschwindigkeit durch Verwendung verschiedener Decoder-Schichten ohne erneutes Training. Das Modell übertrifft viele andere Echtzeit-Objektdetektoren auf beschleunigten Backends wie CUDA mit TensorRT. |
||||
|
||||
 |
||||
**Übersicht von Baidus RT-DETR.** Die Modellarchitekturdiagramm des RT-DETR zeigt die letzten drei Stufen des Backbone {S3, S4, S5} als Eingabe für den Encoder. Der effiziente Hybrid-Encoder verwandelt Multiskalen-Funktionen durch intraskalare Feature-Interaktion (AIFI) und das skalenübergreifende Feature-Fusion-Modul (CCFM) in eine Sequenz von Bildmerkmalen. Die IoU-bewusste Query-Auswahl wird verwendet, um eine feste Anzahl von Bildmerkmalen als anfängliche Objekt-Queries für den Decoder auszuwählen. Der Decoder optimiert iterativ Objekt-Queries, um Boxen und Vertrauenswerte zu generieren ([Quelle](https://arxiv.org/pdf/2304.08069.pdf)). |
||||
|
||||
### Hauptmerkmale |
||||
|
||||
- **Effizienter Hybrid-Encoder:** Baidus RT-DETR verwendet einen effizienten Hybrid-Encoder, der Multiskalen-Funktionen verarbeitet, indem intra-skaliere Interaktion und eine skalenübergreifende Fusion entkoppelt werden. Dieses einzigartige Design auf Basis von Vision Transformers reduziert die Rechenkosten und ermöglicht die Echtzeit-Objekterkennung. |
||||
- **IoU-bewusste Query-Auswahl:** Baidus RT-DETR verbessert die Initialisierung von Objekt-Queries, indem IoU-bewusste Query-Auswahl verwendet wird. Dadurch kann das Modell sich auf die relevantesten Objekte in der Szene konzentrieren und die Erkennungsgenauigkeit verbessern. |
||||
- **Anpassbare Inferenzgeschwindigkeit:** Baidus RT-DETR ermöglicht flexible Anpassungen der Inferenzgeschwindigkeit durch Verwendung unterschiedlicher Decoder-Schichten ohne erneutes Training. Diese Anpassungsfähigkeit erleichtert den praktischen Einsatz in verschiedenen Echtzeit-Objekterkennungsszenarien. |
||||
|
||||
## Vortrainierte Modelle |
||||
|
||||
Die Ultralytics Python API bietet vortrainierte PaddlePaddle RT-DETR-Modelle in verschiedenen Skalierungen: |
||||
|
||||
- RT-DETR-L: 53,0% AP auf COCO val2017, 114 FPS auf T4 GPU |
||||
- RT-DETR-X: 54,8% AP auf COCO val2017, 74 FPS auf T4 GPU |
||||
|
||||
## Beispiele für die Verwendung |
||||
|
||||
Das folgende Beispiel enthält einfache Trainings- und Inferenzbeispiele für RT-DETRR. Für die vollständige Dokumentation zu diesen und anderen [Modi](../modes/index.md) siehe die Dokumentationsseiten für [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md). |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import RTDETR |
||||
|
||||
# Laden Sie ein vortrainiertes RT-DETR-l Modell auf COCO |
||||
model = RTDETR('rtdetr-l.pt') |
||||
|
||||
# Zeigen Sie Informationen über das Modell an (optional) |
||||
model.info() |
||||
|
||||
# Trainieren Sie das Modell auf dem COCO8-Beispiel-Datensatz für 100 Epochen |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Führen Sie die Inferenz mit dem RT-DETR-l Modell auf dem Bild 'bus.jpg' aus |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Laden Sie ein vortrainiertes RT-DETR-l Modell auf COCO und trainieren Sie es auf dem COCO8-Beispiel-Datensatz für 100 Epochen |
||||
yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Laden Sie ein vortrainiertes RT-DETR-l Modell auf COCO und führen Sie die Inferenz auf dem Bild 'bus.jpg' aus |
||||
yolo predict model=rtdetr-l.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Unterstützte Aufgaben und Modi |
||||
|
||||
In dieser Tabelle werden die Modelltypen, die spezifischen vortrainierten Gewichte, die von jedem Modell unterstützten Aufgaben und die verschiedenen Modi ([Train](../modes/train.md), [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)), die unterstützt werden, mit ✅-Emoji angezeigt. |
||||
|
||||
| Modelltyp | Vortrainierte Gewichte | Unterstützte Aufgaben | Inferenz | Validierung | Training | Exportieren | |
||||
|--------------------|------------------------|---------------------------------------|----------|-------------|----------|-------------| |
||||
| RT-DETR Groß | `rtdetr-l.pt` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| RT-DETR Extra-Groß | `rtdetr-x.pt` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
## Zitate und Danksagungen |
||||
|
||||
Wenn Sie Baidus RT-DETR in Ihrer Forschungs- oder Entwicklungsarbeit verwenden, zitieren Sie bitte das [ursprüngliche Papier](https://arxiv.org/abs/2304.08069): |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{lv2023detrs, |
||||
title={DETRs Beat YOLOs on Real-time Object Detection}, |
||||
author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu}, |
||||
year={2023}, |
||||
eprint={2304.08069}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Wir möchten Baidu und dem [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection)-Team für die Erstellung und Pflege dieser wertvollen Ressource für die Computer-Vision-Community danken. Ihre Beitrag zum Gebiet der Entwicklung des Echtzeit-Objekterkenners auf Basis von Vision Transformers, RT-DETR, wird sehr geschätzt. |
||||
|
||||
*Keywords: RT-DETR, Transformer, ViT, Vision Transformers, Baidu RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, Objekterkennung in Echtzeit, objekterkennung basierend auf Vision Transformers, vortrainierte PaddlePaddle RT-DETR Modelle, Verwendung von Baidus RT-DETR, Ultralytics Python API* |
||||
@ -1,226 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erkunden Sie das innovative Segment Anything Model (SAM) von Ultralytics, das Echtzeit-Bildsegmentierung ermöglicht. Erfahren Sie mehr über die promptable Segmentierung, die Zero-Shot-Performance und die Anwendung. |
||||
keywords: Ultralytics, Bildsegmentierung, Segment Anything Model, SAM, SA-1B-Datensatz, Echtzeit-Performance, Zero-Shot-Transfer, Objekterkennung, Bildanalyse, maschinelles Lernen |
||||
--- |
||||
|
||||
# Segment Anything Model (SAM) |
||||
|
||||
Willkommen an der Spitze der Bildsegmentierung mit dem Segment Anything Model (SAM). Dieses revolutionäre Modell hat mit promptabler Bildsegmentierung und Echtzeit-Performance neue Standards in diesem Bereich gesetzt. |
||||
|
||||
## Einführung in SAM: Das Segment Anything Model |
||||
|
||||
Das Segment Anything Model (SAM) ist ein innovatives Bildsegmentierungsmodell, das promptable Segmentierung ermöglicht und so eine beispiellose Vielseitigkeit bei der Bildanalyse bietet. SAM bildet das Herzstück der Segment Anything Initiative, einem bahnbrechenden Projekt, das ein neuartiges Modell, eine neue Aufgabe und einen neuen Datensatz für die Bildsegmentierung einführt. |
||||
|
||||
Dank seiner fortschrittlichen Konstruktion kann SAM sich an neue Bildverteilungen und Aufgaben anpassen, auch ohne Vorwissen. Das wird als Zero-Shot-Transfer bezeichnet. Trainiert wurde SAM auf dem umfangreichen [SA-1B-Datensatz](https://ai.facebook.com/datasets/segment-anything/), der über 1 Milliarde Masken auf 11 Millionen sorgfältig kuratierten Bildern enthält. SAM hat beeindruckende Zero-Shot-Performance gezeigt und in vielen Fällen frühere vollständig überwachte Ergebnisse übertroffen. |
||||
|
||||
 |
||||
Beispielimagen mit überlagernden Masken aus unserem neu eingeführten Datensatz SA-1B. SA-1B enthält 11 Millionen diverse, hochauflösende, lizenzierte und die Privatsphäre schützende Bilder und 1,1 Milliarden qualitativ hochwertige Segmentierungsmasken. Diese wurden vollautomatisch von SAM annotiert und sind nach menschlichen Bewertungen und zahlreichen Experimenten von hoher Qualität und Vielfalt. Die Bilder sind nach der Anzahl der Masken pro Bild gruppiert (im Durchschnitt sind es etwa 100 Masken pro Bild). |
||||
|
||||
## Hauptmerkmale des Segment Anything Model (SAM) |
||||
|
||||
- **Promptable Segmentierungsaufgabe:** SAM wurde mit der Ausführung einer promptable Segmentierungsaufgabe entwickelt, wodurch es valide Segmentierungsmasken aus beliebigen Prompts generieren kann, z. B. räumlichen oder textuellen Hinweisen zur Identifizierung eines Objekts. |
||||
- **Fortgeschrittene Architektur:** Das Segment Anything Model verwendet einen leistungsfähigen Bild-Encoder, einen Prompt-Encoder und einen leichten Masken-Decoder. Diese einzigartige Architektur ermöglicht flexibles Prompting, Echtzeitmaskenberechnung und Berücksichtigung von Mehrdeutigkeiten in Segmentierungsaufgaben. |
||||
- **Der SA-1B-Datensatz:** Eingeführt durch das Segment Anything Projekt, enthält der SA-1B-Datensatz über 1 Milliarde Masken auf 11 Millionen Bildern. Als bisher größter Segmentierungsdatensatz liefert er SAM eine vielfältige und umfangreiche Datenquelle für das Training. |
||||
- **Zero-Shot-Performance:** SAM zeigt herausragende Zero-Shot-Performance in verschiedenen Segmentierungsaufgaben und ist damit ein einsatzbereites Werkzeug für vielfältige Anwendungen mit minimalem Bedarf an prompt engineering. |
||||
|
||||
Für eine detaillierte Betrachtung des Segment Anything Models und des SA-1B-Datensatzes besuchen Sie bitte die [Segment Anything Website](https://segment-anything.com) und lesen Sie das Forschungspapier [Segment Anything](https://arxiv.org/abs/2304.02643). |
||||
|
||||
## Verfügbare Modelle, unterstützte Aufgaben und Betriebsmodi |
||||
|
||||
Diese Tabelle zeigt die verfügbaren Modelle mit ihren spezifischen vortrainierten Gewichten, die unterstützten Aufgaben und ihre Kompatibilität mit verschiedenen Betriebsmodi wie [Inference](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md), wobei ✅ Emojis für unterstützte Modi und ❌ Emojis für nicht unterstützte Modi verwendet werden. |
||||
|
||||
| Modelltyp | Vortrainierte Gewichte | Unterstützte Aufgaben | Inference | Validierung | Training | Export | |
||||
|-----------|------------------------|---------------------------------------------|-----------|-------------|----------|--------| |
||||
| SAM base | `sam_b.pt` | [Instanzsegmentierung](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
| SAM large | `sam_l.pt` | [Instanzsegmentierung](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Wie man SAM verwendet: Vielseitigkeit und Power in der Bildsegmentierung |
||||
|
||||
Das Segment Anything Model kann für eine Vielzahl von Aufgaben verwendet werden, die über die Trainingsdaten hinausgehen. Dazu gehören Kantenerkennung, Generierung von Objektvorschlägen, Instanzsegmentierung und vorläufige Text-to-Mask-Vorhersage. Mit prompt engineering kann SAM sich schnell an neue Aufgaben und Datenverteilungen anpassen und sich so als vielseitiges und leistungsstarkes Werkzeug für alle Anforderungen der Bildsegmentierung etablieren. |
||||
|
||||
### Beispiel für SAM-Vorhersage |
||||
|
||||
!!! Example "Segmentierung mit Prompts" |
||||
|
||||
Bildsegmentierung mit gegebenen Prompts. |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Modell laden |
||||
model = SAM('sam_b.pt') |
||||
|
||||
# Modellinformationen anzeigen (optional) |
||||
model.info() |
||||
|
||||
# Inferenz mit Bounding Box Prompt |
||||
model('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709]) |
||||
|
||||
# Inferenz mit Point Prompt |
||||
model('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1]) |
||||
``` |
||||
|
||||
!!! Example "Alles segmentieren" |
||||
|
||||
Das ganze Bild segmentieren. |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Modell laden |
||||
model = SAM('sam_b.pt') |
||||
|
||||
# Modellinformationen anzeigen (optional) |
||||
model.info() |
||||
|
||||
# Inferenz |
||||
model('Pfad/zum/Bild.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Inferenz mit einem SAM-Modell |
||||
yolo predict model=sam_b.pt source=Pfad/zum/Bild.jpg |
||||
``` |
||||
|
||||
- Die Logik hier besteht darin, das gesamte Bild zu segmentieren, wenn keine Prompts (Bounding Box/Point/Maske) übergeben werden. |
||||
|
||||
!!! Example "Beispiel SAMPredictor" |
||||
|
||||
Dadurch können Sie das Bild einmal festlegen und mehrmals Inferenz mit Prompts ausführen, ohne den Bild-Encoder mehrfach auszuführen. |
||||
|
||||
=== "Prompt-Inferenz" |
||||
|
||||
```python |
||||
from ultralytics.models.sam import Predictor as SAMPredictor |
||||
|
||||
# SAMPredictor erstellen |
||||
overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt") |
||||
predictor = SAMPredictor(overrides=overrides) |
||||
|
||||
# Bild festlegen |
||||
predictor.set_image("ultralytics/assets/zidane.jpg") # Festlegung mit Bild-Datei |
||||
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # Festlegung mit np.ndarray |
||||
results = predictor(bboxes=[439, 437, 524, 709]) |
||||
results = predictor(points=[900, 370], labels=[1]) |
||||
|
||||
# Bild zurücksetzen |
||||
predictor.reset_image() |
||||
``` |
||||
|
||||
Alles segmentieren mit zusätzlichen Argumenten. |
||||
|
||||
=== "Alles segmentieren" |
||||
|
||||
```python |
||||
from ultralytics.models.sam import Predictor as SAMPredictor |
||||
|
||||
# SAMPredictor erstellen |
||||
overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt") |
||||
predictor = SAMPredictor(overrides=overrides) |
||||
|
||||
# Mit zusätzlichen Argumenten segmentieren |
||||
results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64) |
||||
``` |
||||
|
||||
- Weitere zusätzliche Argumente für `Alles segmentieren` finden Sie in der [`Predictor/generate` Referenz](../../../reference/models/sam/predict.md). |
||||
|
||||
## Vergleich von SAM und YOLOv8 |
||||
|
||||
Hier vergleichen wir Meta's kleinstes SAM-Modell, SAM-b, mit Ultralytics kleinstem Segmentierungsmodell, [YOLOv8n-seg](../tasks/segment.md): |
||||
|
||||
| Modell | Größe | Parameter | Geschwindigkeit (CPU) | |
||||
|------------------------------------------------|-------------------------------|------------------------------|----------------------------------------| |
||||
| Meta's SAM-b | 358 MB | 94,7 M | 51096 ms/pro Bild | |
||||
| [MobileSAM](mobile-sam.md) | 40,7 MB | 10,1 M | 46122 ms/pro Bild | |
||||
| [FastSAM-s](fast-sam.md) mit YOLOv8-Backbone | 23,7 MB | 11,8 M | 115 ms/pro Bild | |
||||
| Ultralytics [YOLOv8n-seg](../tasks/segment.md) | **6,7 MB** (53,4-mal kleiner) | **3,4 M** (27,9-mal kleiner) | **59 ms/pro Bild** (866-mal schneller) | |
||||
|
||||
Dieser Vergleich zeigt die Größen- und Geschwindigkeitsunterschiede zwischen den Modellen. Während SAM einzigartige Fähigkeiten für die automatische Segmentierung bietet, konkurriert es nicht direkt mit YOLOv8-Segmentierungsmodellen, die kleiner, schneller und effizienter sind. |
||||
|
||||
Die Tests wurden auf einem Apple M2 MacBook aus dem Jahr 2023 mit 16 GB RAM durchgeführt. Um diesen Test zu reproduzieren: |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM, SAM, YOLO |
||||
|
||||
# SAM-b profilieren |
||||
model = SAM('sam_b.pt') |
||||
model.info() |
||||
model('ultralytics/assets') |
||||
|
||||
# MobileSAM profilieren |
||||
model = SAM('mobile_sam.pt') |
||||
model.info() |
||||
model('ultralytics/assets') |
||||
|
||||
# FastSAM-s profilieren |
||||
model = FastSAM('FastSAM-s.pt') |
||||
model.info() |
||||
model('ultralytics/assets') |
||||
|
||||
# YOLOv8n-seg profilieren |
||||
model = YOLO('yolov8n-seg.pt') |
||||
model.info() |
||||
model('ultralytics/assets') |
||||
``` |
||||
|
||||
## Auto-Annotierung: Der schnelle Weg zu Segmentierungsdatensätzen |
||||
|
||||
Die Auto-Annotierung ist eine wichtige Funktion von SAM, mit der Benutzer mithilfe eines vortrainierten Detektionsmodells einen [Segmentierungsdatensatz](https://docs.ultralytics.com/datasets/segment) generieren können. Diese Funktion ermöglicht eine schnelle und genaue Annotation einer großen Anzahl von Bildern, ohne dass zeitaufwändiges manuelles Labeling erforderlich ist. |
||||
|
||||
### Generieren Sie Ihren Segmentierungsdatensatz mit einem Detektionsmodell |
||||
|
||||
Um Ihren Datensatz mit dem Ultralytics-Framework automatisch zu annotieren, verwenden Sie die `auto_annotate` Funktion wie folgt: |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics.data.annotator import auto_annotate |
||||
|
||||
auto_annotate(data="Pfad/zum/Bilderordner", det_model="yolov8x.pt", sam_model='sam_b.pt') |
||||
``` |
||||
|
||||
| Argument | Typ | Beschreibung | Standard | |
||||
|------------|---------------------|---------------------------------------------------------------------------------------------------------------------------|--------------| |
||||
| data | str | Pfad zu einem Ordner, der die zu annotierenden Bilder enthält. | | |
||||
| det_model | str, optional | Vortrainiertes YOLO-Detektionsmodell. Standardmäßig 'yolov8x.pt'. | 'yolov8x.pt' | |
||||
| sam_model | str, optional | Vortrainiertes SAM-Segmentierungsmodell. Standardmäßig 'sam_b.pt'. | 'sam_b.pt' | |
||||
| device | str, optional | Gerät, auf dem die Modelle ausgeführt werden. Standardmäßig ein leerer String (CPU oder GPU, falls verfügbar). | | |
||||
| output_dir | str, None, optional | Verzeichnis zum Speichern der annotierten Ergebnisse. Standardmäßig ein 'labels'-Ordner im selben Verzeichnis wie 'data'. | None | |
||||
|
||||
Die `auto_annotate` Funktion nimmt den Pfad zu Ihren Bildern entgegen, mit optionalen Argumenten für das vortrainierte Detektions- und SAM-Segmentierungsmodell, das Gerät, auf dem die Modelle ausgeführt werden sollen, und das Ausgabeverzeichnis, in dem die annotierten Ergebnisse gespeichert werden sollen. |
||||
|
||||
Die Auto-Annotierung mit vortrainierten Modellen kann die Zeit und den Aufwand für die Erstellung hochwertiger Segmentierungsdatensätze erheblich reduzieren. Diese Funktion ist besonders vorteilhaft für Forscher und Entwickler, die mit großen Bildersammlungen arbeiten. Sie ermöglicht es ihnen, sich auf die Modellentwicklung und -bewertung zu konzentrieren, anstatt auf die manuelle Annotation. |
||||
|
||||
## Zitate und Danksagungen |
||||
|
||||
Wenn Sie SAM in Ihrer Forschungs- oder Entwicklungsarbeit nützlich finden, erwägen Sie bitte, unser Paper zu zitieren: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{kirillov2023segment, |
||||
title={Segment Anything}, |
||||
author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollár and Ross Girshick}, |
||||
year={2023}, |
||||
eprint={2304.02643}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Wir möchten Meta AI für die Erstellung und Pflege dieser wertvollen Ressource für die Computer Vision Community danken. |
||||
|
||||
*Stichworte: Segment Anything, Segment Anything Model, SAM, Meta SAM, Bildsegmentierung, Promptable Segmentierung, Zero-Shot-Performance, SA-1B-Datensatz, fortschrittliche Architektur, Auto-Annotierung, Ultralytics, vortrainierte Modelle, SAM Base, SAM Large, Instanzsegmentierung, Computer Vision, Künstliche Intelligenz, maschinelles Lernen, Datenannotation, Segmentierungsmasken, Detektionsmodell, YOLO Detektionsmodell, Bibtex, Meta AI.* |
||||
@ -1,121 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erfahren Sie mehr über YOLO-NAS, ein herausragendes Modell für die Objekterkennung. Erfahren Sie mehr über seine Funktionen, vortrainierte Modelle, Nutzung mit der Ultralytics Python API und vieles mehr. |
||||
keywords: YOLO-NAS, Deci AI, Objekterkennung, Deep Learning, Neural Architecture Search, Ultralytics Python API, YOLO-Modell, vortrainierte Modelle, Quantisierung, Optimierung, COCO, Objects365, Roboflow 100 |
||||
--- |
||||
|
||||
# YOLO-NAS |
||||
|
||||
## Übersicht |
||||
|
||||
Entwickelt von Deci AI, ist YOLO-NAS ein bahnbrechendes Modell für die Objekterkennung. Es ist das Ergebnis fortschrittlicher Technologien zur Neural Architecture Search und wurde sorgfältig entworfen, um die Einschränkungen früherer YOLO-Modelle zu überwinden. Mit signifikanten Verbesserungen in der Quantisierungsunterstützung und Abwägung von Genauigkeit und Latenz stellt YOLO-NAS einen großen Fortschritt in der Objekterkennung dar. |
||||
|
||||
 |
||||
**Übersicht über YOLO-NAS.** YOLO-NAS verwendet Quantisierungsblöcke und selektive Quantisierung für optimale Leistung. Das Modell weist bei der Konvertierung in seine quantisierte Version mit INT8 einen minimalen Präzisionsverlust auf, was im Vergleich zu anderen Modellen eine signifikante Verbesserung darstellt. Diese Entwicklungen führen zu einer überlegenen Architektur mit beispiellosen Fähigkeiten zur Objekterkennung und herausragender Leistung. |
||||
|
||||
### Schlüsselfunktionen |
||||
|
||||
- **Quantisierungsfreundlicher Basiselement:** YOLO-NAS führt ein neues Basiselement ein, das für Quantisierung geeignet ist und eine der wesentlichen Einschränkungen früherer YOLO-Modelle angeht. |
||||
- **Raffiniertes Training und Quantisierung:** YOLO-NAS nutzt fortschrittliche Trainingsschemata und post-training Quantisierung zur Leistungsverbesserung. |
||||
- **AutoNAC-Optimierung und Vortraining:** YOLO-NAS verwendet die AutoNAC-Optimierung und wird auf prominenten Datensätzen wie COCO, Objects365 und Roboflow 100 vortrainiert. Dieses Vortraining macht es äußerst geeignet für die Objekterkennung in Produktionsumgebungen. |
||||
|
||||
## Vortrainierte Modelle |
||||
|
||||
Erleben Sie die Leistungsfähigkeit der Objekterkennung der nächsten Generation mit den vortrainierten YOLO-NAS-Modellen von Ultralytics. Diese Modelle sind darauf ausgelegt, sowohl bei Geschwindigkeit als auch bei Genauigkeit hervorragende Leistung zu liefern. Wählen Sie aus einer Vielzahl von Optionen, die auf Ihre spezifischen Anforderungen zugeschnitten sind: |
||||
|
||||
| Modell | mAP | Latenz (ms) | |
||||
|------------------|-------|-------------| |
||||
| YOLO-NAS S | 47,5 | 3,21 | |
||||
| YOLO-NAS M | 51,55 | 5,85 | |
||||
| YOLO-NAS L | 52,22 | 7,87 | |
||||
| YOLO-NAS S INT-8 | 47,03 | 2,36 | |
||||
| YOLO-NAS M INT-8 | 51,0 | 3,78 | |
||||
| YOLO-NAS L INT-8 | 52,1 | 4,78 | |
||||
|
||||
Jede Modellvariante ist darauf ausgelegt, eine Balance zwischen Mean Average Precision (mAP) und Latenz zu bieten und Ihre Objekterkennungsaufgaben für Performance und Geschwindigkeit zu optimieren. |
||||
|
||||
## Beispiele zur Verwendung |
||||
|
||||
Ultralytics hat es einfach gemacht, YOLO-NAS-Modelle in Ihre Python-Anwendungen über unser `ultralytics` Python-Paket zu integrieren. Das Paket bietet eine benutzerfreundliche Python-API, um den Prozess zu optimieren. |
||||
|
||||
Die folgenden Beispiele zeigen, wie Sie YOLO-NAS-Modelle mit dem `ultralytics`-Paket für Inferenz und Validierung verwenden: |
||||
|
||||
### Beispiele für Inferenz und Validierung |
||||
|
||||
In diesem Beispiel validieren wir YOLO-NAS-s auf dem COCO8-Datensatz. |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
Dieses Beispiel bietet einfachen Code für Inferenz und Validierung für YOLO-NAS. Für die Verarbeitung von Inferenzergebnissen siehe den [Predict](../modes/predict.md)-Modus. Für die Verwendung von YOLO-NAS mit zusätzlichen Modi siehe [Val](../modes/val.md) und [Export](../modes/export.md). Das YOLO-NAS-Modell im `ultralytics`-Paket unterstützt kein Training. |
||||
|
||||
=== "Python" |
||||
|
||||
Vorab trainierte `*.pt`-Modelldateien von PyTorch können der Klasse `NAS()` übergeben werden, um eine Modellinstanz in Python zu erstellen: |
||||
|
||||
```python |
||||
from ultralytics import NAS |
||||
|
||||
# Laden Sie ein auf COCO vortrainiertes YOLO-NAS-s-Modell |
||||
model = NAS('yolo_nas_s.pt') |
||||
|
||||
# Modelinformationen anzeigen (optional) |
||||
model.info() |
||||
|
||||
# Validieren Sie das Modell am Beispiel des COCO8-Datensatzes |
||||
results = model.val(data='coco8.yaml') |
||||
|
||||
# Führen Sie Inferenz mit dem YOLO-NAS-s-Modell auf dem Bild 'bus.jpg' aus |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
CLI-Befehle sind verfügbar, um die Modelle direkt auszuführen: |
||||
|
||||
```bash |
||||
# Laden Sie ein auf COCO vortrainiertes YOLO-NAS-s-Modell und validieren Sie die Leistung am Beispiel des COCO8-Datensatzes |
||||
yolo val model=yolo_nas_s.pt data=coco8.yaml |
||||
|
||||
# Laden Sie ein auf COCO vortrainiertes YOLO-NAS-s-Modell und führen Sie Inferenz auf dem Bild 'bus.jpg' aus |
||||
yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Unterstützte Aufgaben und Modi |
||||
|
||||
Wir bieten drei Varianten der YOLO-NAS-Modelle an: Small (s), Medium (m) und Large (l). Jede Variante ist dazu gedacht, unterschiedliche Berechnungs- und Leistungsanforderungen zu erfüllen: |
||||
|
||||
- **YOLO-NAS-s**: Optimiert für Umgebungen mit begrenzten Rechenressourcen, bei denen Effizienz entscheidend ist. |
||||
- **YOLO-NAS-m**: Bietet einen ausgewogenen Ansatz und ist für die Objekterkennung im Allgemeinen mit höherer Genauigkeit geeignet. |
||||
- **YOLO-NAS-l**: Maßgeschneidert für Szenarien, bei denen höchste Genauigkeit gefordert ist und Rechenressourcen weniger einschränkend sind. |
||||
|
||||
Im Folgenden finden Sie eine detaillierte Übersicht über jedes Modell, einschließlich Links zu den vortrainierten Gewichten, den unterstützten Aufgaben und deren Kompatibilität mit verschiedenen Betriebsmodi. |
||||
|
||||
| Modelltyp | Vortrainierte Gewichte | Unterstützte Aufgaben | Inferenz | Validierung | Training | Export | |
||||
|------------|-----------------------------------------------------------------------------------------------|---------------------------------------|----------|-------------|----------|--------| |
||||
| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_s.pt) | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_m.pt) | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_l.pt) | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
|
||||
## Zitierungen und Danksagungen |
||||
|
||||
Wenn Sie YOLO-NAS in Ihrer Forschungs- oder Entwicklungsarbeit verwenden, zitieren Sie bitte SuperGradients: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{supergradients, |
||||
doi = {10.5281/ZENODO.7789328}, |
||||
url = {https://zenodo.org/record/7789328}, |
||||
author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}}, |
||||
title = {Super-Gradients}, |
||||
publisher = {GitHub}, |
||||
journal = {GitHub repository}, |
||||
year = {2021}, |
||||
} |
||||
``` |
||||
|
||||
Wir möchten dem [SuperGradients](https://github.com/Deci-AI/super-gradients/)-Team von Deci AI für ihre Bemühungen bei der Erstellung und Pflege dieser wertvollen Ressource für die Computer Vision Community danken. Wir sind der Meinung, dass YOLO-NAS mit seiner innovativen Architektur und seinen herausragenden Fähigkeiten zur Objekterkennung ein wichtiges Werkzeug für Entwickler und Forscher gleichermaßen wird. |
||||
|
||||
*Keywords: YOLO-NAS, Deci AI, Objekterkennung, Deep Learning, Neural Architecture Search, Ultralytics Python API, YOLO-Modell, SuperGradients, vortrainierte Modelle, quantisierungsfreundliches Basiselement, fortschrittliche Trainingsschemata, post-training Quantisierung, AutoNAC-Optimierung, COCO, Objects365, Roboflow 100* |
||||
@ -1,98 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erhalten Sie eine Übersicht über YOLOv3, YOLOv3-Ultralytics und YOLOv3u. Erfahren Sie mehr über ihre wichtigsten Funktionen, Verwendung und unterstützte Aufgaben für die Objekterkennung. |
||||
keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Objekterkennung, Inferenz, Training, Ultralytics |
||||
--- |
||||
|
||||
# YOLOv3, YOLOv3-Ultralytics und YOLOv3u |
||||
|
||||
## Übersicht |
||||
|
||||
Dieses Dokument bietet eine Übersicht über drei eng verwandte Modelle zur Objekterkennung, nämlich [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) und [YOLOv3u](https://github.com/ultralytics/ultralytics). |
||||
|
||||
1. **YOLOv3:** Dies ist die dritte Version des You Only Look Once (YOLO) Objekterkennungsalgorithmus. Ursprünglich entwickelt von Joseph Redmon, verbesserte YOLOv3 seine Vorgängermodelle durch die Einführung von Funktionen wie mehrskaligen Vorhersagen und drei verschiedenen Größen von Erkennungskernen. |
||||
|
||||
2. **YOLOv3-Ultralytics:** Dies ist die Implementierung des YOLOv3-Modells von Ultralytics. Es reproduziert die ursprüngliche YOLOv3-Architektur und bietet zusätzliche Funktionalitäten, wie die Unterstützung für weitere vortrainierte Modelle und einfachere Anpassungsoptionen. |
||||
|
||||
3. **YOLOv3u:** Dies ist eine aktualisierte Version von YOLOv3-Ultralytics, die den anchor-freien, objektfreien Split Head aus den YOLOv8-Modellen einbezieht. YOLOv3u verwendet die gleiche Backbone- und Neck-Architektur wie YOLOv3, aber mit dem aktualisierten Erkennungskopf von YOLOv8. |
||||
|
||||
 |
||||
|
||||
## Wichtigste Funktionen |
||||
|
||||
- **YOLOv3:** Einführung der Verwendung von drei unterschiedlichen Skalen für die Erkennung unter Verwendung von drei verschiedenen Größen von Erkennungskernen: 13x13, 26x26 und 52x52. Dadurch wurde die Erkennungsgenauigkeit für Objekte unterschiedlicher Größe erheblich verbessert. Darüber hinaus fügte YOLOv3 Funktionen wie Mehrfachkennzeichnungen für jeden Begrenzungsrahmen und ein besseres Feature-Extraktionsnetzwerk hinzu. |
||||
|
||||
- **YOLOv3-Ultralytics:** Ultralytics' Implementierung von YOLOv3 bietet die gleiche Leistung wie das ursprüngliche Modell, bietet jedoch zusätzliche Unterstützung für weitere vortrainierte Modelle, zusätzliche Trainingsmethoden und einfachere Anpassungsoptionen. Dadurch wird es vielseitiger und benutzerfreundlicher für praktische Anwendungen. |
||||
|
||||
- **YOLOv3u:** Dieses aktualisierte Modell enthält den anchor-freien, objektfreien Split Head aus YOLOv8. Durch die Beseitigung der Notwendigkeit vordefinierter Ankerfelder und Objektheitsscores kann dieses Entwurfsmerkmal für den Erkennungskopf die Fähigkeit des Modells verbessern, Objekte unterschiedlicher Größe und Form zu erkennen. Dadurch wird YOLOv3u robuster und genauer für Aufgaben der Objekterkennung. |
||||
|
||||
## Unterstützte Aufgaben und Modi |
||||
|
||||
Die YOLOv3-Serie, einschließlich YOLOv3, YOLOv3-Ultralytics und YOLOv3u, ist speziell für Aufgaben der Objekterkennung konzipiert. Diese Modelle sind bekannt für ihre Effektivität in verschiedenen realen Szenarien und kombinieren Genauigkeit und Geschwindigkeit. Jede Variante bietet einzigartige Funktionen und Optimierungen, die sie für eine Vielzahl von Anwendungen geeignet machen. |
||||
|
||||
Alle drei Modelle unterstützen einen umfangreichen Satz von Modi, um Vielseitigkeit in verschiedenen Phasen der Modellbereitstellung und -entwicklung zu gewährleisten. Zu diesen Modi gehören [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md), was den Benutzern ein vollständiges Toolkit für eine effektive Objekterkennung bietet. |
||||
|
||||
| Modelltyp | Unterstützte Aufgaben | Inferenz | Validierung | Training | Export | |
||||
|--------------------|---------------------------------------|----------|-------------|----------|--------| |
||||
| YOLOv3 | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv3-Ultralytics | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv3u | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Diese Tabelle bietet einen schnellen Überblick über die Fähigkeiten jeder YOLOv3-Variante und hebt ihre Vielseitigkeit und Eignung für verschiedene Aufgaben und Betriebsmodi in Workflows zur Objekterkennung hervor. |
||||
|
||||
## Beispiele zur Verwendung |
||||
|
||||
Dieses Beispiel enthält einfache Trainings- und Inferenzbeispiele für YOLOv3. Für die vollständige Dokumentation zu diesen und anderen [Modi](../modes/index.md) siehe die Seiten zur [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md). |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
|
||||
Vorgefertigte PyTorch-Modelle im `*.pt`-Format sowie Konfigurationsdateien im `*.yaml`-Format können an die `YOLO()`-Klasse übergeben werden, um eine Modellinstanz in Python zu erstellen: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Lade ein vortrainiertes YOLOv3n-Modell für COCO |
||||
model = YOLO('yolov3n.pt') |
||||
|
||||
# Zeige Informationen zum Modell an (optional) |
||||
model.info() |
||||
|
||||
# Trainiere das Modell mit dem COCO8-Beispieldatensatz für 100 Epochen |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Führe Inferenz mit dem YOLOv3n-Modell auf dem Bild "bus.jpg" durch |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
CLI-Befehle stehen zur Verfügung, um die Modelle direkt auszuführen: |
||||
|
||||
```bash |
||||
# Lade ein vortrainiertes YOLOv3n-Modell und trainiere es mit dem COCO8-Beispieldatensatz für 100 Epochen |
||||
yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Lade ein vortrainiertes YOLOv3n-Modell und führe Inferenz auf dem Bild "bus.jpg" aus |
||||
yolo predict model=yolov3n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Zitate und Anerkennungen |
||||
|
||||
Wenn Sie YOLOv3 in Ihrer Forschung verwenden, zitieren Sie bitte die ursprünglichen YOLO-Papiere und das Ultralytics YOLOv3-Repository: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{redmon2018yolov3, |
||||
title={YOLOv3: An Incremental Improvement}, |
||||
author={Redmon, Joseph and Farhadi, Ali}, |
||||
journal={arXiv preprint arXiv:1804.02767}, |
||||
year={2018} |
||||
} |
||||
``` |
||||
|
||||
Vielen Dank an Joseph Redmon und Ali Farhadi für die Entwicklung des originalen YOLOv3. |
||||
@ -1,71 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erforschen Sie unseren detaillierten Leitfaden zu YOLOv4, einem hochmodernen Echtzeit-Objektdetektor. Erfahren Sie mehr über seine architektonischen Highlights, innovativen Funktionen und Anwendungsbeispiele. |
||||
keywords: ultralytics, YOLOv4, Objekterkennung, neuronales Netzwerk, Echtzeit-Erkennung, Objektdetektor, maschinelles Lernen |
||||
--- |
||||
|
||||
# YOLOv4: Schnelle und präzise Objekterkennung |
||||
|
||||
Willkommen auf der Ultralytics-Dokumentationsseite für YOLOv4, einem hochmodernen, Echtzeit-Objektdetektor, der 2020 von Alexey Bochkovskiy unter [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet) veröffentlicht wurde. YOLOv4 wurde entwickelt, um das optimale Gleichgewicht zwischen Geschwindigkeit und Genauigkeit zu bieten und ist somit eine ausgezeichnete Wahl für viele Anwendungen. |
||||
|
||||
 |
||||
**YOLOv4 Architekturdiagramm**. Zeigt das komplexe Netzwerkdesign von YOLOv4, einschließlich der Backbone-, Neck- und Head-Komponenten sowie ihrer verbundenen Schichten für eine optimale Echtzeit-Objekterkennung. |
||||
|
||||
## Einleitung |
||||
|
||||
YOLOv4 steht für You Only Look Once Version 4. Es handelt sich um ein Echtzeit-Objekterkennungsmodell, das entwickelt wurde, um die Grenzen früherer YOLO-Versionen wie [YOLOv3](yolov3.md) und anderer Objekterkennungsmodelle zu überwinden. Im Gegensatz zu anderen konvolutionellen neuronalen Netzwerken (CNN), die auf Objekterkennung basieren, ist YOLOv4 nicht nur für Empfehlungssysteme geeignet, sondern auch für eigenständiges Prozessmanagement und Reduzierung der Benutzereingabe. Durch den Einsatz von herkömmlichen Grafikprozessoreinheiten (GPUs) ermöglicht es YOLOv4 eine Massennutzung zu einem erschwinglichen Preis und ist so konzipiert, dass es in Echtzeit auf einer herkömmlichen GPU funktioniert, wobei nur eine solche GPU für das Training erforderlich ist. |
||||
|
||||
## Architektur |
||||
|
||||
YOLOv4 nutzt mehrere innovative Funktionen, die zusammenarbeiten, um seine Leistung zu optimieren. Dazu gehören Weighted-Residual-Connections (WRC), Cross-Stage-Partial-connections (CSP), Cross mini-Batch Normalization (CmBN), Self-adversarial-training (SAT), Mish-Aktivierung, Mosaic-Datenaugmentation, DropBlock-Regularisierung und CIoU-Verlust. Diese Funktionen werden kombiniert, um erstklassige Ergebnisse zu erzielen. |
||||
|
||||
Ein typischer Objektdetektor besteht aus mehreren Teilen, darunter der Eingabe, dem Backbone, dem Neck und dem Head. Das Backbone von YOLOv4 ist auf ImageNet vorgeschult und wird zur Vorhersage von Klassen und Begrenzungsrahmen von Objekten verwendet. Das Backbone kann aus verschiedenen Modellen wie VGG, ResNet, ResNeXt oder DenseNet stammen. Der Neck-Teil des Detektors wird verwendet, um Merkmalskarten von verschiedenen Stufen zu sammeln und umfasst normalerweise mehrere Bottom-up-Pfade und mehrere Top-down-Pfade. Der Head-Teil wird schließlich zur Durchführung der endgültigen Objekterkennung und Klassifizierung verwendet. |
||||
|
||||
## Bag of Freebies |
||||
|
||||
YOLOv4 verwendet auch Methoden, die als "Bag of Freebies" bekannt sind. Dabei handelt es sich um Techniken, die die Genauigkeit des Modells während des Trainings verbessern, ohne die Kosten der Inferenz zu erhöhen. Datenaugmentation ist eine häufige Bag of Freebies-Technik, die in der Objekterkennung verwendet wird, um die Variabilität der Eingabebilder zu erhöhen und die Robustheit des Modells zu verbessern. Beispiele für Datenaugmentation sind photometrische Verzerrungen (Anpassung von Helligkeit, Kontrast, Farbton, Sättigung und Rauschen eines Bildes) und geometrische Verzerrungen (Hinzufügen von zufälliger Skalierung, Ausschnitt, Spiegelung und Rotation). Diese Techniken helfen dem Modell, sich besser an verschiedene Arten von Bildern anzupassen. |
||||
|
||||
## Funktionen und Leistung |
||||
|
||||
YOLOv4 ist für optimale Geschwindigkeit und Genauigkeit in der Objekterkennung konzipiert. Die Architektur von YOLOv4 umfasst CSPDarknet53 als Backbone, PANet als Neck und YOLOv3 als Detektionskopf. Diese Konstruktion ermöglicht es YOLOv4, beeindruckend schnelle Objekterkennungen durchzuführen und ist somit für Echtzeitanwendungen geeignet. YOLOv4 zeichnet sich auch durch Genauigkeit aus und erzielt erstklassige Ergebnisse in Objekterkennungs-Benchmarks. |
||||
|
||||
## Beispiele für die Verwendung |
||||
|
||||
Zum Zeitpunkt der Erstellung dieser Dokumentation unterstützt Ultralytics derzeit keine YOLOv4-Modelle. Daher müssen sich Benutzer, die YOLOv4 verwenden möchten, direkt an das YOLOv4 GitHub-Repository für Installations- und Verwendungshinweise wenden. |
||||
|
||||
Hier ist ein kurzer Überblick über die typischen Schritte, die Sie unternehmen könnten, um YOLOv4 zu verwenden: |
||||
|
||||
1. Besuchen Sie das YOLOv4 GitHub-Repository: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). |
||||
|
||||
2. Befolgen Sie die in der README-Datei bereitgestellten Anweisungen zur Installation. Dies beinhaltet in der Regel das Klonen des Repositories, die Installation der erforderlichen Abhängigkeiten und das Einrichten der erforderlichen Umgebungsvariablen. |
||||
|
||||
3. Sobald die Installation abgeschlossen ist, können Sie das Modell gemäß den in dem Repository bereitgestellten Verwendungshinweisen trainieren und verwenden. Dies beinhaltet in der Regel die Vorbereitung des Datensatzes, die Konfiguration der Modellparameter, das Training des Modells und die anschließende Verwendung des trainierten Modells zur Durchführung der Objekterkennung. |
||||
|
||||
Bitte beachten Sie, dass die spezifischen Schritte je nach Ihrer spezifischen Anwendung und dem aktuellen Stand des YOLOv4-Repositories variieren können. Es wird daher dringend empfohlen, sich direkt an die Anweisungen im YOLOv4-GitHub-Repository zu halten. |
||||
|
||||
Wir bedauern etwaige Unannehmlichkeiten und werden uns bemühen, dieses Dokument mit Verwendungsbeispielen für Ultralytics zu aktualisieren, sobald die Unterstützung für YOLOv4 implementiert ist. |
||||
|
||||
## Fazit |
||||
|
||||
YOLOv4 ist ein leistungsstarkes und effizientes Modell zur Objekterkennung, das eine Balance zwischen Geschwindigkeit und Genauigkeit bietet. Durch den Einsatz einzigartiger Funktionen und Bag of Freebies-Techniken während des Trainings erzielt es hervorragende Ergebnisse in Echtzeit-Objekterkennungsaufgaben. YOLOv4 kann von jedem mit einer herkömmlichen GPU trainiert und verwendet werden, was es für eine Vielzahl von Anwendungen zugänglich und praktisch macht. |
||||
|
||||
## Zitate und Anerkennungen |
||||
|
||||
Wir möchten den Autoren von YOLOv4 für ihren bedeutenden Beitrag auf dem Gebiet der Echtzeit-Objekterkennung danken: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{bochkovskiy2020yolov4, |
||||
title={YOLOv4: Optimal Speed and Accuracy of Object Detection}, |
||||
author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao}, |
||||
year={2020}, |
||||
eprint={2004.10934}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Die originale YOLOv4-Publikation finden Sie auf [arXiv](https://arxiv.org/abs/2004.10934). Die Autoren haben ihre Arbeit öffentlich zugänglich gemacht und der Code kann auf [GitHub](https://github.com/AlexeyAB/darknet) abgerufen werden. Wir schätzen ihre Bemühungen, das Fachgebiet voranzubringen und ihre Arbeit der breiteren Community zugänglich zu machen. |
||||
@ -1,113 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Entdecken Sie YOLOv5u, eine verbesserte Version des YOLOv5-Modells mit einem optimierten Verhältnis von Genauigkeit und Geschwindigkeit sowie zahlreiche vorab trainierte Modelle für verschiedene Objekterkennungsaufgaben. |
||||
keywords: YOLOv5u, Objekterkennung, vorab trainierte Modelle, Ultralytics, Inferenz, Validierung, YOLOv5, YOLOv8, Ankerfrei, Objektlos, Echtzeitanwendungen, Maschinelles Lernen |
||||
--- |
||||
|
||||
# YOLOv5 |
||||
|
||||
## Übersicht |
||||
|
||||
YOLOv5u steht für eine Weiterentwicklung der Methoden zur Objekterkennung. Basierend auf der grundlegenden Architektur des von Ultralytics entwickelten YOLOv5-Modells integriert YOLOv5u den ankerfreien, objektlosen Split-Kopf, ein Feature, das zuvor in den YOLOv8-Modellen eingeführt wurde. Diese Anpassung verfeinert die Architektur des Modells und führt zu einem optimierten Verhältnis von Genauigkeit und Geschwindigkeit bei der Objekterkennung. Basierend auf den empirischen Ergebnissen und den abgeleiteten Features bietet YOLOv5u eine effiziente Alternative für diejenigen, die robuste Lösungen sowohl in der Forschung als auch in praktischen Anwendungen suchen. |
||||
|
||||
 |
||||
|
||||
## Hauptmerkmale |
||||
|
||||
- **Ankerfreier Split-Ultralytics-Kopf:** Herkömmliche Objekterkennungsmodelle verwenden vordefinierte Ankerboxen, um die Position von Objekten vorherzusagen. YOLOv5u modernisiert diesen Ansatz. Durch die Verwendung eines ankerfreien Split-Ultralytics-Kopfes wird ein flexiblerer und anpassungsfähigerer Detektionsmechanismus gewährleistet, der die Leistung in verschiedenen Szenarien verbessert. |
||||
|
||||
- **Optimiertes Verhältnis von Genauigkeit und Geschwindigkeit:** Geschwindigkeit und Genauigkeit ziehen oft in entgegengesetzte Richtungen. Aber YOLOv5u stellt diese Abwägung in Frage. Es bietet eine ausgewogene Balance, die Echtzeitdetektionen ohne Einbußen bei der Genauigkeit ermöglicht. Diese Funktion ist besonders wertvoll für Anwendungen, die schnelle Reaktionen erfordern, wie autonome Fahrzeuge, Robotik und Echtzeitanalyse von Videos. |
||||
|
||||
- **Vielfalt an vorab trainierten Modellen:** YOLOv5u bietet eine Vielzahl von vorab trainierten Modellen, da verschiedene Aufgaben unterschiedliche Werkzeuge erfordern. Ob Sie sich auf Inferenz, Validierung oder Training konzentrieren, es wartet ein maßgeschneidertes Modell auf Sie. Diese Vielfalt gewährleistet, dass Sie nicht nur eine Einheitslösung verwenden, sondern ein speziell für Ihre einzigartige Herausforderung feinabgestimmtes Modell. |
||||
|
||||
## Unterstützte Aufgaben und Modi |
||||
|
||||
Die YOLOv5u-Modelle mit verschiedenen vorab trainierten Gewichten eignen sich hervorragend für Aufgaben zur [Objekterkennung](../tasks/detect.md). Sie unterstützen eine umfassende Palette von Modi, die sie für verschiedene Anwendungen von der Entwicklung bis zur Bereitstellung geeignet machen. |
||||
|
||||
| Modelltyp | Vorab trainierte Gewichte | Aufgabe | Inferenz | Validierung | Training | Export | |
||||
|-----------|-----------------------------------------------------------------------------------------------------------------------------|---------------------------------------|----------|-------------|----------|--------| |
||||
| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Diese Tabelle bietet eine detaillierte Übersicht über die verschiedenen Varianten des YOLOv5u-Modells und hebt ihre Anwendbarkeit in der Objekterkennung sowie die Unterstützung unterschiedlicher Betriebsmodi wie [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md) hervor. Diese umfassende Unterstützung ermöglicht es Benutzern, die Fähigkeiten der YOLOv5u-Modelle in einer Vielzahl von Objekterkennungsszenarien voll auszuschöpfen. |
||||
|
||||
## Leistungskennzahlen |
||||
|
||||
!!! Leistung |
||||
|
||||
=== "Erkennung" |
||||
|
||||
Siehe [Erkennungsdokumentation](https://docs.ultralytics.com/tasks/detect/) für Beispiele zur Verwendung dieser Modelle, die auf [COCO](https://docs.ultralytics.com/datasets/detect/coco/) trainiert wurden und 80 vorab trainierte Klassen enthalten. |
||||
|
||||
| Modell | YAML | 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) | Parameter<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
|---------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|------------------------------------------|-----------------------------------------------|--------------------|-------------------| |
||||
| [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34,3 | 73,6 | 1,06 | 2,6 | 7,7 | |
||||
| [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43,0 | 120,7 | 1,27 | 9,1 | 24,0 | |
||||
| [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49,0 | 233,9 | 1,86 | 25,1 | 64,2 | |
||||
| [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52,2 | 408,4 | 2,50 | 53,2 | 135,0 | |
||||
| [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53,2 | 763,2 | 3,81 | 97,2 | 246,4 | |
||||
| | | | | | | | | |
||||
| [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 42,1 | 211,0 | 1,83 | 4,3 | 7,8 | |
||||
| [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 48,6 | 422,6 | 2,34 | 15,3 | 24,6 | |
||||
| [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 53,6 | 810,9 | 4,36 | 41,2 | 65,7 | |
||||
| [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 55,7 | 1.470,9 | 5,47 | 86,1 | 137,4 | |
||||
| [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 56,8 | 2.436,5 | 8,98 | 155,4 | 250,7 | |
||||
|
||||
## Beispiele zur Verwendung |
||||
|
||||
Dieses Beispiel enthält einfache Beispiele zur Schulung und Inferenz mit YOLOv5. Die vollständige Dokumentation zu diesen und anderen [Modi](../modes/index.md) finden Sie in den Seiten [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md). |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
|
||||
PyTorch-vortrainierte `*.pt`-Modelle sowie Konfigurationsdateien `*.yaml` können an die `YOLO()`-Klasse übergeben werden, um eine Modellinstanz in Python zu erstellen: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Laden Sie ein vortrainiertes YOLOv5n-Modell für COCO-Daten |
||||
modell = YOLO('yolov5n.pt') |
||||
|
||||
# Informationen zum Modell anzeigen (optional) |
||||
model.info() |
||||
|
||||
# Trainieren Sie das Modell anhand des COCO8-Beispieldatensatzes für 100 Epochen |
||||
ergebnisse = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Führen Sie die Inferenz mit dem YOLOv5n-Modell auf dem Bild 'bus.jpg' durch |
||||
ergebnisse = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
CLI-Befehle sind verfügbar, um die Modelle direkt auszuführen: |
||||
|
||||
```bash |
||||
# Laden Sie ein vortrainiertes YOLOv5n-Modell und trainieren Sie es anhand des COCO8-Beispieldatensatzes für 100 Epochen |
||||
yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Laden Sie ein vortrainiertes YOLOv5n-Modell und führen Sie die Inferenz auf dem Bild 'bus.jpg' durch |
||||
yolo predict model=yolov5n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Zitate und Danksagungen |
||||
|
||||
Wenn Sie YOLOv5 oder YOLOv5u in Ihrer Forschung verwenden, zitieren Sie bitte das Ultralytics YOLOv5-Repository wie folgt: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
```bibtex |
||||
@software{yolov5, |
||||
title = {Ultralytics YOLOv5}, |
||||
author = {Glenn Jocher}, |
||||
year = {2020}, |
||||
version = {7.0}, |
||||
license = {AGPL-3.0}, |
||||
url = {https://github.com/ultralytics/yolov5}, |
||||
doi = {10.5281/zenodo.3908559}, |
||||
orcid = {0000-0001-5950-6979} |
||||
} |
||||
``` |
||||
|
||||
Bitte beachten Sie, dass die YOLOv5-Modelle unter den Lizenzen [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) und [Enterprise](https://ultralytics.com/license) bereitgestellt werden. |
||||
@ -1,107 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erforschen Sie Meituan YOLOv6, ein modernes Objekterkennungsmodell, das eine ausgewogene Kombination aus Geschwindigkeit und Genauigkeit bietet. Tauchen Sie ein in Funktionen, vorab trainierte Modelle und die Verwendung von Python. |
||||
keywords: Meituan YOLOv6, Objekterkennung, Ultralytics, YOLOv6 Dokumentation, Bi-direktionale Konkatenation, Anchor-Aided Training, vorab trainierte Modelle, Echtzeitanwendungen |
||||
--- |
||||
|
||||
# Meituan YOLOv6 |
||||
|
||||
## Überblick |
||||
|
||||
[Meituan](https://about.meituan.com/) YOLOv6 ist ein moderner Objekterkenner, der eine bemerkenswerte Balance zwischen Geschwindigkeit und Genauigkeit bietet und somit eine beliebte Wahl für Echtzeitanwendungen darstellt. Dieses Modell bietet mehrere bemerkenswerte Verbesserungen in seiner Architektur und seinem Trainingsschema, einschließlich der Implementierung eines Bi-direktionalen Konkatenationsmoduls (BiC), einer anchor-aided training (AAT)-Strategie und einem verbesserten Backpropagation- und Neck-Design für Spitzenleistungen auf dem COCO-Datensatz. |
||||
|
||||
 |
||||
 |
||||
**Übersicht über YOLOv6.** Diagramm der Modellarchitektur, das die neu gestalteten Netzwerkkomponenten und Trainingstrategien zeigt, die zu signifikanten Leistungsverbesserungen geführt haben. (a) Der Nacken von YOLOv6 (N und S sind dargestellt). Beachten Sie, dass bei M/L RepBlocks durch CSPStackRep ersetzt wird. (b) Die Struktur eines BiC-Moduls. (c) Ein SimCSPSPPF-Block. ([Quelle](https://arxiv.org/pdf/2301.05586.pdf)). |
||||
|
||||
### Hauptmerkmale |
||||
|
||||
- **Bi-direktionales Konkatenations (BiC) Modul:** YOLOv6 führt ein BiC-Modul im Nacken des Erkenners ein, das die Lokalisierungssignale verbessert und eine Leistungssteigerung bei vernachlässigbarem Geschwindigkeitsabfall liefert. |
||||
- **Anchor-aided Training (AAT) Strategie:** Dieses Modell schlägt AAT vor, um die Vorteile sowohl von ankerbasierten als auch von ankerfreien Paradigmen zu nutzen, ohne die Inferenzeffizienz zu beeinträchtigen. |
||||
- **Verbessertes Backpropagation- und Neck-Design:** Durch Vertiefung von YOLOv6 um eine weitere Stufe im Backpropagation und Nacken erreicht dieses Modell Spitzenleistungen auf dem COCO-Datensatz bei hochauflösenden Eingaben. |
||||
- **Self-Distillation Strategie:** Eine neue Self-Distillation-Strategie wird implementiert, um die Leistung von kleineren Modellen von YOLOv6 zu steigern, indem der Hilfsregressionszweig während des Trainings verstärkt und bei der Inferenz entfernt wird, um einen deutlichen Geschwindigkeitsabfall zu vermeiden. |
||||
|
||||
## Leistungsmetriken |
||||
|
||||
YOLOv6 bietet verschiedene vorab trainierte Modelle mit unterschiedlichen Maßstäben: |
||||
|
||||
- YOLOv6-N: 37,5% AP auf COCO val2017 bei 1187 FPS mit NVIDIA Tesla T4 GPU. |
||||
- YOLOv6-S: 45,0% AP bei 484 FPS. |
||||
- YOLOv6-M: 50,0% AP bei 226 FPS. |
||||
- YOLOv6-L: 52,8% AP bei 116 FPS. |
||||
- YOLOv6-L6: Spitzenleistung in Echtzeit. |
||||
|
||||
YOLOv6 bietet auch quantisierte Modelle für verschiedene Genauigkeiten sowie Modelle, die für mobile Plattformen optimiert sind. |
||||
|
||||
## Beispiele zur Verwendung |
||||
|
||||
In diesem Beispiel werden einfache Schulungs- und Inferenzbeispiele für YOLOv6 bereitgestellt. Weitere Dokumentation zu diesen und anderen [Modi](../modes/index.md) finden Sie auf den Seiten [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md). |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
|
||||
In Python kann PyTorch-vorab trainierte `*.pt`-Modelle sowie Konfigurations-`*.yaml`-Dateien an die `YOLO()`-Klasse übergeben werden, um eine Modellinstanz zu erstellen: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Erstellen Sie ein YOLOv6n-Modell von Grund auf |
||||
model = YOLO('yolov6n.yaml') |
||||
|
||||
# Zeigen Sie Informationen zum Modell an (optional) |
||||
model.info() |
||||
|
||||
# Trainieren Sie das Modell am Beispiel des COCO8-Datensatzes für 100 Epochen |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Führen Sie Inferenz mit dem YOLOv6n-Modell auf dem Bild 'bus.jpg' durch |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
CLI-Befehle stehen zur Verfügung, um die Modelle direkt auszuführen: |
||||
|
||||
```bash |
||||
# Erstellen Sie ein YOLOv6n-Modell von Grund auf und trainieren Sie es am Beispiel des COCO8-Datensatzes für 100 Epochen |
||||
yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Erstellen Sie ein YOLOv6n-Modell von Grund auf und führen Sie Inferenz auf dem Bild 'bus.jpg' durch |
||||
yolo predict model=yolov6n.yaml source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Unterstützte Aufgaben und Modi |
||||
|
||||
Die YOLOv6-Serie bietet eine Reihe von Modellen, die jeweils für die Hochleistungs-[Objekterkennung](../tasks/detect.md) optimiert sind. Diese Modelle erfüllen unterschiedliche Rechenanforderungen und Genauigkeitsanforderungen und sind daher vielseitig für eine Vielzahl von Anwendungen einsetzbar. |
||||
|
||||
| Modelltyp | Vorab trainierte Gewichte | Unterstützte Aufgaben | Inferenz | Validierung | Training | Exportieren | |
||||
|-----------|---------------------------|---------------------------------------|----------|-------------|----------|-------------| |
||||
| YOLOv6-N | `yolov6-n.pt` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-S | `yolov6-s.pt` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-M | `yolov6-m.pt` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-L | `yolov6-l.pt` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-L6 | `yolov6-l6.pt` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Diese Tabelle bietet einen detaillierten Überblick über die YOLOv6-Modellvarianten und hebt ihre Fähigkeiten bei der Objekterkennung sowie ihre Kompatibilität mit verschiedenen Betriebsmodi wie [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Exportieren](../modes/export.md) hervor. Diese umfassende Unterstützung ermöglicht es den Benutzern, die Fähigkeiten von YOLOv6-Modellen in einer Vielzahl von Objekterkennungsszenarien vollständig zu nutzen. |
||||
|
||||
## Zitate und Anerkennungen |
||||
|
||||
Wir möchten den Autoren für ihre bedeutenden Beiträge auf dem Gebiet der Echtzeit-Objekterkennung danken: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{li2023yolov6, |
||||
title={YOLOv6 v3.0: A Full-Scale Reloading}, |
||||
author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu}, |
||||
year={2023}, |
||||
eprint={2301.05586}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Das ursprüngliche YOLOv6-Papier finden Sie auf [arXiv](https://arxiv.org/abs/2301.05586). Die Autoren haben ihre Arbeit öffentlich zugänglich gemacht, und der Code kann auf [GitHub](https://github.com/meituan/YOLOv6) abgerufen werden. Wir schätzen ihre Bemühungen zur Weiterentwicklung des Fachgebiets und zur Zugänglichmachung ihrer Arbeit für die breitere Gemeinschaft. |
||||
@ -1,66 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erforsche den YOLOv7, einen echtzeitfähigen Objektdetektor. Verstehe seine überlegene Geschwindigkeit, beeindruckende Genauigkeit und seinen einzigartigen Fokus auf die optimierte Ausbildung mit "trainable bag-of-freebies". |
||||
keywords: YOLOv7, echtzeitfähiger Objektdetektor, State-of-the-Art, Ultralytics, MS COCO Datensatz, Modellumparameterisierung, dynamische Labelzuweisung, erweiterte Skalierung, umfassende Skalierung |
||||
--- |
||||
|
||||
# YOLOv7: Trainable Bag-of-Freebies |
||||
|
||||
YOLOv7 ist ein echtzeitfähiger Objektdetektor der Spitzenklasse, der alle bekannten Objektdetektoren in Bezug auf Geschwindigkeit und Genauigkeit im Bereich von 5 FPS bis 160 FPS übertrifft. Mit einer Genauigkeit von 56,8% AP ist er der präziseste Echtzeit-Objektdetektor unter allen bekannten Modellen mit einer FPS von 30 oder höher auf der GPU V100. Darüber hinaus übertrifft YOLOv7 andere Objektdetektoren wie YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 und viele andere in Bezug auf Geschwindigkeit und Genauigkeit. Das Modell wird ausschließlich auf dem MS COCO-Datensatz trainiert, ohne andere Datensätze oder vortrainierte Gewichte zu verwenden. Sourcecode für YOLOv7 ist auf GitHub verfügbar. |
||||
|
||||
 |
||||
**Vergleich von Spitzen-Objektdetektoren. |
||||
** Aus den Ergebnissen in Tabelle 2 wissen wir, dass die vorgeschlagene Methode das beste Verhältnis von Geschwindigkeit und Genauigkeit umfassend aufweist. Vergleichen wir YOLOv7-tiny-SiLU mit YOLOv5-N (r6.1), so ist unsere Methode 127 FPS schneller und um 10,7% genauer beim AP. Darüber hinaus erreicht YOLOv7 bei einer Bildrate von 161 FPS einen AP von 51,4%, während PPYOLOE-L mit demselben AP nur eine Bildrate von 78 FPS aufweist. In Bezug auf die Parameterverwendung ist YOLOv7 um 41% geringer als PPYOLOE-L. Vergleicht man YOLOv7-X mit 114 FPS Inferenzgeschwindigkeit mit YOLOv5-L (r6.1) mit 99 FPS Inferenzgeschwindigkeit, kann YOLOv7-X den AP um 3,9% verbessern. Wenn YOLOv7-X mit YOLOv5-X (r6.1) in ähnlichem Maßstab verglichen wird, ist die Inferenzgeschwindigkeit von YOLOv7-X 31 FPS schneller. Darüber hinaus reduziert YOLOv7-X in Bezug auf die Anzahl der Parameter und Berechnungen 22% der Parameter und 8% der Berechnungen im Vergleich zu YOLOv5-X (r6.1), verbessert jedoch den AP um 2,2% ([Source](https://arxiv.org/pdf/2207.02696.pdf)). |
||||
|
||||
## Übersicht |
||||
|
||||
Echtzeit-Objekterkennung ist eine wichtige Komponente vieler Computersysteme für Bildverarbeitung, einschließlich Multi-Object-Tracking, autonomes Fahren, Robotik und medizinische Bildanalyse. In den letzten Jahren konzentrierte sich die Entwicklung der Echtzeit-Objekterkennung auf die Gestaltung effizienter Architekturen und die Verbesserung der Inferenzgeschwindigkeit verschiedener CPUs, GPUs und Neural Processing Units (NPUs). YOLOv7 unterstützt sowohl mobile GPUs als auch GPU-Geräte, von der Edge bis zur Cloud. |
||||
|
||||
Im Gegensatz zu herkömmlichen, echtzeitfähigen Objektdetektoren, die sich auf die Architekturoptimierung konzentrieren, führt YOLOv7 eine Fokussierung auf die Optimierung des Schulungsprozesses ein. Dazu gehören Module und Optimierungsmethoden, die darauf abzielen, die Genauigkeit der Objekterkennung zu verbessern, ohne die Inferenzkosten zu erhöhen - ein Konzept, das als "trainable bag-of-freebies" bekannt ist. |
||||
|
||||
## Hauptmerkmale |
||||
|
||||
YOLOv7 führt mehrere Schlüsselfunktionen ein: |
||||
|
||||
1. **Modellumparameterisierung**: YOLOv7 schlägt ein geplantes umparameterisiertes Modell vor, das eine in verschiedenen Netzwerken anwendbare Strategie darstellt und auf dem Konzept des Gradientenpropagationspfades basiert. |
||||
|
||||
2. **Dynamische Labelzuweisung**: Das Training des Modells mit mehreren Ausgabeschichten stellt ein neues Problem dar: "Wie weist man dynamische Ziele für die Ausgaben der verschiedenen Zweige zu?" Zur Lösung dieses Problems führt YOLOv7 eine neue Methode zur Labelzuweisung ein, die als coarse-to-fine lead guided label assignment bekannt ist. |
||||
|
||||
3. **Erweiterte und umfassende Skalierung**: YOLOv7 schlägt Methoden zur "erweiterten" und "umfassenden Skalierung" des echtzeitfähigen Objektdetektors vor, die Parameter und Berechnungen effektiv nutzen können. |
||||
|
||||
4. **Effizienz**: Die von YOLOv7 vorgeschlagene Methode kann etwa 40 % der Parameter und 50 % der Berechnungen des state-of-the-art echtzeitfähigen Objektdetektors wirksam reduzieren und weist eine schnellere Inferenzgeschwindigkeit und eine höhere Detektionsgenauigkeit auf. |
||||
|
||||
## Beispiele zur Nutzung |
||||
|
||||
Zum Zeitpunkt der Erstellung dieses Textes unterstützt Ultralytics derzeit keine YOLOv7-Modelle. Daher müssen sich alle Benutzer, die YOLOv7 verwenden möchten, direkt an das YOLOv7 GitHub-Repository für Installations- und Nutzungshinweise wenden. |
||||
|
||||
Hier ist ein kurzer Überblick über die typischen Schritte, die Sie unternehmen könnten, um YOLOv7 zu verwenden: |
||||
|
||||
1. Besuchen Sie das YOLOv7 GitHub-Repository: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7). |
||||
|
||||
2. Befolgen Sie die in der README-Datei bereitgestellten Anweisungen zur Installation. Dies beinhaltet in der Regel das Klonen des Repositories, die Installation der erforderlichen Abhängigkeiten und das Einrichten eventuell notwendiger Umgebungsvariablen. |
||||
|
||||
3. Sobald die Installation abgeschlossen ist, können Sie das Modell entsprechend den im Repository bereitgestellten Anleitungen trainieren und verwenden. Dies umfasst in der Regel die Vorbereitung des Datensatzes, das Konfigurieren der Modellparameter, das Training des Modells und anschließend die Verwendung des trainierten Modells zur Durchführung der Objekterkennung. |
||||
|
||||
Bitte beachten Sie, dass die spezifischen Schritte je nach Ihrem spezifischen Anwendungsfall und dem aktuellen Stand des YOLOv7-Repositories variieren können. Es wird daher dringend empfohlen, sich direkt an die im YOLOv7 GitHub-Repository bereitgestellten Anweisungen zu halten. |
||||
|
||||
Wir bedauern etwaige Unannehmlichkeiten und werden uns bemühen, dieses Dokument mit Anwendungsbeispielen für Ultralytics zu aktualisieren, sobald die Unterstützung für YOLOv7 implementiert ist. |
||||
|
||||
## Zitationen und Danksagungen |
||||
|
||||
Wir möchten den Autoren von YOLOv7 für ihre bedeutenden Beiträge im Bereich der echtzeitfähigen Objekterkennung danken: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{wang2022yolov7, |
||||
title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors}, |
||||
author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark}, |
||||
journal={arXiv preprint arXiv:2207.02696}, |
||||
year={2022} |
||||
} |
||||
``` |
||||
|
||||
Die ursprüngliche YOLOv7-Studie kann auf [arXiv](https://arxiv.org/pdf/2207.02696.pdf) gefunden werden. Die Autoren haben ihre Arbeit öffentlich zugänglich gemacht, und der Code kann auf [GitHub](https://github.com/WongKinYiu/yolov7) abgerufen werden. Wir schätzen ihre Bemühungen, das Feld voranzubringen und ihre Arbeit der breiteren Gemeinschaft zugänglich zu machen. |
||||
@ -1,162 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Erfahren Sie mehr über die aufregenden Funktionen von YOLOv8, der neuesten Version unseres Echtzeit-Objekterkenners! Erfahren Sie, wie fortschrittliche Architekturen, vortrainierte Modelle und die optimale Balance zwischen Genauigkeit und Geschwindigkeit YOLOv8 zur perfekten Wahl für Ihre Objekterkennungsaufgaben machen. |
||||
keywords: YOLOv8, Ultralytics, Echtzeit-Objekterkennung, vortrainierte Modelle, Dokumentation, Objekterkennung, YOLO-Serie, fortschrittliche Architekturen, Genauigkeit, Geschwindigkeit |
||||
--- |
||||
|
||||
# YOLOv8 |
||||
|
||||
## Übersicht |
||||
|
||||
YOLOv8 ist die neueste Version der YOLO-Serie von Echtzeit-Objekterkennern und bietet modernste Leistung in Bezug auf Genauigkeit und Geschwindigkeit. Basierend auf den Fortschritten früherer YOLO-Versionen bringt YOLOv8 neue Funktionen und Optimierungen mit sich, die ihn zu einer idealen Wahl für verschiedene Objekterkennungsaufgaben in einer Vielzahl von Anwendungen machen. |
||||
|
||||
 |
||||
|
||||
## Schlüsselfunktionen |
||||
|
||||
- **Fortschrittliche Backbone- und Neck-Architekturen:** YOLOv8 verwendet modernste Backbone- und Neck-Architekturen, die zu einer verbesserten Merkmalsextraktion und Objekterkennungsleistung führen. |
||||
- **Ankerfreier Split Ultralytics Head:** YOLOv8 verwendet einen ankerfreien Split Ultralytics Head, der zu einer besseren Genauigkeit und einem effizienteren Erkennungsprozess im Vergleich zu ankerbasierten Ansätzen führt. |
||||
- **Optimale Genauigkeits-Geschwindigkeits-Balance:** Mit dem Fokus auf die Aufrechterhaltung einer optimalen Balance zwischen Genauigkeit und Geschwindigkeit eignet sich YOLOv8 für Echtzeit-Objekterkennungsaufgaben in verschiedenen Anwendungsbereichen. |
||||
- **Vielfalt an vortrainierten Modellen:** YOLOv8 bietet eine Vielzahl von vortrainierten Modellen, um verschiedenen Aufgaben und Leistungsanforderungen gerecht zu werden. Dies erleichtert die Suche nach dem richtigen Modell für Ihren spezifischen Anwendungsfall. |
||||
|
||||
## Unterstützte Aufgaben und Modi |
||||
|
||||
Die YOLOv8-Serie bietet eine Vielzahl von Modellen, von denen jedes auf bestimmte Aufgaben in der Computer Vision spezialisiert ist. Diese Modelle sind so konzipiert, dass sie verschiedenen Anforderungen gerecht werden, von der Objekterkennung bis hin zu komplexeren Aufgaben wie Instanzsegmentierung, Pose/Keypoint-Erkennung und Klassifikation. |
||||
|
||||
Jede Variante der YOLOv8-Serie ist auf ihre jeweilige Aufgabe optimiert und gewährleistet damit hohe Leistung und Genauigkeit. Darüber hinaus sind diese Modelle kompatibel mit verschiedenen Betriebsmodi, einschließlich [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md). Dadurch wird ihre Verwendung in verschiedenen Phasen der Bereitstellung und Entwicklung erleichtert. |
||||
|
||||
| Modell | Dateinamen | Aufgabe | Inference | Validation | Training | Export | |
||||
|-------------|----------------------------------------------------------------------------------------------------------------|---------------------------------------------|-----------|------------|----------|--------| |
||||
| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Instanzsegmentierung](../tasks/segment.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [Pose/Keypoints](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Klassifikation](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Diese Tabelle gibt einen Überblick über die verschiedenen Varianten des YOLOv8-Modells und deren Anwendungsbereiche sowie deren Kompatibilität mit verschiedenen Betriebsmodi wie Inference, Validation, Training und Export. Sie zeigt die Vielseitigkeit und Robustheit der YOLOv8-Serie, was sie für verschiedene Anwendungen in der Computer Vision geeignet macht. |
||||
|
||||
## Leistungskennzahlen |
||||
|
||||
!!! Performance |
||||
|
||||
=== "Objekterkennung (COCO)" |
||||
|
||||
Siehe [Objekterkennungsdokumentation](https://docs.ultralytics.com/tasks/detect/) für Beispiele zur Verwendung dieser Modelle, die auf [COCO](https://docs.ultralytics.com/datasets/detect/coco/) trainiert wurden und 80 vortrainierte Klassen enthalten. |
||||
|
||||
| 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) | Parameter<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ---------------------------------------- | --------------------------------------------- | ------------------ | ----------------- | |
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt) | 640 | 37,3 | 80,4 | 0,99 | 3,2 | 8,7 | |
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44,9 | 128,4 | 1,20 | 11,2 | 28,6 | |
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50,2 | 234,7 | 1,83 | 25,9 | 78,9 | |
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52,9 | 375,2 | 2,39 | 43,7 | 165,2 | |
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x.pt) | 640 | 53,9 | 479,1 | 3,53 | 68,2 | 257,8 | |
||||
|
||||
=== "Objekterkennung (Open Images V7)" |
||||
|
||||
Siehe [Objekterkennungsdokumentation](https://docs.ultralytics.com/tasks/detect/) für Beispiele zur Verwendung dieser Modelle, die auf [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/) trainiert wurden und 600 vortrainierte Klassen enthalten. |
||||
|
||||
| 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) | Parameter<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ---------------------------------------- | --------------------------------------------- | ------------------ | ----------------- | |
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n-oiv7.pt) | 640 | 18,4 | 142,4 | 1,21 | 3,5 | 10,5 | |
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s-oiv7.pt) | 640 | 27,7 | 183,1 | 1,40 | 11,4 | 29,7 | |
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m-oiv7.pt) | 640 | 33,6 | 408,5 | 2,26 | 26,2 | 80,6 | |
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l-oiv7.pt) | 640 | 34,9 | 596,9 | 2,43 | 44,1 | 167,4 | |
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x-oiv7.pt) | 640 | 36,3 | 860,6 | 3,56 | 68,7 | 260,6 | |
||||
|
||||
=== "Segmentierung (COCO)" |
||||
|
||||
Siehe [Segmentierungsdokumentation](https://docs.ultralytics.com/tasks/segment/) für Beispiele zur Verwendung dieser Modelle, die auf [COCO](https://docs.ultralytics.com/datasets/segment/coco/) trainiert wurden und 80 vortrainierte Klassen enthalten. |
||||
|
||||
| Modell | Größe<br><sup>(Pixel) | mAP<sup>box<br>50-95 | mAP<sup>mask<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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53,4 | 43,4 | 712,1 | 4,02 | 71,8 | 344,1 | |
||||
|
||||
=== "Klassifikation (ImageNet)" |
||||
|
||||
Siehe [Klassifikationsdokumentation](https://docs.ultralytics.com/tasks/classify/) für Beispiele zur Verwendung dieser Modelle, die auf [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/) trainiert wurden und 1000 vortrainierte Klassen enthalten. |
||||
|
||||
| Modell | Größe<br><sup>(Pixel) | acc<br><sup>top1 | acc<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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78,4 | 94,3 | 232,0 | 1,01 | 57,4 | 154,8 | |
||||
|
||||
=== "Pose (COCO)" |
||||
|
||||
Siehe [Pose Estimation Docs](https://docs.ultralytics.com/tasks/segment/) für Beispiele zur Verwendung dieser Modelle, die auf [COCO](https://docs.ultralytics.com/datasets/pose/coco/) trainiert wurden und 1 vortrainierte Klasse, 'person', enthalten. |
||||
|
||||
| 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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71,6 | 91,2 | 4088,7 | 10,04 | 99,1 | 1066,4 | |
||||
|
||||
## Beispiele zur Verwendung |
||||
|
||||
Dieses Beispiel liefert einfache Trainings- und Inferenzbeispiele für YOLOv8. Für die vollständige Dokumentation zu diesen und anderen [Modi](../modes/index.md) siehe die Seiten [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md). |
||||
|
||||
Beachten Sie, dass das folgende Beispiel für YOLOv8 [Detect](../tasks/detect.md) Modelle für die Objekterkennung verwendet. Für zusätzliche unterstützte Aufgaben siehe die Dokumentation zur [Segmentation](../tasks/segment.md), [Classification](../tasks/classify.md) und [Pose](../tasks/pose.md). |
||||
|
||||
!!! Example "Beispiel" |
||||
|
||||
=== "Python" |
||||
|
||||
Vortrainierte PyTorch-`*.pt`-Modelle sowie Konfigurations-`*.yaml`-Dateien können der Klasse `YOLO()` in Python übergeben werden, um eine Modellinstanz zu erstellen: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Laden Sie ein vortrainiertes YOLOv8n-Modell für COCO |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Zeigen Sie Informationen zum Modell an (optional) |
||||
model.info() |
||||
|
||||
# Trainieren Sie das Modell mit dem COCO8-Beispieldatensatz für 100 Epochen |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Führen Sie eine Inferenz mit dem YOLOv8n-Modell auf dem Bild 'bus.jpg' aus |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
CLI-Befehle stehen zur direkten Ausführung der Modelle zur Verfügung: |
||||
|
||||
```bash |
||||
# Laden Sie ein vortrainiertes YOLOv8n-Modell für COCO und trainieren Sie es mit dem COCO8-Beispieldatensatz für 100 Epochen |
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Laden Sie ein vortrainiertes YOLOv8n-Modell für COCO und führen Sie eine Inferenz auf dem Bild 'bus.jpg' aus |
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Zitate und Danksagungen |
||||
|
||||
Wenn Sie das YOLOv8-Modell oder eine andere Software aus diesem Repository in Ihrer Arbeit verwenden, zitieren Sie es bitte in folgendem Format: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@software{yolov8_ultralytics, |
||||
author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu}, |
||||
title = {Ultralytics YOLOv8}, |
||||
version = {8.0.0}, |
||||
year = {2023}, |
||||
url = {https://github.com/ultralytics/ultralytics}, |
||||
orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069}, |
||||
license = {AGPL-3.0} |
||||
} |
||||
``` |
||||
|
||||
Bitte beachten Sie, dass dieDOI aussteht und der Zitation hinzugefügt wird, sobald sie verfügbar ist. YOLOv8-Modelle werden unter den Lizenzen [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) und [Enterprise](https://ultralytics.com/license) bereitgestellt. |
||||
@ -1,94 +0,0 @@ |
||||
--- |
||||
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 "Beispiel" |
||||
|
||||
=== "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. |
||||
@ -1,108 +0,0 @@ |
||||
--- |
||||
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 "Beispiel" |
||||
|
||||
=== "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` | |
||||
@ -1,74 +0,0 @@ |
||||
--- |
||||
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 } |
||||
|
||||
## [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 } |
||||
|
||||
## [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 } |
||||
|
||||
## [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 } |
||||
|
||||
## [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 } |
||||
|
||||
## [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 } |
||||
@ -1,227 +0,0 @@ |
||||
--- |
||||
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: |
||||
|
||||
!!! Example "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. |
||||
|
||||
!!! Tip "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: |
||||
|
||||
!!! Example "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 |
||||
``` |
||||
@ -1,206 +0,0 @@ |
||||
--- |
||||
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. |
||||
|
||||
!!! Tip "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. |
||||
|
||||
!!! Example "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. |
||||
|
||||
!!! Example "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: |
||||
|
||||
!!! Example "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: |
||||
|
||||
!!! Example "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: |
||||
|
||||
!!! Example "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: |
||||
|
||||
!!! Example "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/. |
||||
|
||||
!!! Example "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. |
||||
@ -1,86 +0,0 @@ |
||||
--- |
||||
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 "Beispiel" |
||||
|
||||
=== "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' | |
||||
| |
||||
@ -1,198 +0,0 @@ |
||||
--- |
||||
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. |
||||
|
||||
!!! Example "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 |
||||
``` |
||||
|
||||
!!! Note "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/pyproject.toml) Datei für eine Liste der Abhängigkeiten. Beachten Sie, dass alle oben genannten Beispiele alle erforderlichen Abhängigkeiten installieren. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/_a7cVL9hqnk" |
||||
title="YouTube video player" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Watch:</strong> Ultralytics YOLO Quick Start Guide |
||||
</p> |
||||
|
||||
!!! Tip "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. |
||||
|
||||
!!! Example "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 |
||||
``` |
||||
|
||||
!!! Warning "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 } |
||||
|
||||
## 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. |
||||
|
||||
!!! Example "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} |
||||
@ -1,172 +0,0 @@ |
||||
--- |
||||
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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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 "Beispiel" |
||||
|
||||
=== "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 "Beispiel" |
||||
|
||||
=== "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 "Beispiel" |
||||
|
||||
=== "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 "Beispiel" |
||||
|
||||
=== "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/). |
||||
@ -1,184 +0,0 @@ |
||||
--- |
||||
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/v8.1.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | |
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | |
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | |
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | |
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.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](https://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 "Beispiel" |
||||
|
||||
=== "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 "Beispiel" |
||||
|
||||
=== "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 "Beispiel" |
||||
|
||||
=== "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 "Beispiel" |
||||
|
||||
=== "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/). |
||||
@ -1,55 +0,0 @@ |
||||
--- |
||||
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. |
||||
|
||||
!!! Note "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 } |
||||
|
||||
## [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 } |
||||
|
||||
## [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 } |
||||
|
||||
## [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 } |
||||
|
||||
## 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. |
||||
@ -1,185 +0,0 @@ |
||||
--- |
||||
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> |
||||
|
||||
!!! Tip "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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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](https://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. |
||||
|
||||
!!! Example "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. |
||||
|
||||
!!! Example "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. |
||||
|
||||
!!! Example "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. |
||||
|
||||
!!! Example "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. |
||||
@ -1,188 +0,0 @@ |
||||
--- |
||||
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> |
||||
|
||||
!!! Tip "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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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](https://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). |
||||
|
||||
!!! Example "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. |
||||
|
||||
!!! Example "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. |
||||
|
||||
!!! Example "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. |
||||
|
||||
!!! Example "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/). |
||||
@ -1,127 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explore diferentes conjuntos de datos de visión por computadora soportados por Ultralytics para la detección de objetos, segmentación, estimación de poses, clasificación de imágenes y seguimiento de múltiples objetos. |
||||
keywords: visión por computadora, conjuntos de datos, Ultralytics, YOLO, detección de objetos, segmentación de instancias, estimación de poses, clasificación de imágenes, seguimiento de múltiples objetos |
||||
--- |
||||
|
||||
# Resumen de Conjuntos de Datos |
||||
|
||||
Ultralytics brinda soporte para varios conjuntos de datos para facilitar tareas de visión por computadora como detección, segmentación de instancias, estimación de poses, clasificación y seguimiento de múltiples objetos. A continuación se presenta una lista de los principales conjuntos de datos de Ultralytics, seguido por un resumen de cada tarea de visión por computadora y los respectivos conjuntos de datos. |
||||
|
||||
!!! Note "Nota" |
||||
|
||||
🚧 Nuestra documentación multilingüe está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por su paciencia! 🙏 |
||||
|
||||
## [Conjuntos de Datos de Detección](../../datasets/detect/index.md) |
||||
|
||||
La detección de objetos con cuadros delimitadores es una técnica de visión por computadora que implica detectar y localizar objetos en una imagen dibujando un cuadro alrededor de cada objeto. |
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md): Un conjunto de datos que contiene datos de seguimiento en 3D y predicción de movimientos en entornos urbanos con anotaciones detalladas. |
||||
- [COCO](../../datasets/detect/coco.md): Un conjunto de datos a gran escala diseñado para detección de objetos, segmentación y subtitulado con más de 200 mil imágenes etiquetadas. |
||||
- [COCO8](../../datasets/detect/coco8.md): Contiene las primeras 4 imágenes de COCO train y COCO val, adecuado para pruebas rápidas. |
||||
- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Un conjunto de datos de imágenes de cabezas de trigo recolectadas alrededor del mundo para tareas de detección y localización de objetos. |
||||
- [Objects365](../../datasets/detect/objects365.md): Un conjunto de datos a gran escala y de alta calidad para la detección de objetos con 365 categorías y más de 600 mil imágenes anotadas. |
||||
- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Un conjunto de datos completo de Google con 1.7 millones de imágenes de entrenamiento y 42 mil imágenes de validación. |
||||
- [SKU-110K](../../datasets/detect/sku-110k.md): Un conjunto de datos que presenta detección de objetos densa en entornos minoristas con más de 11 mil imágenes y 1.7 millones de cuadros delimitadores. |
||||
- [VisDrone](../../datasets/detect/visdrone.md): Un conjunto de datos que contiene datos de detección de objetos y seguimiento de múltiples objetos de imágenes capturadas por drones con más de 10 mil imágenes y secuencias de video. |
||||
- [VOC](../../datasets/detect/voc.md): El conjunto de datos de Clases de Objetos Visuales de Pascal (VOC) para la detección de objetos y segmentación con 20 clases de objetos y más de 11 mil imágenes. |
||||
- [xView](../../datasets/detect/xview.md): Un conjunto de datos para la detección de objetos en imágenes aéreas con 60 categorías de objetos y más de un millón de objetos anotados. |
||||
|
||||
## [Conjuntos de Datos de Segmentación de Instancias](../../datasets/segment/index.md) |
||||
|
||||
La segmentación de instancias es una técnica de visión por computadora que implica identificar y localizar objetos en una imagen a nivel de píxel. |
||||
|
||||
- [COCO](../../datasets/segment/coco.md): Un conjunto de datos a gran escala diseñado para tareas de detección de objetos, segmentación y subtitulado con más de 200 mil imágenes etiquetadas. |
||||
- [COCO8-seg](../../datasets/segment/coco8-seg.md): Un conjunto de datos más pequeño para tareas de segmentación de instancias, que contiene un subconjunto de 8 imágenes de COCO con anotaciones de segmentación. |
||||
|
||||
## [Estimación de Poses](../../datasets/pose/index.md) |
||||
|
||||
La estimación de poses es una técnica utilizada para determinar la pose del objeto en relación con la cámara o el sistema de coordenadas del mundo. |
||||
|
||||
- [COCO](../../datasets/pose/coco.md): Un conjunto de datos a gran escala con anotaciones de pose humana diseñado para tareas de estimación de poses. |
||||
- [COCO8-pose](../../datasets/pose/coco8-pose.md): Un conjunto de datos más pequeño para tareas de estimación de poses, que contiene un subconjunto de 8 imágenes de COCO con anotaciones de pose humana. |
||||
- [Tiger-pose](../../datasets/pose/tiger-pose.md): Un conjunto de datos compacto que consiste en 263 imágenes centradas en tigres, anotadas con 12 puntos clave por tigre para tareas de estimación de poses. |
||||
|
||||
## [Clasificación](../../datasets/classify/index.md) |
||||
|
||||
La clasificación de imágenes es una tarea de visión por computadora que implica categorizar una imagen en una o más clases o categorías predefinidas basadas en su contenido visual. |
||||
|
||||
- [Caltech 101](../../datasets/classify/caltech101.md): Un conjunto de datos que contiene imágenes de 101 categorías de objetos para tareas de clasificación de imágenes. |
||||
- [Caltech 256](../../datasets/classify/caltech256.md): Una versión extendida de Caltech 101 con 256 categorías de objetos y imágenes más desafiantes. |
||||
- [CIFAR-10](../../datasets/classify/cifar10.md): Un conjunto de datos de 60 mil imágenes a color de 32x32 en 10 clases, con 6 mil imágenes por clase. |
||||
- [CIFAR-100](../../datasets/classify/cifar100.md): Una versión extendida de CIFAR-10 con 100 categorías de objetos y 600 imágenes por clase. |
||||
- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Un conjunto de datos compuesto por 70 mil imágenes en escala de grises de 10 categorías de moda para tareas de clasificación de imágenes. |
||||
- [ImageNet](../../datasets/classify/imagenet.md): Un conjunto de datos a gran escala para detección de objetos y clasificación de imágenes con más de 14 millones de imágenes y 20 mil categorías. |
||||
- [ImageNet-10](../../datasets/classify/imagenet10.md): Un subconjunto más pequeño de ImageNet con 10 categorías para experimentación y pruebas más rápidas. |
||||
- [Imagenette](../../datasets/classify/imagenette.md): Un subconjunto más pequeño de ImageNet que contiene 10 clases fácilmente distinguibles para entrenamientos y pruebas más rápidos. |
||||
- [Imagewoof](../../datasets/classify/imagewoof.md): Un subconjunto más desafiante de ImageNet que contiene 10 categorías de razas de perros para tareas de clasificación de imágenes. |
||||
- [MNIST](../../datasets/classify/mnist.md): Un conjunto de datos de 70 mil imágenes en escala de grises de dígitos escritos a mano para tareas de clasificación de imágenes. |
||||
|
||||
## [Cuadros Delimitadores Orientados (OBB)](../../datasets/obb/index.md) |
||||
|
||||
Los Cuadros Delimitadores Orientados (OBB) es un método en visión por computadora para detectar objetos angulados en imágenes utilizando cuadros delimitadores rotados, a menudo aplicado en imágenes aéreas y satelitales. |
||||
|
||||
- [DOTAv2](../../datasets/obb/dota-v2.md): Un popular conjunto de datos de imágenes aéreas de OBB con 1.7 millones de instancias y 11,268 imágenes. |
||||
|
||||
## [Seguimiento de Múltiples Objetos](../../datasets/track/index.md) |
||||
|
||||
El seguimiento de múltiples objetos es una técnica de visión por computadora que implica detectar y seguir múltiples objetos a lo largo del tiempo en una secuencia de video. |
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md): Un conjunto de datos que contiene datos de seguimiento en 3D y predicción de movimientos en entornos urbanos con anotaciones detalladas para tareas de seguimiento de múltiples objetos. |
||||
- [VisDrone](../../datasets/detect/visdrone.md): Un conjunto de datos que contiene datos de detección de objetos y seguimiento de múltiples objetos de imágenes capturadas por drones con más de 10 mil imágenes y secuencias de video. |
||||
|
||||
## Contribuir con Nuevos Conjuntos de Datos |
||||
|
||||
Contribuir con un nuevo conjunto de datos implica varios pasos para garantizar que se alinee bien con la infraestructura existente. A continuación, se presentan los pasos necesarios: |
||||
|
||||
### Pasos para Contribuir con un Nuevo Conjunto de Datos |
||||
|
||||
1. **Recolectar Imágenes**: Reúne las imágenes que pertenecen al conjunto de datos. Estas podrían ser recopiladas de varias fuentes, tales como bases de datos públicas o tu propia colección. |
||||
|
||||
2. **Annotar Imágenes**: Anota estas imágenes con cuadros delimitadores, segmentos o puntos clave, dependiendo de la tarea. |
||||
|
||||
3. **Exportar Anotaciones**: Convierte estas anotaciones en el formato de archivo `*.txt` de YOLO que Ultralytics soporta. |
||||
|
||||
4. **Organizar Conjunto de Datos**: Organiza tu conjunto de datos en la estructura de carpetas correcta. Deberías tener directorios de nivel superior `train/` y `val/`, y dentro de cada uno, un subdirectorio `images/` y `labels/`. |
||||
|
||||
``` |
||||
dataset/ |
||||
├── train/ |
||||
│ ├── images/ |
||||
│ └── labels/ |
||||
└── val/ |
||||
├── images/ |
||||
└── labels/ |
||||
``` |
||||
|
||||
5. **Crear un Archivo `data.yaml`**: En el directorio raíz de tu conjunto de datos, crea un archivo `data.yaml` que describa el conjunto de datos, clases y otra información necesaria. |
||||
|
||||
6. **Optimizar Imágenes (Opcional)**: Si deseas reducir el tamaño del conjunto de datos para un procesamiento más eficiente, puedes optimizar las imágenes usando el código a continuación. Esto no es requerido, pero se recomienda para tamaños de conjuntos de datos más pequeños y velocidades de descarga más rápidas. |
||||
|
||||
7. **Comprimir Conjunto de Datos**: Comprime toda la carpeta del conjunto de datos en un archivo .zip. |
||||
|
||||
8. **Documentar y PR**: Crea una página de documentación describiendo tu conjunto de datos y cómo encaja en el marco existente. Después de eso, envía una Solicitud de Extracción (PR). Consulta las [Pautas de Contribución de Ultralytics](https://docs.ultralytics.com/help/contributing) para obtener más detalles sobre cómo enviar una PR. |
||||
|
||||
### Código de Ejemplo para Optimizar y Comprimir un Conjunto de Datos |
||||
|
||||
!!! Example "Optimizar y Comprimir un Conjunto de Datos" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from pathlib import Path |
||||
from ultralytics.data.utils import compress_one_image |
||||
from ultralytics.utils.downloads import zip_directory |
||||
|
||||
# Definir el directorio del conjunto de datos |
||||
path = Path('ruta/al/conjunto-de-datos') |
||||
|
||||
# Optimizar imágenes en el conjunto de datos (opcional) |
||||
for f in path.rglob('*.jpg'): |
||||
compress_one_image(f) |
||||
|
||||
# Comprimir el conjunto de datos en 'ruta/al/conjunto-de-datos.zip' |
||||
zip_directory(path) |
||||
``` |
||||
|
||||
Siguiendo estos pasos, puedes contribuir con un nuevo conjunto de datos que se integre bien con la estructura existente de Ultralytics. |
||||
@ -1,193 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explora FastSAM, una solución basada en CNN para la segmentación en tiempo real de objetos en imágenes. Ofrece una interacción mejorada del usuario, eficiencia computacional y es adaptable a diversas tareas de visión. |
||||
keywords: FastSAM, aprendizaje automático, solución basada en CNN, segmentación de objetos, solución en tiempo real, Ultralytics, tareas de visión, procesamiento de imágenes, aplicaciones industriales, interacción del usuario |
||||
--- |
||||
|
||||
# Modelo para Segmentar Cualquier Cosa Rápidamente (FastSAM) |
||||
|
||||
El Modelo para Segmentar Cualquier Cosa Rápidamente (FastSAM) es una solución novedosa basada en CNN que funciona en tiempo real para la tarea de Segmentar Cualquier Cosa. Esta tarea está diseñada para segmentar cualquier objeto dentro de una imagen basándose en diversas indicaciones posibles de interacción del usuario. FastSAM reduce significativamente las demandas computacionales a la vez que mantiene un rendimiento competitivo, lo que lo convierte en una opción práctica para una variedad de tareas de visión. |
||||
|
||||
 |
||||
|
||||
## Descripción general |
||||
|
||||
FastSAM está diseñado para abordar las limitaciones del [Modelo para Segmentar Cualquier Cosa (SAM)](sam.md), un modelo Transformer pesado con requerimientos sustanciales de recursos computacionales. FastSAM divide la tarea de segmentar cualquier cosa en dos etapas secuenciales: segmentación de todas las instancias y selección basada en indicaciones. La primera etapa utiliza [YOLOv8-seg](../tasks/segment.md) para producir las máscaras de segmentación de todas las instancias en la imagen. En la segunda etapa, produce la región de interés correspondiente a la indicación. |
||||
|
||||
## Características principales |
||||
|
||||
1. **Solución en tiempo real:** Al aprovechar la eficiencia computacional de las CNN, FastSAM proporciona una solución en tiempo real para la tarea de segmentar cualquier cosa, lo que lo hace valioso para aplicaciones industriales que requieren resultados rápidos. |
||||
|
||||
2. **Eficiencia y rendimiento:** FastSAM ofrece una reducción significativa en las demandas computacionales y de recursos sin comprometer la calidad del rendimiento. Alcanza un rendimiento comparable al de SAM, pero con recursos computacionales drásticamente reducidos, lo que permite su aplicación en tiempo real. |
||||
|
||||
3. **Segmentación guiada por indicaciones:** FastSAM puede segmentar cualquier objeto dentro de una imagen guiado por diversas indicaciones posibles de interacción del usuario, lo que proporciona flexibilidad y adaptabilidad en diferentes escenarios. |
||||
|
||||
4. **Basado en YOLOv8-seg:** FastSAM se basa en [YOLOv8-seg](../tasks/segment.md), un detector de objetos equipado con una rama de segmentación de instancias. Esto le permite producir de manera efectiva las máscaras de segmentación de todas las instancias en una imagen. |
||||
|
||||
5. **Resultados competitivos en pruebas de referencia:** En la tarea de propuesta de objetos de MS COCO, FastSAM alcanza puntuaciones altas a una velocidad significativamente más rápida que [SAM](sam.md) en una sola tarjeta NVIDIA RTX 3090, lo que demuestra su eficiencia y capacidad. |
||||
|
||||
6. **Aplicaciones prácticas:** El enfoque propuesto proporciona una solución nueva y práctica para un gran número de tareas de visión a una velocidad muy alta, varias veces más rápida que los métodos actuales. |
||||
|
||||
7. **Factibilidad de compresión del modelo:** FastSAM demuestra la factibilidad de un camino que puede reducir significativamente el esfuerzo computacional al introducir una prioridad artificial en la estructura, abriendo así nuevas posibilidades para la arquitectura de modelos grandes en tareas generales de visión. |
||||
|
||||
## Modelos disponibles, tareas admitidas y modos de funcionamiento |
||||
|
||||
Esta tabla presenta los modelos disponibles con sus pesos pre-entrenados específicos, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento, como [Inference](../modes/predict.md) (inferencia), [Validation](../modes/val.md) (validación), [Training](../modes/train.md) (entrenamiento) y [Export](../modes/export.md) (exportación), indicados mediante emojis ✅ para los modos admitidos y emojis ❌ para los modos no admitidos. |
||||
|
||||
| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inferencia | Validación | Entrenamiento | Exportación | |
||||
|----------------|----------------------|---------------------------------------------------|------------|------------|---------------|-------------| |
||||
| FastSAM-s | `FastSAM-s.pt` | [Segmentación de Instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
| FastSAM-x | `FastSAM-x.pt` | [Segmentación de Instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Ejemplos de uso |
||||
|
||||
Los modelos FastSAM son fáciles de integrar en tus aplicaciones Python. Ultralytics proporciona una API y comandos de línea de comandos (CLI) fáciles de usar para agilizar el desarrollo. |
||||
|
||||
### Uso de predicción |
||||
|
||||
Para realizar la detección de objetos en una imagen, utiliza el método `predict` de la siguiente manera: |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM |
||||
from ultralytics.models.fastsam import FastSAMPrompt |
||||
|
||||
# Define una fuente de inferencia |
||||
source = 'ruta/hacia/bus.jpg' |
||||
|
||||
# Crea un modelo FastSAM |
||||
model = FastSAM('FastSAM-s.pt') # o FastSAM-x.pt |
||||
|
||||
# Ejecuta la inferencia en una imagen |
||||
everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9) |
||||
|
||||
# Prepara un objeto de procesamiento de indicaciones |
||||
prompt_process = FastSAMPrompt(source, everything_results, device='cpu') |
||||
|
||||
# Indicación Everything |
||||
ann = prompt_process.everything_prompt() |
||||
|
||||
# Caja predeterminada [0,0,0,0] -> [x1,y1,x2,y2] |
||||
ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300]) |
||||
|
||||
# Indicación de texto |
||||
ann = prompt_process.text_prompt(text='una foto de un perro') |
||||
|
||||
# Indicación de punto |
||||
# puntos predeterminados [[0,0]] [[x1,y1],[x2,y2]] |
||||
# etiqueta_predeterminada [0] [1,0] 0:fondo, 1:primer plano |
||||
ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1]) |
||||
prompt_process.plot(annotations=ann, output='./') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
```bash |
||||
# Carga un modelo FastSAM y segmenta todo con él |
||||
yolo segment predict model=FastSAM-s.pt source=ruta/hacia/bus.jpg imgsz=640 |
||||
``` |
||||
|
||||
Este fragmento de código demuestra la simplicidad de cargar un modelo pre-entrenado y realizar una predicción en una imagen. |
||||
|
||||
### Uso de validación |
||||
|
||||
La validación del modelo en un conjunto de datos se puede realizar de la siguiente manera: |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM |
||||
|
||||
# Crea un modelo FastSAM |
||||
model = FastSAM('FastSAM-s.pt') # o FastSAM-x.pt |
||||
|
||||
# Valida el modelo |
||||
results = model.val(data='coco8-seg.yaml') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
```bash |
||||
# Carga un modelo FastSAM y valida en el conjunto de datos de ejemplo COCO8 con un tamaño de imagen de 640 |
||||
yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640 |
||||
``` |
||||
|
||||
Ten en cuenta que FastSAM solo admite la detección y segmentación de una sola clase de objeto. Esto significa que reconocerá y segmentará todos los objetos como si fueran de la misma clase. Por lo tanto, al preparar el conjunto de datos, debes convertir todos los IDs de categoría de objetos a 0. |
||||
|
||||
## Uso oficial de FastSAM |
||||
|
||||
FastSAM también está disponible directamente en el repositorio [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM). Aquí hay una descripción general breve de los pasos típicos que podrías seguir para usar FastSAM: |
||||
|
||||
### Instalación |
||||
|
||||
1. Clona el repositorio de FastSAM: |
||||
```shell |
||||
git clone https://github.com/CASIA-IVA-Lab/FastSAM.git |
||||
``` |
||||
|
||||
2. Crea y activa un entorno Conda con Python 3.9: |
||||
```shell |
||||
conda create -n FastSAM python=3.9 |
||||
conda activate FastSAM |
||||
``` |
||||
|
||||
3. Navega hasta el repositorio clonado e instala los paquetes requeridos: |
||||
```shell |
||||
cd FastSAM |
||||
pip install -r requirements.txt |
||||
``` |
||||
|
||||
4. Instala el modelo CLIP: |
||||
```shell |
||||
pip install git+https://github.com/openai/CLIP.git |
||||
``` |
||||
|
||||
### Ejemplo de uso |
||||
|
||||
1. Descarga un [punto de control del modelo](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing). |
||||
|
||||
2. Utiliza FastSAM para inferencia. Ejemplos de comandos: |
||||
|
||||
- Segmentar todo en una imagen: |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg |
||||
``` |
||||
|
||||
- Segmentar objetos específicos utilizando una indicación de texto: |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "el perro amarillo" |
||||
``` |
||||
|
||||
- Segmentar objetos dentro de una caja delimitadora (proporciona las coordenadas de la caja en formato xywh): |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]" |
||||
``` |
||||
|
||||
- Segmentar objetos cerca de puntos específicos: |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]" |
||||
``` |
||||
|
||||
Además, puedes probar FastSAM a través de una [demostración en Colab](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) o en la [demostración web de HuggingFace](https://huggingface.co/spaces/An-619/FastSAM) para tener una experiencia visual. |
||||
|
||||
## Citas y agradecimientos |
||||
|
||||
Nos gustaría agradecer a los autores de FastSAM por sus importantes contribuciones en el campo de la segmentación de instancias en tiempo real: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{zhao2023fast, |
||||
title={Fast Segment Anything}, |
||||
author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang}, |
||||
year={2023}, |
||||
eprint={2306.12156}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
El artículo original de FastSAM se puede encontrar en [arXiv](https://arxiv.org/abs/2306.12156). Los autores han puesto su trabajo a disposición del público, y el código base se puede acceder en [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). Agradecemos sus esfuerzos para avanzar en el campo y hacer que su trabajo sea accesible a la comunidad en general. |
||||
@ -1,98 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explore la amplia gama de modelos de la familia YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS y RT-DETR soportados por Ultralytics. Comienza con ejemplos para el uso tanto de CLI como de Python. |
||||
keywords: Ultralytics, documentación, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modelos, arquitecturas, Python, CLI |
||||
--- |
||||
|
||||
# Modelos soportados por Ultralytics |
||||
|
||||
¡Bienvenido a la documentación de modelos de Ultralytics! Ofrecemos soporte para una amplia gama de modelos, cada uno adaptado a tareas específicas como [detección de objetos](../tasks/detect.md), [segmentación de instancias](../tasks/segment.md), [clasificación de imágenes](../tasks/classify.md), [estimación de posturas](../tasks/pose.md), y [seguimiento de múltiples objetos](../modes/track.md). Si estás interesado en contribuir con tu arquitectura de modelo a Ultralytics, consulta nuestra [Guía de Contribución](../../help/contributing.md). |
||||
|
||||
!!! Note "Nota" |
||||
|
||||
🚧 Estamos trabajando arduamente para mejorar nuestra documentación en varios idiomas actualmente en construcción. ¡Gracias por tu paciencia! 🙏 |
||||
|
||||
## Modelos destacados |
||||
|
||||
Aquí están algunos de los modelos clave soportados: |
||||
|
||||
1. **[YOLOv3](yolov3.md)**: La tercera iteración de la familia de modelos YOLO, original de Joseph Redmon, conocida por su capacidad de detección de objetos en tiempo real eficientemente. |
||||
2. **[YOLOv4](yolov4.md)**: Una actualización nativa de darknet para YOLOv3, lanzada por Alexey Bochkovskiy en 2020. |
||||
3. **[YOLOv5](yolov5.md)**: Una versión mejorada de la arquitectura YOLO por Ultralytics, ofreciendo un mejor rendimiento y compromiso de velocidad comparado con versiones anteriores. |
||||
4. **[YOLOv6](yolov6.md)**: Lanzado por [Meituan](https://about.meituan.com/) en 2022, y utilizado en muchos de los robots de entrega autónomos de la compañía. |
||||
5. **[YOLOv7](yolov7.md)**: Modelos YOLO actualizados lanzados en 2022 por los autores de YOLOv4. |
||||
6. **[YOLOv8](yolov8.md) NUEVO 🚀**: La última versión de la familia YOLO, con capacidades mejoradas como segmentación de instancias, estimación de posturas/puntos clave y clasificación. |
||||
7. **[Modelo Segment Anything (SAM)](sam.md)**: Modelo Segment Anything (SAM) de Meta. |
||||
8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: MobileSAM para aplicaciones móviles, por la Universidad de Kyung Hee. |
||||
9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: FastSAM por el Grupo de Análisis de Imagen y Video, Instituto de Automatización, Academia China de Ciencias. |
||||
10. **[YOLO-NAS](yolo-nas.md)**: Modelos YOLO de Búsqueda de Arquitectura Neural (NAS). |
||||
11. **[Transformadores de Detección en Tiempo Real (RT-DETR)](rtdetr.md)**: Modelos de Transformador de Detección en Tiempo Real (RT-DETR) de Baidu's PaddlePaddle. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/MWq1UxqTClU?si=nHAW-lYDzrz68jR0" |
||||
title="Reproductor de video de YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Mira:</strong> Ejecuta modelos YOLO de Ultralytics en solo unas pocas líneas de código. |
||||
</p> |
||||
|
||||
## Empezando: Ejemplos de Uso |
||||
|
||||
Este ejemplo proporciona ejemplos simples de entrenamiento e inferencia YOLO. Para la documentación completa de estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md). |
||||
|
||||
Nota que el siguiente ejemplo es para los modelos YOLOv8 [Detect](../tasks/detect.md) para detección de objetos. Para tareas adicionales soportadas, consulta la documentación de [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) y [Pose](../tasks/pose.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
Los modelos pre-entrenados `*.pt` de PyTorch así como los archivos de configuración `*.yaml` se pueden pasar a las clases `YOLO()`, `SAM()`, `NAS()` y `RTDETR()` para crear una instancia de modelo en Python: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo YOLOv8n preentrenado en COCO |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Mostrar información del modelo (opcional) |
||||
model.info() |
||||
|
||||
# Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Ejecutar inferencia con el modelo YOLOv8n en la imagen 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Los comandos CLI están disponibles para ejecutar directamente los modelos: |
||||
|
||||
```bash |
||||
# Cargar un modelo YOLOv8n preentrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Cargar un modelo YOLOv8n preentrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg' |
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Contribuir con Nuevos Modelos |
||||
|
||||
¿Interesado en contribuir con tu modelo a Ultralytics? ¡Genial! Siempre estamos abiertos a expandir nuestro portafolio de modelos. |
||||
|
||||
1. **Haz un Fork del Repositorio**: Comienza haciendo un fork del [repositorio de GitHub de Ultralytics](https://github.com/ultralytics/ultralytics). |
||||
|
||||
2. **Clona tu Fork**: Clona tu fork a tu máquina local y crea una nueva rama para trabajar. |
||||
|
||||
3. **Implementa tu Modelo**: Añade tu modelo siguiendo los estándares de codificación y directrices proporcionadas en nuestra [Guía de Contribución](../../help/contributing.md). |
||||
|
||||
4. **Prueba Rigurosamente**: Asegúrate de probar tu modelo rigurosamente, tanto de forma aislada como parte del proceso. |
||||
|
||||
5. **Crea un Pull Request**: Una vez que estés satisfecho con tu modelo, crea un pull request al repositorio principal para revisión. |
||||
|
||||
6. **Revisión de Código y Fusión**: Después de la revisión, si tu modelo cumple con nuestros criterios, será fusionado al repositorio principal. |
||||
|
||||
Para pasos detallados, consulta nuestra [Guía de Contribución](../../help/contributing.md). |
||||
@ -1,116 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Obtén más información sobre MobileSAM, su implementación, comparación con SAM original y cómo descargarlo y probarlo en el framework de Ultralytics. ¡Mejora tus aplicaciones móviles hoy mismo! |
||||
keywords: MobileSAM, Ultralytics, SAM, aplicaciones móviles, Arxiv, GPU, API, codificador de imágenes, decodificador de máscaras, descarga de modelos, método de prueba |
||||
--- |
||||
|
||||
 |
||||
|
||||
# Segmentación Móvil de Cualquier Cosa (MobileSAM) |
||||
|
||||
El artículo de MobileSAM ahora está disponible en [arXiv](https://arxiv.org/pdf/2306.14289.pdf). |
||||
|
||||
Una demostración de MobileSAM funcionando en una CPU se puede acceder en este [enlace de demostración](https://huggingface.co/spaces/dhkim2810/MobileSAM). El rendimiento en una CPU Mac i5 tarda aproximadamente 3 segundos. En la demostración de Hugging Face, la interfaz y las CPUs de menor rendimiento contribuyen a una respuesta más lenta, pero sigue funcionando de manera efectiva. |
||||
|
||||
MobileSAM se implementa en varios proyectos, incluyendo [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling) y [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D). |
||||
|
||||
MobileSAM se entrena en una sola GPU con un conjunto de datos de 100k (1% de las imágenes originales) en menos de un día. El código para este entrenamiento estará disponible en el futuro. |
||||
|
||||
## Modelos Disponibles, Tareas Admitidas y Modos de Operación |
||||
|
||||
Esta tabla presenta los modelos disponibles con sus pesos pre-entrenados específicos, las tareas que admiten y su compatibilidad con diferentes modos de operación como [Inference (Inferencia)](../modes/predict.md), [Validation (Validación)](../modes/val.md), [Training (Entrenamiento)](../modes/train.md) y [Export (Exportación)](../modes/export.md), indicados por emojis ✅ para los modos admitidos y emojis ❌ para los modos no admitidos. |
||||
|
||||
| Tipo de Modelo | Pesos Pre-entrenados | Tareas Admitidas | Inferencia | Validación | Entrenamiento | Exportación | |
||||
|----------------|----------------------|---------------------------------------------------|------------|------------|---------------|-------------| |
||||
| MobileSAM | `mobile_sam.pt` | [Segmentación de Instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Adaptación de SAM a MobileSAM |
||||
|
||||
Dado que MobileSAM mantiene el mismo pipeline que SAM original, hemos incorporado el pre-procesamiento, post-procesamiento y todas las demás interfaces del original. En consecuencia, aquellos que actualmente utilizan SAM original pueden hacer la transición a MobileSAM con un esfuerzo mínimo. |
||||
|
||||
MobileSAM tiene un rendimiento comparable a SAM original y mantiene el mismo pipeline excepto por un cambio en el codificador de imágenes. Específicamente, reemplazamos el codificador de imágenes original ViT-H pesado (632M) por uno más pequeño, Tiny-ViT (5M). En una sola GPU, MobileSAM funciona a aproximadamente 12ms por imagen: 8ms en el codificador de imágenes y 4ms en el decodificador de máscaras. |
||||
|
||||
La siguiente tabla proporciona una comparación de los codificadores de imágenes basados en ViT: |
||||
|
||||
| Codificador de Imágenes | SAM Original | MobileSAM | |
||||
|-------------------------|--------------|-----------| |
||||
| Parámetros | 611M | 5M | |
||||
| Velocidad | 452ms | 8ms | |
||||
|
||||
Tanto SAM original como MobileSAM utilizan el mismo decodificador de máscaras guiado por instrucciones: |
||||
|
||||
| Decodificador de Máscaras | SAM Original | MobileSAM | |
||||
|---------------------------|--------------|-----------| |
||||
| Parámetros | 3.876M | 3.876M | |
||||
| Velocidad | 4ms | 4ms | |
||||
|
||||
Aquí está la comparación de todo el pipeline: |
||||
|
||||
| Pipeline Completo (Enc+Dec) | SAM Original | MobileSAM | |
||||
|-----------------------------|--------------|-----------| |
||||
| Parámetros | 615M | 9.66M | |
||||
| Velocidad | 456ms | 12ms | |
||||
|
||||
El rendimiento de MobileSAM y SAM original se demuestra utilizando tanto un punto como una caja como instrucciones. |
||||
|
||||
 |
||||
|
||||
 |
||||
|
||||
Con su rendimiento superior, MobileSAM es aproximadamente 5 veces más pequeño y 7 veces más rápido que el actual FastSAM. Más detalles están disponibles en la [página del proyecto de MobileSAM](https://github.com/ChaoningZhang/MobileSAM). |
||||
|
||||
## Probando MobileSAM en Ultralytics |
||||
|
||||
Al igual que SAM original, ofrecemos un método sencillo de prueba en Ultralytics, que incluye modos tanto para instrucciones de Punto como para Caja. |
||||
|
||||
### Descarga del Modelo |
||||
|
||||
Puedes descargar el modelo [aquí](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt). |
||||
|
||||
### Instrucción de Punto |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Carga el modelo |
||||
model = SAM('mobile_sam.pt') |
||||
|
||||
# Predice un segmento basado en una instrucción de punto |
||||
model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1]) |
||||
``` |
||||
|
||||
### Instrucción de Caja |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Carga el modelo |
||||
model = SAM('mobile_sam.pt') |
||||
|
||||
# Predice un segmento basado en una instrucción de caja |
||||
model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709]) |
||||
``` |
||||
|
||||
Hemos implementado `MobileSAM` y `SAM` utilizando la misma API. Para obtener más información sobre cómo usarlo, consulta la [página de SAM](sam.md). |
||||
|
||||
## Citaciones y Reconocimientos |
||||
|
||||
Si encuentras útil MobileSAM en tu investigación o trabajo de desarrollo, considera citar nuestro artículo: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{mobile_sam, |
||||
title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications}, |
||||
author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon}, |
||||
journal={arXiv preprint arXiv:2306.14289}, |
||||
year={2023} |
||||
} |
||||
@ -1,93 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Descubre las características y beneficios de RT-DETR, un eficiente y adaptable detector de objetos en tiempo real desarrollado por Baidu y potenciado por Vision Transformers, que incluye modelos pre-entrenados. |
||||
keywords: RT-DETR, Baidu, Vision Transformers, detección de objetos, rendimiento en tiempo real, CUDA, TensorRT, selección de consultas IoU, Ultralytics, API de Python, PaddlePaddle |
||||
--- |
||||
|
||||
# RT-DETR de Baidu: Un Detector de Objetos en Tiempo Real Basado en Vision Transformers |
||||
|
||||
## Resumen |
||||
|
||||
Real-Time Detection Transformer (RT-DETR), desarrollado por Baidu, es un avanzado detector de objetos de extremo a extremo que proporciona un rendimiento en tiempo real manteniendo una alta precisión. Utiliza la potencia de Vision Transformers (ViT) para procesar de manera eficiente características de múltiples escalas mediante la descomposición de la interacción intra-escala y la fusión inter-escala. RT-DETR es altamente adaptable y permite ajustar de manera flexible la velocidad de inferencia utilizando diferentes capas de decodificador sin necesidad de volver a entrenar el modelo. El modelo se destaca en plataformas aceleradas como CUDA con TensorRT, superando a muchos otros detectores de objetos en tiempo real. |
||||
|
||||
 |
||||
**Resumen de RT-DETR de Baidu.** El diagrama de la arquitectura del modelo RT-DETR muestra las últimas tres etapas del canal (S3, S4, S5) como entrada al codificador. El eficiente codificador híbrido transforma características de múltiples escalas en una secuencia de características de imagen a través del módulo de interacción de características intra-escala (AIFI) y el módulo de fusión de características inter-escala (CCFM). Se utiliza la selección de consultas IoU-aware para seleccionar un número fijo de características de imagen que servirán como consultas iniciales de objetos para el decodificador. Finalmente, el decodificador con cabeceras de predicción auxiliares optimiza iterativamente las consultas de objetos para generar cajas y puntuaciones de confianza ([fuente](https://arxiv.org/pdf/2304.08069.pdf)). |
||||
|
||||
### Características Clave |
||||
|
||||
- **Codificador Híbrido Eficiente:** RT-DETR de Baidu utiliza un codificador híbrido eficiente que procesa características de múltiples escalas mediante la descomposición de la interacción intra-escala y la fusión inter-escala. Este diseño único basado en Vision Transformers reduce los costos computacionales y permite la detección de objetos en tiempo real. |
||||
- **Selección de Consultas IoU-aware:** RT-DETR de Baidu mejora la inicialización de las consultas de objetos utilizando la selección de consultas IoU-aware. Esto permite que el modelo se enfoque en los objetos más relevantes de la escena, mejorando la precisión en la detección. |
||||
- **Velocidad de Inferencia Adaptable:** RT-DETR de Baidu admite ajustes flexibles de la velocidad de inferencia utilizando diferentes capas de decodificador sin necesidad de volver a entrenar el modelo. Esta adaptabilidad facilita la aplicación práctica en diversos escenarios de detección de objetos en tiempo real. |
||||
|
||||
## Modelos Pre-entrenados |
||||
|
||||
La API de Python de Ultralytics proporciona modelos pre-entrenados de RT-DETR de PaddlePaddle en diferentes escalas: |
||||
|
||||
- RT-DETR-L: 53.0% AP en COCO val2017, 114 FPS en GPU T4 |
||||
- RT-DETR-X: 54.8% AP en COCO val2017, 74 FPS en GPU T4 |
||||
|
||||
## Ejemplos de Uso |
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de RT-DETRR. Para obtener una documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import RTDETR |
||||
|
||||
# Cargar un modelo RT-DETR-l pre-entrenado en COCO |
||||
model = RTDETR('rtdetr-l.pt') |
||||
|
||||
# Mostrar información del modelo (opcional) |
||||
model.info() |
||||
|
||||
# Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Realizar inferencia con el modelo RT-DETR-l en la imagen 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Cargar un modelo RT-DETR-l pre-entrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Cargar un modelo RT-DETR-l pre-entrenado en COCO y realizar inferencia en la imagen 'bus.jpg' |
||||
yolo predict model=rtdetr-l.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Tareas y Modos Admitidos |
||||
|
||||
Esta tabla presenta los tipos de modelos, los pesos pre-entrenados específicos, las tareas admitidas por cada modelo y los diversos modos ([Train](../modes/train.md) , [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)) admitidos, indicados por los emojis ✅. |
||||
|
||||
| Tipo de Modelo | Pesos Pre-entrenados | Tareas Admitidas | Inferencia | Validación | Entrenamiento | Exportación | |
||||
|---------------------|----------------------|--------------------------------------------|------------|------------|---------------|-------------| |
||||
| RT-DETR Large | `rtdetr-l.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| RT-DETR Extra-Large | `rtdetr-x.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
## Citaciones y Agradecimientos |
||||
|
||||
Si utilizas RT-DETR de Baidu en tu investigación o trabajo de desarrollo, por favor cita el [artículo original](https://arxiv.org/abs/2304.08069): |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{lv2023detrs, |
||||
title={DETRs Beat YOLOs on Real-time Object Detection}, |
||||
author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu}, |
||||
year={2023}, |
||||
eprint={2304.08069}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Nos gustaría agradecer a Baidu y al equipo de [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) por crear y mantener este valioso recurso para la comunidad de visión por computadora. Apreciamos enormemente su contribución al campo con el desarrollo del detector de objetos en tiempo real basado en Vision Transformers, RT-DETR. |
||||
|
||||
*keywords: RT-DETR, Transformer, ViT, Vision Transformers, Baidu RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, detección de objetos en tiempo real, detección de objetos basada en Vision Transformers, modelos pre-entrenados PaddlePaddle RT-DETR, uso de RT-DETR de Baidu, API de Python de Ultralytics* |
||||
@ -1,226 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explora el revolucionario Segment Anything Model (SAM) de Ultralytics que permite la segmentación de imágenes en tiempo real. Aprende sobre su segmentación por indicación, rendimiento en la transferencia sin entrenamiento y cómo usarlo. |
||||
keywords: Ultralytics, segmentación de imágenes, Segment Anything Model, SAM, SA-1B dataset, rendimiento en tiempo real, transferencia sin entrenamiento, detección de objetos, análisis de imágenes, aprendizaje automático |
||||
--- |
||||
|
||||
# Segment Anything Model (SAM) |
||||
|
||||
Bienvenido al frontera de la segmentación de imágenes con el Segment Anything Model, o SAM. Este modelo revolucionario ha cambiado el juego al introducir la segmentación de imágenes por indicación con rendimiento en tiempo real, estableciendo nuevos estándares en el campo. |
||||
|
||||
## Introducción a SAM: Segment Anything Model |
||||
|
||||
El Segment Anything Model, o SAM, es un modelo de segmentación de imágenes de vanguardia que permite la segmentación por indicación, ofreciendo una versatilidad sin igual en las tareas de análisis de imágenes. SAM forma el corazón de la iniciativa Segment Anything, un proyecto innovador que presenta un modelo, una tarea y un conjunto de datos nuevos para la segmentación de imágenes. |
||||
|
||||
El diseño avanzado de SAM le permite adaptarse a nuevas distribuciones y tareas de imágenes sin conocimientos previos, una característica conocida como transferencia sin entrenamiento. Entrenado en el extenso [conjunto de datos SA-1B](https://ai.facebook.com/datasets/segment-anything/), que contiene más de mil millones de máscaras distribuidas en once millones de imágenes seleccionadas cuidadosamente, SAM ha demostrado un impresionante rendimiento en la transferencia sin entrenamiento, superando en muchos casos los resultados de supervisión completa anteriores. |
||||
|
||||
 |
||||
Imágenes de ejemplo con máscaras superpuestas de nuestro nuevo conjunto de datos, SA-1B. SA-1B contiene 11 millones de imágenes diversas de alta resolución, con licencia y protección de la privacidad, y 1.1 mil millones de máscaras de segmentación de alta calidad. Estas máscaras fueron anotadas completamente automáticamente por SAM y, según las calificaciones humanas y numerosos experimentos, tienen una alta calidad y diversidad. Las imágenes se agrupan por número de máscaras por imagen para su visualización (hay aproximadamente 100 máscaras por imagen en promedio). |
||||
|
||||
## Características clave del Segment Anything Model (SAM) |
||||
|
||||
- **Tarea de segmentación por indicación**: SAM fue diseñado teniendo en cuenta una tarea de segmentación por indicación, lo que le permite generar máscaras de segmentación válidas a partir de cualquier indicación dada, como pistas espaciales o de texto que identifican un objeto. |
||||
- **Arquitectura avanzada**: El Segment Anything Model utiliza un potente codificador de imágenes, un codificador de indicaciones y un decodificador de máscaras ligero. Esta arquitectura única permite la indicación flexible, el cálculo de máscaras en tiempo real y la conciencia de ambigüedades en las tareas de segmentación. |
||||
- **El conjunto de datos SA-1B**: Introducido por el proyecto Segment Anything, el conjunto de datos SA-1B cuenta con más de mil millones de máscaras en once millones de imágenes. Como el conjunto de datos de segmentación más grande hasta la fecha, proporciona a SAM una fuente de datos de entrenamiento diversa y a gran escala. |
||||
- **Rendimiento en la transferencia sin entrenamiento**: SAM muestra un destacado rendimiento en la transferencia sin entrenamiento en diversas tareas de segmentación, lo que lo convierte en una herramienta lista para usar en diversas aplicaciones con una necesidad mínima de ingeniería de indicación. |
||||
|
||||
Para obtener una visión más detallada del Segment Anything Model y el conjunto de datos SA-1B, visita el [sitio web de Segment Anything](https://segment-anything.com) y consulta el artículo de investigación [Segment Anything](https://arxiv.org/abs/2304.02643). |
||||
|
||||
## Modelos disponibles, tareas admitidas y modos de funcionamiento |
||||
|
||||
Esta tabla muestra los modelos disponibles con sus pesos pre-entrenados específicos, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento como [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) y [Export](../modes/export.md), indicados con emojis ✅ para los modos admitidos y emojis ❌ para los modos no admitidos. |
||||
|
||||
| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inference | Validation | Training | Export | |
||||
|----------------|----------------------|---------------------------------------------------|-----------|------------|----------|--------| |
||||
| SAM base | `sam_b.pt` | [Segmentación de instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
| SAM large | `sam_l.pt` | [Segmentación de instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Cómo usar SAM: Versatilidad y potencia en la segmentación de imágenes |
||||
|
||||
El Segment Anything Model se puede utilizar para una multitud de tareas posteriores que van más allá de sus datos de entrenamiento. Esto incluye detección de bordes, generación de propuestas de objetos, segmentación de instancias y predicción preliminar de texto a máscara. Con la ingeniería de indicación, SAM puede adaptarse rápidamente a nuevas tareas y distribuciones de datos de manera sin entrenamiento, estableciéndolo como una herramienta versátil y potente para todas tus necesidades de segmentación de imágenes. |
||||
|
||||
### Ejemplo de predicción con SAM |
||||
|
||||
!!! Example "Segmentar con indicaciones" |
||||
|
||||
Segmenta la imagen con las indicaciones proporcionadas. |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Cargar un modelo |
||||
modelo = SAM('sam_b.pt') |
||||
|
||||
# Mostrar información del modelo (opcional) |
||||
modelo.info() |
||||
|
||||
# Ejecutar inferencia con indicaciones de bboxes |
||||
modelo('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709]) |
||||
|
||||
# Ejecutar inferencia con indicaciones de puntos |
||||
modelo('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1]) |
||||
``` |
||||
|
||||
!!! Example "Segmentar todo" |
||||
|
||||
Segmenta toda la imagen. |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Cargar un modelo |
||||
modelo = SAM('sam_b.pt') |
||||
|
||||
# Mostrar información del modelo (opcional) |
||||
modelo.info() |
||||
|
||||
# Ejecutar inferencia |
||||
modelo('ruta/hacia/imagen.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Ejecutar inferencia con un modelo SAM |
||||
yolo predict model=sam_b.pt source=ruta/hacia/imagen.jpg |
||||
``` |
||||
|
||||
- La lógica aquí es segmentar toda la imagen si no se proporcionan indicaciones (bboxes/puntos/máscaras). |
||||
|
||||
!!! Example "Ejemplo de SAMPredictor" |
||||
|
||||
De esta manera, puedes configurar una imagen una vez y ejecutar inferencia con indicaciones múltiples sin ejecutar el codificador de imágenes múltiples veces. |
||||
|
||||
=== "Inferencia con indicaciones" |
||||
|
||||
```python |
||||
from ultralytics.models.sam import Predictor as SAMPredictor |
||||
|
||||
# Crear SAMPredictor |
||||
opciones = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt") |
||||
predictor = SAMPredictor(opciones=opciones) |
||||
|
||||
# Establecer imagen |
||||
predictor.set_image("ultralytics/assets/zidane.jpg") # establecer con archivo de imagen |
||||
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # establecer con np.ndarray |
||||
resultados = predictor(bboxes=[439, 437, 524, 709]) |
||||
resultados = predictor(points=[900, 370], labels=[1]) |
||||
|
||||
# Restablecer imagen |
||||
predictor.reset_image() |
||||
``` |
||||
|
||||
Segmentar todo con argumentos adicionales. |
||||
|
||||
=== "Segmentar todo" |
||||
|
||||
```python |
||||
from ultralytics.models.sam import Predictor as SAMPredictor |
||||
|
||||
# Crear SAMPredictor |
||||
opciones = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt") |
||||
predictor = SAMPredictor(opciones=opciones) |
||||
|
||||
# Segmentar con argumentos adicionales |
||||
resultados = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64) |
||||
``` |
||||
|
||||
- Más argumentos adicionales para `Segmentar todo` en [`Referencia de Predictor/generate`](../../../reference/models/sam/predict.md). |
||||
|
||||
## SAM comparado con YOLOv8 |
||||
|
||||
Aquí comparamos el modelo SAM más pequeño de Meta, SAM-b, con el modelo de segmentación más pequeño de Ultralytics, [YOLOv8n-seg](../tasks/segment.md): |
||||
|
||||
| Modelo | Tamaño | Parámetros | Velocidad (CPU) | |
||||
|-------------------------------------------------|-------------------------------------|------------------------------|-------------------------------------| |
||||
| SAM-b de Meta | 358 MB | 94.7 M | 51096 ms/im | |
||||
| [MobileSAM](mobile-sam.md) | 40.7 MB | 10.1 M | 46122 ms/im | |
||||
| [FastSAM-s](fast-sam.md) con respaldo de YOLOv8 | 23.7 MB | 11.8 M | 115 ms/im | |
||||
| YOLOv8n-seg de Ultralytics | **6.7 MB** (53.4 veces más pequeño) | **3.4 M** (27.9 veces menos) | **59 ms/im** (866 veces más rápido) | |
||||
|
||||
Esta comparación muestra las diferencias de órdenes de magnitud en los tamaños y velocidades de los modelos. Si bien SAM presenta capacidades únicas para la segmentación automática, no es un competidor directo de los modelos de segmentación YOLOv8, que son más pequeños, más rápidos y más eficientes. |
||||
|
||||
Las pruebas se realizaron en una MacBook Apple M2 de 2023 con 16 GB de RAM. Para reproducir esta prueba: |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM, SAM, YOLO |
||||
|
||||
# Perfil del modelo SAM-b |
||||
modelo = SAM('sam_b.pt') |
||||
modelo.info() |
||||
modelo('ultralytics/assets') |
||||
|
||||
# Perfil de MobileSAM |
||||
modelo = SAM('mobile_sam.pt') |
||||
modelo.info() |
||||
modelo('ultralytics/assets') |
||||
|
||||
# Perfil de FastSAM-s |
||||
modelo = FastSAM('FastSAM-s.pt') |
||||
modelo.info() |
||||
modelo('ultralytics/assets') |
||||
|
||||
# Perfil de YOLOv8n-seg |
||||
modelo = YOLO('yolov8n-seg.pt') |
||||
modelo.info() |
||||
modelo('ultralytics/assets') |
||||
``` |
||||
|
||||
## Auto-anotación: un camino rápido hacia conjuntos de datos de segmentación |
||||
|
||||
La auto-anotación es una característica clave de SAM que permite a los usuarios generar un [conjunto de datos de segmentación](https://docs.ultralytics.com/datasets/segment) utilizando un modelo de detección pre-entrenado. Esta función permite una anotación rápida y precisa de un gran número de imágenes, evitando la necesidad de una etiquetación manual que consume mucho tiempo. |
||||
|
||||
### Generar tu conjunto de datos de segmentación utilizando un modelo de detección |
||||
|
||||
Para auto-anotar tu conjunto de datos con el marco de trabajo de Ultralytics, utiliza la función `auto_annotate` como se muestra a continuación: |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics.data.annotator import auto_annotate |
||||
|
||||
auto_annotate(data="ruta/a/las/imagenes", det_model="yolov8x.pt", sam_model='sam_b.pt') |
||||
``` |
||||
|
||||
| Argumento | Tipo | Descripción | Predeterminado | |
||||
|------------|---------------------|-----------------------------------------------------------------------------------------------------------------------|----------------| |
||||
| data | str | Ruta a una carpeta que contiene las imágenes a anotar. | | |
||||
| det_model | str, opcional | Modelo de detección YOLO pre-entrenado. Por defecto, 'yolov8x.pt'. | 'yolov8x.pt' | |
||||
| sam_model | str, opcional | Modelo de segmentación SAM pre-entrenado. Por defecto, 'sam_b.pt'. | 'sam_b.pt' | |
||||
| device | str, opcional | Dispositivo en el que ejecutar los modelos. Por defecto, una cadena vacía (CPU o GPU, si está disponible). | | |
||||
| output_dir | str, None, opcional | Directorio para guardar los resultados anotados. Por defecto, una carpeta 'labels' en el mismo directorio que 'data'. | None | |
||||
|
||||
La función `auto_annotate` toma la ruta de tus imágenes, con argumentos opcionales para especificar los modelos de detección y segmentación SAM pre-entrenados, el dispositivo en el que ejecutar los modelos, y el directorio de salida para guardar los resultados anotados. |
||||
|
||||
La auto-anotación con modelos pre-entrenados puede reducir drásticamente el tiempo y el esfuerzo requeridos para crear conjuntos de datos de segmentación de alta calidad. Esta característica es especialmente beneficiosa para investigadores y desarrolladores que trabajan con grandes colecciones de imágenes, ya que les permite centrarse en el desarrollo y la evaluación de modelos en lugar de en la anotación manual. |
||||
|
||||
## Citas y agradecimientos |
||||
|
||||
Si encuentras útil SAM en tu trabajo de investigación o desarrollo, considera citar nuestro artículo: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{kirillov2023segment, |
||||
title={Segment Anything}, |
||||
author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollár and Ross Girshick}, |
||||
year={2023}, |
||||
eprint={2304.02643}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Nos gustaría expresar nuestro agradecimiento a Meta AI por crear y mantener este valioso recurso para la comunidad de visión por computadora. |
||||
|
||||
*keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, segmentación de imágenes, segmentación por indicación, rendimiento en la transferencia sin entrenamiento, conjunto de datos SA-1B, arquitectura avanzada, auto-anotación, Ultralytics, modelos pre-entrenados, SAM base, SAM large, segmentación de instancias, visión por computadora, IA, inteligencia artificial, aprendizaje automático, anotación de datos, máscaras de segmentación, modelo de detección, modelo de detección YOLO, bibtex, Meta AI.* |
||||
@ -1,121 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explora la documentación detallada de YOLO-NAS, un modelo de detección de objetos superior. Aprende sobre sus características, modelos pre-entrenados, uso con la API de Ultralytics Python, y más. |
||||
keywords: YOLO-NAS, Deci AI, detección de objetos, aprendizaje profundo, búsqueda de arquitectura neural, API de Ultralytics Python, modelo YOLO, modelos pre-entrenados, cuantización, optimización, COCO, Objects365, Roboflow 100 |
||||
--- |
||||
|
||||
# YOLO-NAS |
||||
|
||||
## Visión general |
||||
|
||||
Desarrollado por Deci AI, YOLO-NAS es un modelo revolucionario de detección de objetos. Es el producto de una tecnología avanzada de Búsqueda de Arquitectura Neural, meticulosamente diseñada para abordar las limitaciones de los modelos YOLO anteriores. Con mejoras significativas en el soporte de cuantización y el equilibrio entre precisión y latencia, YOLO-NAS representa un gran avance en la detección de objetos. |
||||
|
||||
 |
||||
**Visión general de YOLO-NAS.** YOLO-NAS utiliza bloques conscientes de cuantización y cuantización selectiva para un rendimiento óptimo. El modelo, cuando se convierte en su versión cuantizada INT8, experimenta una caída mínima de precisión, una mejora significativa en comparación con otros modelos. Estos avances culminan en una arquitectura superior con capacidades de detección de objetos sin precedentes y un rendimiento sobresaliente. |
||||
|
||||
### Características clave |
||||
|
||||
- **Bloque básico compatible con cuantización:** YOLO-NAS introduce un nuevo bloque básico que es compatible con la cuantización, abordando una de las limitaciones significativas de los modelos YOLO anteriores. |
||||
- **Entrenamiento sofisticado y cuantización:** YOLO-NAS utiliza esquemas avanzados de entrenamiento y cuantización posterior para mejorar el rendimiento. |
||||
- **Optimización AutoNAC y pre-entrenamiento:** YOLO-NAS utiliza la optimización AutoNAC y se pre-entrena en conjuntos de datos prominentes como COCO, Objects365 y Roboflow 100. Este pre-entrenamiento lo hace extremadamente adecuado para tareas de detección de objetos en entornos de producción. |
||||
|
||||
## Modelos pre-entrenados |
||||
|
||||
Experimenta el poder de la detección de objetos de próxima generación con los modelos pre-entrenados de YOLO-NAS proporcionados por Ultralytics. Estos modelos están diseñados para ofrecer un rendimiento de primera clase tanto en velocidad como en precisión. Elige entre una variedad de opciones adaptadas a tus necesidades específicas: |
||||
|
||||
| Modelo | mAP | Latencia (ms) | |
||||
|------------------|-------|---------------| |
||||
| YOLO-NAS S | 47.5 | 3.21 | |
||||
| YOLO-NAS M | 51.55 | 5.85 | |
||||
| YOLO-NAS L | 52.22 | 7.87 | |
||||
| YOLO-NAS S INT-8 | 47.03 | 2.36 | |
||||
| YOLO-NAS M INT-8 | 51.0 | 3.78 | |
||||
| YOLO-NAS L INT-8 | 52.1 | 4.78 | |
||||
|
||||
Cada variante del modelo está diseñada para ofrecer un equilibrio entre la Precisión Promedio de las Areas (mAP, por sus siglas en inglés) y la latencia, ayudándote a optimizar tus tareas de detección de objetos en términos de rendimiento y velocidad. |
||||
|
||||
## Ejemplos de uso |
||||
|
||||
Ultralytics ha facilitado la integración de los modelos YOLO-NAS en tus aplicaciones de Python a través de nuestro paquete `ultralytics`. El paquete proporciona una API de Python fácil de usar para agilizar el proceso. |
||||
|
||||
Los siguientes ejemplos muestran cómo usar los modelos YOLO-NAS con el paquete `ultralytics` para inferencia y validación: |
||||
|
||||
### Ejemplos de inferencia y validación |
||||
|
||||
En este ejemplo validamos YOLO-NAS-s en el conjunto de datos COCO8. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
Este ejemplo proporciona un código simple de inferencia y validación para YOLO-NAS. Para manejar los resultados de la inferencia, consulta el modo [Predict](../modes/predict.md). Para usar YOLO-NAS con modos adicionales, consulta [Val](../modes/val.md) y [Export](../modes/export.md). El paquete `ultralytics` para YOLO-NAS no admite entrenamiento. |
||||
|
||||
=== "Python" |
||||
|
||||
Los archivos de modelos pre-entrenados `*.pt` de PyTorch se pueden pasar a la clase `NAS()` para crear una instancia del modelo en Python: |
||||
|
||||
```python |
||||
from ultralytics import NAS |
||||
|
||||
# Carga un modelo YOLO-NAS-s pre-entrenado en COCO |
||||
modelo = NAS('yolo_nas_s.pt') |
||||
|
||||
# Muestra información del modelo (opcional) |
||||
modelo.info() |
||||
|
||||
# Valida el modelo en el conjunto de datos de ejemplo COCO8 |
||||
resultados = modelo.val(data='coco8.yaml') |
||||
|
||||
# Ejecuta inferencia con el modelo YOLO-NAS-s en la imagen 'bus.jpg' |
||||
resultados = modelo('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Los comandos CLI están disponibles para ejecutar directamente los modelos: |
||||
|
||||
```bash |
||||
# Carga un modelo YOLO-NAS-s pre-entrenado en COCO y valida su rendimiento en el conjunto de datos de ejemplo COCO8 |
||||
yolo val model=yolo_nas_s.pt data=coco8.yaml |
||||
|
||||
# Carga un modelo YOLO-NAS-s pre-entrenado en COCO y ejecuta inferencia en la imagen 'bus.jpg' |
||||
yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Tareas y modos compatibles |
||||
|
||||
Ofrecemos tres variantes de los modelos YOLO-NAS: Small (s), Medium (m) y Large (l). Cada variante está diseñada para satisfacer diferentes necesidades computacionales y de rendimiento: |
||||
|
||||
- **YOLO-NAS-s**: Optimizado para entornos donde los recursos computacionales son limitados pero la eficiencia es clave. |
||||
- **YOLO-NAS-m**: Ofrece un enfoque equilibrado, adecuado para la detección de objetos de propósito general con mayor precisión. |
||||
- **YOLO-NAS-l**: Adaptados para escenarios que requieren la mayor precisión, donde los recursos computacionales son menos restrictivos. |
||||
|
||||
A continuación se muestra una descripción detallada de cada modelo, incluyendo enlaces a sus pesos pre-entrenados, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento. |
||||
|
||||
| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inferencia | Validación | Entrenamiento | Exportación | |
||||
|----------------|-----------------------------------------------------------------------------------------------|--------------------------------------------|------------|------------|---------------|-------------| |
||||
| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_s.pt) | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_m.pt) | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_l.pt) | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
|
||||
## Citaciones y agradecimientos |
||||
|
||||
Si utilizas YOLO-NAS en tu investigación o trabajo de desarrollo, por favor cita SuperGradients: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{supergradients, |
||||
doi = {10.5281/ZENODO.7789328}, |
||||
url = {https://zenodo.org/record/7789328}, |
||||
author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}}, |
||||
title = {Super-Gradients}, |
||||
publisher = {GitHub}, |
||||
journal = {GitHub repository}, |
||||
year = {2021}, |
||||
} |
||||
``` |
||||
|
||||
Agradecemos al equipo de [SuperGradients](https://github.com/Deci-AI/super-gradients/) de Deci AI por sus esfuerzos en la creación y mantenimiento de este valioso recurso para la comunidad de visión por computadora. Creemos que YOLO-NAS, con su arquitectura innovadora y sus capacidades de detección de objetos superiores, se convertirá en una herramienta fundamental tanto para desarrolladores como para investigadores. |
||||
|
||||
*keywords: YOLO-NAS, Deci AI, detección de objetos, aprendizaje profundo, búsqueda de arquitectura neural, API de Ultralytics Python, modelo YOLO, SuperGradients, modelos pre-entrenados, bloque básico compatible con cuantización, esquemas avanzados de entrenamiento, cuantización posterior, optimización AutoNAC, COCO, Objects365, Roboflow 100* |
||||
@ -1,98 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Obtén una descripción general de YOLOv3, YOLOv3-Ultralytics y YOLOv3u. Aprende sobre sus características clave, uso y tareas admitidas para la detección de objetos. |
||||
keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Detección de objetos, Inferencia, Entrenamiento, Ultralytics |
||||
--- |
||||
|
||||
# YOLOv3, YOLOv3-Ultralytics y YOLOv3u |
||||
|
||||
## Descripción general |
||||
|
||||
Este documento presenta una descripción general de tres modelos de detección de objetos estrechamente relacionados, conocidos como [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) y [YOLOv3u](https://github.com/ultralytics/ultralytics). |
||||
|
||||
1. **YOLOv3:** Esta es la tercera versión del algoritmo de detección de objetos You Only Look Once (YOLO). Originalmente desarrollado por Joseph Redmon, YOLOv3 mejoró a sus predecesores al introducir características como predicciones multiescala y tres tamaños diferentes de núcleos de detección. |
||||
|
||||
2. **YOLOv3-Ultralytics:** Esta es la implementación de YOLOv3 realizada por Ultralytics. Reproduce la arquitectura original de YOLOv3 y ofrece funcionalidades adicionales, como soporte para más modelos pre-entrenados y opciones de personalización más fáciles. |
||||
|
||||
3. **YOLOv3u:** Esta es una versión actualizada de YOLOv3-Ultralytics que incorpora la cabeza dividida sin anclaje y sin objeto utilizada en los modelos YOLOv8. YOLOv3u mantiene la misma arquitectura de columna vertebral y cuello que YOLOv3, pero con la cabeza de detección actualizada de YOLOv8. |
||||
|
||||
 |
||||
|
||||
## Características clave |
||||
|
||||
- **YOLOv3:** Introdujo el uso de tres escalas diferentes para la detección, aprovechando tres tamaños diferentes de núcleos de detección: 13x13, 26x26 y 52x52. Esto mejoró significativamente la precisión de detección para objetos de diferentes tamaños. Además, YOLOv3 añadió características como predicciones con múltiples etiquetas para cada cuadro delimitador y una mejor red extractora de características. |
||||
|
||||
- **YOLOv3-Ultralytics:** La implementación de Ultralytics de YOLOv3 proporciona el mismo rendimiento que el modelo original, pero cuenta con soporte adicional para más modelos pre-entrenados, métodos de entrenamiento adicionales y opciones de personalización más fáciles. Esto lo hace más versátil y fácil de usar para aplicaciones prácticas. |
||||
|
||||
- **YOLOv3u:** Este modelo actualizado incorpora la cabeza dividida sin anclaje y sin objeto de YOLOv8. Al eliminar la necesidad de cajas de anclaje predefinidas y puntuaciones de objeto, este diseño de cabeza de detección puede mejorar la capacidad del modelo para detectar objetos de diferentes tamaños y formas. Esto hace que YOLOv3u sea más robusto y preciso para tareas de detección de objetos. |
||||
|
||||
## Tareas y modos admitidos |
||||
|
||||
La serie YOLOv3, que incluye YOLOv3, YOLOv3-Ultralytics y YOLOv3u, está diseñada específicamente para tareas de detección de objetos. Estos modelos son reconocidos por su eficacia en diversos escenarios del mundo real, equilibrando precisión y velocidad. Cada variante ofrece características y optimizaciones únicas, lo que los hace adecuados para una variedad de aplicaciones. |
||||
|
||||
Los tres modelos admiten un conjunto completo de modos, asegurando versatilidad en diversas etapas del despliegue y desarrollo del modelo. Estos modos incluyen [Inferencia](../modes/predict.md), [Validación](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportación](../modes/export.md), proporcionando a los usuarios un conjunto completo de herramientas para una detección de objetos efectiva. |
||||
|
||||
| Tipo de modelo | Tareas admitidas | Inferencia | Validación | Entrenamiento | Exportación | |
||||
|--------------------|--------------------------------------------|------------|------------|---------------|-------------| |
||||
| YOLOv3 | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv3-Ultralytics | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv3u | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Esta tabla proporciona una visión rápida de las capacidades de cada variante de YOLOv3, destacando su versatilidad y aptitud para diversas tareas y modos operativos en flujos de trabajo de detección de objetos. |
||||
|
||||
## Ejemplos de uso |
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de YOLOv3. Para obtener documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
Los modelos pre-entrenados de PyTorch en archivos `*.pt`, así como los archivos de configuración `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia del modelo en Python: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo YOLOv3n pre-entrenado en COCO |
||||
model = YOLO('yolov3n.pt') |
||||
|
||||
# Mostrar información del modelo (opcional) |
||||
model.info() |
||||
|
||||
# Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Ejecutar inferencia con el modelo YOLOv3n en la imagen 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Hay comandos de CLI disponibles para ejecutar directamente los modelos: |
||||
|
||||
```bash |
||||
# Cargar un modelo YOLOv3n pre-entrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Cargar un modelo YOLOv3n pre-entrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg' |
||||
yolo predict model=yolov3n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Citaciones y agradecimientos |
||||
|
||||
Si utilizas YOLOv3 en tu investigación, por favor, cita los artículos originales de YOLO y el repositorio de YOLOv3 de Ultralytics: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{redmon2018yolov3, |
||||
title={YOLOv3: An Incremental Improvement}, |
||||
author={Redmon, Joseph and Farhadi, Ali}, |
||||
journal={arXiv preprint arXiv:1804.02767}, |
||||
year={2018} |
||||
} |
||||
``` |
||||
|
||||
Gracias a Joseph Redmon y Ali Farhadi por desarrollar YOLOv3 original. |
||||
@ -1,71 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explora nuestra detallada guía sobre YOLOv4, un detector de objetos en tiempo real de vanguardia. Comprende sus aspectos arquitectónicos destacados, características innovadoras y ejemplos de aplicación. |
||||
keywords: ultralytics, YOLOv4, detección de objetos, red neuronal, detección en tiempo real, detector de objetos, aprendizaje automático |
||||
--- |
||||
|
||||
# YOLOv4: Detección de objetos rápida y precisa |
||||
|
||||
Bienvenido a la página de documentación de Ultralytics para YOLOv4, un detector de objetos en tiempo real de vanguardia lanzado en 2020 por Alexey Bochkovskiy en [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). YOLOv4 está diseñado para ofrecer un equilibrio óptimo entre velocidad y precisión, lo que lo convierte en una excelente opción para muchas aplicaciones. |
||||
|
||||
 |
||||
**Diagrama de arquitectura de YOLOv4**. Muestra el intrincado diseño de red de YOLOv4, incluyendo los componentes backbone, neck y head, y sus capas interconectadas para una detección de objetos en tiempo real óptima. |
||||
|
||||
## Introducción |
||||
|
||||
YOLOv4 significa You Only Look Once versión 4. Es un modelo de detección de objetos en tiempo real desarrollado para abordar las limitaciones de versiones anteriores de YOLO como [YOLOv3](yolov3.md) y otros modelos de detección de objetos. A diferencia de otros detectores de objetos basados en redes neuronales convolucionales (CNN), YOLOv4 no solo es aplicable para sistemas de recomendación, sino también para la gestión de procesos independientes y la reducción de la entrada humana. Su funcionamiento en unidades de procesamiento de gráficos (GPU) convencionales permite su uso masivo a un precio asequible, y está diseñado para funcionar en tiempo real en una GPU convencional, siendo necesario solo una GPU para el entrenamiento. |
||||
|
||||
## Arquitectura |
||||
|
||||
YOLOv4 utiliza varias características innovadoras que trabajan juntas para optimizar su rendimiento. Estas incluyen Conexiones Residuales Ponderadas (WRC), Conexiones Parciales Cruzadas en Etapas (CSP), Normalización Cruzada de Mini-Batch (CmBN), Entrenamiento Autoadversarial (SAT), Activación Mish, Aumento de Datos Mosaico, Regularización DropBlock y Pérdida CIoU. Estas características se combinan para lograr resultados de vanguardia. |
||||
|
||||
Un detector de objetos típico está compuesto por varias partes, incluyendo la entrada, el backbone (espinazo), el neck (cuello) y el head (cabeza). El backbone de YOLOv4 está pre-entrenado en ImageNet y se utiliza para predecir las clases y las cajas delimitadoras de los objetos. El backbone puede ser de varios modelos, incluyendo VGG, ResNet, ResNeXt o DenseNet. La parte del neck del detector se utiliza para recolectar mapas de características de diferentes etapas y generalmente incluye varias rutas de abajo hacia arriba y varias rutas de arriba hacia abajo. La parte de la cabeza es la que se utiliza para realizar las detecciones y clasificaciones finales de objetos. |
||||
|
||||
## Bolsa de regalos |
||||
|
||||
YOLOv4 también utiliza métodos conocidos como "bolsa de regalos" (bag of freebies), que son técnicas que mejoran la precisión del modelo durante el entrenamiento sin aumentar el costo de la inferencia. La ampliación de datos es una técnica común de la bolsa de regalos utilizada en la detección de objetos, que aumenta la variabilidad de las imágenes de entrada para mejorar la robustez del modelo. Algunos ejemplos de ampliación de datos incluyen distorsiones fotométricas (ajuste del brillo, contraste, matiz, saturación y ruido de una imagen) y distorsiones geométricas (agregar escalado, recorte, volteo y rotación aleatorios). Estas técnicas ayudan al modelo a generalizar mejor para diferentes tipos de imágenes. |
||||
|
||||
## Características y rendimiento |
||||
|
||||
YOLOv4 está diseñado para obtener una velocidad y precisión óptimas en la detección de objetos. La arquitectura de YOLOv4 incluye CSPDarknet53 como backbone, PANet como neck y YOLOv3 como cabeza de detección. Este diseño permite que YOLOv4 realice la detección de objetos a una velocidad impresionante, lo que lo hace adecuado para aplicaciones en tiempo real. YOLOv4 también sobresale en precisión, logrando resultados de vanguardia en los benchmarks de detección de objetos. |
||||
|
||||
## Ejemplos de uso |
||||
|
||||
Hasta el momento de escribir este documento, Ultralytics actualmente no admite modelos YOLOv4. Por lo tanto, cualquier usuario interesado en usar YOLOv4 deberá consultar directamente el repositorio de YOLOv4 en GitHub para obtener instrucciones de instalación y uso. |
||||
|
||||
Aquí hay un resumen breve de los pasos típicos que podrías seguir para usar YOLOv4: |
||||
|
||||
1. Visita el repositorio de YOLOv4 en GitHub: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). |
||||
|
||||
2. Sigue las instrucciones proporcionadas en el archivo README para la instalación. Esto generalmente implica clonar el repositorio, instalar las dependencias necesarias y configurar las variables de entorno necesarias. |
||||
|
||||
3. Una vez que la instalación esté completa, puedes entrenar y usar el modelo según las instrucciones de uso proporcionadas en el repositorio. Esto normalmente implica preparar tu conjunto de datos, configurar los parámetros del modelo, entrenar el modelo y luego usar el modelo entrenado para realizar la detección de objetos. |
||||
|
||||
Ten en cuenta que los pasos específicos pueden variar dependiendo de tu caso de uso específico y del estado actual del repositorio de YOLOv4. Por lo tanto, se recomienda encarecidamente consultar directamente las instrucciones proporcionadas en el repositorio de YOLOv4 en GitHub. |
||||
|
||||
Lamentamos cualquier inconveniente que esto pueda causar y nos esforzaremos por actualizar este documento con ejemplos de uso para Ultralytics una vez que se implemente el soporte para YOLOv4. |
||||
|
||||
## Conclusión |
||||
|
||||
YOLOv4 es un modelo de detección de objetos potente y eficiente que logra un equilibrio entre velocidad y precisión. Su uso de características únicas y técnicas de bolsa de regalos durante el entrenamiento le permite realizar un excelente desempeño en tareas de detección de objetos en tiempo real. YOLOv4 puede ser entrenado y utilizado por cualquier persona con una GPU convencional, lo que lo hace accesible y práctico para una amplia gama de aplicaciones. |
||||
|
||||
## Citaciones y agradecimientos |
||||
|
||||
Nos gustaría reconocer a los autores de YOLOv4 por sus importantes contribuciones en el campo de la detección de objetos en tiempo real: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{bochkovskiy2020yolov4, |
||||
title={YOLOv4: Optimal Speed and Accuracy of Object Detection}, |
||||
author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao}, |
||||
year={2020}, |
||||
eprint={2004.10934}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
El artículo original de YOLOv4 se puede encontrar en [arXiv](https://arxiv.org/abs/2004.10934). Los autores han puesto su trabajo a disposición del público, y el código se puede acceder en [GitHub](https://github.com/AlexeyAB/darknet). Apreciamos sus esfuerzos en el avance del campo y en hacer que su trabajo sea accesible para la comunidad en general. |
||||
@ -1,113 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Descubra YOLOv5u, una versión mejorada del modelo YOLOv5 con un mejor equilibrio entre precisión y velocidad, y numerosos modelos pre-entrenados para diversas tareas de detección de objetos. |
||||
keywords: YOLOv5u, detección de objetos, modelos pre-entrenados, Ultralytics, Inferencia, Validación, YOLOv5, YOLOv8, sin anclas, sin atención al objeto, aplicaciones en tiempo real, aprendizaje automático |
||||
--- |
||||
|
||||
# YOLOv5 |
||||
|
||||
## Resumen |
||||
|
||||
YOLOv5u representa un avance en las metodologías de detección de objetos. Originado a partir de la arquitectura fundamental del modelo [YOLOv5](https://github.com/ultralytics/yolov5) desarrollado por Ultralytics, YOLOv5u integra la división de la cabeza Ultralytics sin anclas y sin atención al objeto, una característica introducida previamente en los modelos [YOLOv8](yolov8.md). Esta adaptación perfecciona la arquitectura del modelo, resultando en un mejor equilibrio entre precisión y velocidad en tareas de detección de objetos. Con base en los resultados empíricos y sus características derivadas, YOLOv5u proporciona una alternativa eficiente para aquellos que buscan soluciones robustas tanto en investigación como en aplicaciones prácticas. |
||||
|
||||
 |
||||
|
||||
## Características clave |
||||
|
||||
- **Cabeza dividida Ultralytics sin anclas:** Los modelos tradicionales de detección de objetos dependen de cajas de anclaje predefinidas para predecir la ubicación de los objetos. Sin embargo, YOLOv5u moderniza este enfoque. Al adoptar una cabeza Ultralytics dividida sin anclas, se garantiza un mecanismo de detección más flexible y adaptable, lo que en consecuencia mejora el rendimiento en diversos escenarios. |
||||
|
||||
- **Equilibrio óptimo entre precisión y velocidad:** La velocidad y la precisión suelen ser contrapuestas. Pero YOLOv5u desafía este equilibrio. Ofrece un balance calibrado, garantizando detecciones en tiempo real sin comprometer la precisión. Esta característica es especialmente valiosa para aplicaciones que requieren respuestas rápidas, como vehículos autónomos, robótica y análisis de video en tiempo real. |
||||
|
||||
- **Variedad de modelos pre-entrenados:** Entendiendo que diferentes tareas requieren diferentes herramientas, YOLOv5u proporciona una gran cantidad de modelos pre-entrenados. Ya sea que te enfoques en Inferencia, Validación o Entrenamiento, hay un modelo a la medida esperándote. Esta variedad asegura que no estés utilizando una solución genérica, sino un modelo específicamente ajustado para tu desafío único. |
||||
|
||||
## Tareas y Modos Soportados |
||||
|
||||
Los modelos YOLOv5u, con diferentes pesos pre-entrenados, sobresalen en las tareas de [Detección de Objetos](../tasks/detect.md). Soportan una amplia gama de modos que los hacen adecuados para diversas aplicaciones, desde el desarrollo hasta la implementación. |
||||
|
||||
| Tipo de Modelo | Pesos Pre-entrenados | Tarea | Inferencia | Validación | Entrenamiento | Exportación | |
||||
|----------------|-----------------------------------------------------------------------------------------------------------------------------|--------------------------------------------|------------|------------|---------------|-------------| |
||||
| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Esta tabla proporciona una descripción detallada de las variantes de modelos YOLOv5u, destacando su aplicabilidad en tareas de detección de objetos y el soporte para varios modos operativos como [Inferencia](../modes/predict.md), [Validación](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportación](../modes/export.md). Este soporte integral asegura que los usuarios puedan aprovechar al máximo las capacidades de los modelos YOLOv5u en una amplia gama de escenarios de detección de objetos. |
||||
|
||||
## Métricas de Rendimiento |
||||
|
||||
!!! Rendimiento |
||||
|
||||
=== "Detección" |
||||
|
||||
Consulta la [Documentación de Detección](https://docs.ultralytics.com/tasks/detect/) para obtener ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/detect/coco/), los cuales incluyen 80 clases pre-entrenadas. |
||||
|
||||
| Modelo | YAML | tamaño<br><sup>(píxeles) | mAP<sup>val<br>50-95 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
|---------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------| |
||||
| [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34.3 | 73.6 | 1.06 | 2.6 | 7.7 | |
||||
| [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43.0 | 120.7 | 1.27 | 9.1 | 24.0 | |
||||
| [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49.0 | 233.9 | 1.86 | 25.1 | 64.2 | |
||||
| [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52.2 | 408.4 | 2.50 | 53.2 | 135.0 | |
||||
| [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53.2 | 763.2 | 3.81 | 97.2 | 246.4 | |
||||
| | | | | | | | | |
||||
| [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 42.1 | 211.0 | 1.83 | 4.3 | 7.8 | |
||||
| [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 48.6 | 422.6 | 2.34 | 15.3 | 24.6 | |
||||
| [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 53.6 | 810.9 | 4.36 | 41.2 | 65.7 | |
||||
| [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 55.7 | 1470.9 | 5.47 | 86.1 | 137.4 | |
||||
| [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 56.8 | 2436.5 | 8.98 | 155.4 | 250.7 | |
||||
|
||||
## Ejemplos de Uso |
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de YOLOv5. Para obtener documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
Los modelos pre-entrenados `*.pt` de PyTorch, así como los archivos de configuración `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia de modelo en Python: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo YOLOv5n pre-entrenado en COCO |
||||
modelo = YOLO('yolov5n.pt') |
||||
|
||||
# Mostrar información del modelo (opcional) |
||||
modelo.info() |
||||
|
||||
# Entrenar el modelo con el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
resultados = modelo.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Ejecutar inferencia con el modelo YOLOv5n en la imagen 'bus.jpg' |
||||
resultados = modelo('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Hay comandos de CLI disponibles para ejecutar directamente los modelos: |
||||
|
||||
```bash |
||||
# Cargar un modelo YOLOv5n pre-entrenado en COCO y entrenarlo con el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Cargar un modelo YOLOv5n pre-entrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg' |
||||
yolo predict model=yolov5n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Citaciones y Reconocimientos |
||||
|
||||
Si utilizas YOLOv5 o YOLOv5u en tu investigación, por favor cita el repositorio de Ultralytics YOLOv5 de la siguiente manera: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
```bibtex |
||||
@software{yolov5, |
||||
title = {Ultralytics YOLOv5}, |
||||
author = {Glenn Jocher}, |
||||
year = {2020}, |
||||
version = {7.0}, |
||||
license = {AGPL-3.0}, |
||||
url = {https://github.com/ultralytics/yolov5}, |
||||
doi = {10.5281/zenodo.3908559}, |
||||
orcid = {0000-0001-5950-6979} |
||||
} |
||||
``` |
||||
|
||||
Ten en cuenta que los modelos YOLOv5 se proporcionan bajo las licencias [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) y [Enterprise](https://ultralytics.com/license). |
||||
@ -1,107 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explora Meituan YOLOv6, un modelo de detección de objetos de última generación que logra un equilibrio entre velocidad y precisión. Sumérgete en características, modelos pre-entrenados y el uso de Python. |
||||
keywords: Meituan YOLOv6, detección de objetos, Ultralytics, documentación de YOLOv6, Concatenación Bidireccional, Entrenamiento con Anclas, modelos pre-entrenados, aplicaciones en tiempo real |
||||
--- |
||||
|
||||
# Meituan YOLOv6 |
||||
|
||||
## Visión general |
||||
|
||||
[Meituan](https://about.meituan.com/) YOLOv6 es un detector de objetos de última generación que ofrece un notable equilibrio entre velocidad y precisión, lo que lo convierte en una opción popular para aplicaciones en tiempo real. Este modelo presenta varias mejoras notables en su arquitectura y esquema de entrenamiento, que incluyen la implementación de un módulo de Concatenación Bidireccional (BiC), una estrategia de entrenamiento con anclas (AAT) y un diseño de columna vertebral y cuello mejorado para lograr una precisión de última generación en el conjunto de datos COCO. |
||||
|
||||
 |
||||
 |
||||
**Visión general de YOLOv6.** Diagrama de la arquitectura del modelo que muestra los componentes de la red redesdiseñados y las estrategias de entrenamiento que han llevado a mejoras significativas en el rendimiento. (a) El cuello de YOLOv6 (N y S se muestran). Señalar que, en M/L, RepBlocks es reemplazado por CSPStackRep. (b) La estructura de un módulo BiC. (c) Un bloque SimCSPSPPF. ([fuente](https://arxiv.org/pdf/2301.05586.pdf)). |
||||
|
||||
### Características clave |
||||
|
||||
- **Módulo de Concatenación Bidireccional (BiC):** YOLOv6 introduce un módulo de BiC en el cuello del detector, mejorando las señales de localización y ofreciendo mejoras en el rendimiento con una degradación de velocidad despreciable. |
||||
- **Estrategia de Entrenamiento con Anclas (AAT):** Este modelo propone AAT para disfrutar de los beneficios de los paradigmas basados en anclas y sin anclas sin comprometer la eficiencia de inferencia. |
||||
- **Diseño de Columna Vertebral y Cuello Mejorado:** Al profundizar en YOLOv6 para incluir otra etapa en la columna vertebral y el cuello, este modelo logra un rendimiento de última generación en el conjunto de datos COCO con una entrada de alta resolución. |
||||
- **Estrategia de Auto-Destilación:** Se implementa una nueva estrategia de auto-destilación para mejorar el rendimiento de los modelos más pequeños de YOLOv6, mejorando la rama de regresión auxiliar durante el entrenamiento y eliminándola durante la inferencia para evitar una marcada disminución de velocidad. |
||||
|
||||
## Métricas de rendimiento |
||||
|
||||
YOLOv6 proporciona varios modelos pre-entrenados con diferentes escalas: |
||||
|
||||
- YOLOv6-N: 37.5% de precisión promedio (AP) en COCO val2017 a 1187 FPS con la GPU NVIDIA Tesla T4. |
||||
- YOLOv6-S: 45.0% de AP a 484 FPS. |
||||
- YOLOv6-M: 50.0% de AP a 226 FPS. |
||||
- YOLOv6-L: 52.8% de AP a 116 FPS. |
||||
- YOLOv6-L6: Precisión de última generación en tiempo real. |
||||
|
||||
YOLOv6 también proporciona modelos cuantizados para diferentes precisiones y modelos optimizados para plataformas móviles. |
||||
|
||||
## Ejemplos de uso |
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia con YOLOv6. Para obtener documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
Los modelos pre-entrenados en `*.pt` de PyTorch, así como los archivos de configuración `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia del modelo en Python: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Construir un modelo YOLOv6n desde cero |
||||
modelo = YOLO('yolov6n.yaml') |
||||
|
||||
# Mostrar información del modelo (opcional) |
||||
modelo.info() |
||||
|
||||
# Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 epochs |
||||
resultados = modelo.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Ejecutar inferencia con el modelo YOLOv6n en la imagen 'bus.jpg' |
||||
resultados = modelo('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Se dispone de comandos de línea de comandos (CLI) para ejecutar directamente los modelos: |
||||
|
||||
```bash |
||||
# Construir un modelo YOLOv6n desde cero y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 epochs |
||||
yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Construir un modelo YOLOv6n desde cero y ejecutar inferencia en la imagen 'bus.jpg' |
||||
yolo predict model=yolov6n.yaml source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Tareas y Modos Soportados |
||||
|
||||
La serie YOLOv6 ofrece una variedad de modelos, cada uno optimizado para [Detección de Objetos](../tasks/detect.md) de alto rendimiento. Estos modelos se adaptan a distintas necesidades computacionales y requisitos de precisión, lo que los hace versátiles para una amplia gama de aplicaciones. |
||||
|
||||
| Tipo de Modelo | Pesos Pre-entrenados | Tareas Soportadas | Inferencia | Validación | Entrenamiento | Exportación | |
||||
|----------------|----------------------|--------------------------------------------|------------|------------|---------------|-------------| |
||||
| YOLOv6-N | `yolov6-n.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-S | `yolov6-s.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-M | `yolov6-m.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-L | `yolov6-l.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-L6 | `yolov6-l6.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Esta tabla proporciona una descripción detallada de las variantes del modelo YOLOv6, destacando sus capacidades en tareas de detección de objetos y su compatibilidad con varios modos operativos como [Inferencia](../modes/predict.md), [Validación](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportación](../modes/export.md). Este soporte integral garantiza que los usuarios puedan aprovechar al máximo las capacidades de los modelos YOLOv6 en una amplia gama de escenarios de detección de objetos. |
||||
|
||||
## Citaciones y Agradecimientos |
||||
|
||||
Nos gustaría agradecer a los autores por sus importantes contribuciones en el campo de la detección de objetos en tiempo real: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{li2023yolov6, |
||||
title={YOLOv6 v3.0: A Full-Scale Reloading}, |
||||
author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu}, |
||||
year={2023}, |
||||
eprint={2301.05586}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Se puede encontrar el artículo original de YOLOv6 en [arXiv](https://arxiv.org/abs/2301.05586). Los autores han puesto su trabajo a disposición del público y el código fuente se puede acceder en [GitHub](https://github.com/meituan/YOLOv6). Agradecemos sus esfuerzos en avanzar en el campo y hacer que su trabajo sea accesible para la comunidad en general. |
||||
@ -1,66 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explora el YOLOv7, un detector de objetos en tiempo real. Comprende su velocidad superior, precisión impresionante y enfoque único en la optimización de entrenamiento de bolsas de características entrenables. |
||||
keywords: YOLOv7, detector de objetos en tiempo real, estado del arte, Ultralytics, conjunto de datos MS COCO, re-parametrización del modelo, asignación dinámica de etiquetas, escalado extendido, escalado compuesto |
||||
--- |
||||
|
||||
# YOLOv7: Bolsa de Características Entrenable |
||||
|
||||
YOLOv7 es un detector de objetos en tiempo real de última generación que supera a todos los detectores de objetos conocidos tanto en velocidad como en precisión en el rango de 5 FPS a 160 FPS. Tiene la mayor precisión (56.8% AP) entre todos los detectores de objetos en tiempo real conocidos con una velocidad de 30 FPS o superior en la GPU V100. Además, YOLOv7 supera a otros detectores de objetos como YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 y muchos otros en cuanto a velocidad y precisión. El modelo se entrena desde cero utilizando el conjunto de datos MS COCO sin utilizar ningún otro conjunto de datos o pesos pre-entrenados. El código fuente de YOLOv7 está disponible en GitHub. |
||||
|
||||
 |
||||
**Comparación de los detectores de objetos de estado del arte. |
||||
** Según los resultados en la Tabla 2, sabemos que el método propuesto tiene el mejor equilibrio entre velocidad y precisión de manera integral. Si comparamos YOLOv7-tiny-SiLU con YOLOv5-N (r6.1), nuestro método es 127 fps más rápido y un 10.7% más preciso en AP. Además, YOLOv7 tiene un AP del 51.4% a una velocidad de cuadro de 161 fps, mientras que PPYOLOE-L con el mismo AP tiene solo una velocidad de cuadro de 78 fps. En términos de uso de parámetros, YOLOv7 utiliza un 41% menos que PPYOLOE-L. Si comparamos YOLOv7-X con una velocidad de inferencia de 114 fps con YOLOv5-L (r6.1) con una velocidad de inferencia de 99 fps, YOLOv7-X puede mejorar el AP en un 3.9%. Si se compara YOLOv7-X con YOLOv5-X (r6.1) de una escala similar, la velocidad de inferencia de YOLOv7-X es 31 fps más rápida. Además, en términos de cantidad de parámetros y cálculos, YOLOv7-X reduce un 22% de los parámetros y un 8% de los cálculos en comparación con YOLOv5-X (r6.1), pero mejora el AP en un 2.2% ([Fuente](https://arxiv.org/pdf/2207.02696.pdf)). |
||||
|
||||
## Descripción general |
||||
|
||||
La detección de objetos en tiempo real es un componente importante en muchos sistemas de visión por computadora, incluyendo el seguimiento de múltiples objetos, conducción autónoma, robótica y análisis de imágenes médicas. En los últimos años, el desarrollo de la detección de objetos en tiempo real se ha centrado en el diseño de arquitecturas eficientes y en la mejora de la velocidad de inferencia de diversas CPUs, GPUs y unidades de procesamiento neural (NPUs). YOLOv7 es compatible tanto con GPU para dispositivos móviles como con GPU para dispositivos de escritorio, desde el borde hasta la nube. |
||||
|
||||
A diferencia de los detectores de objetos en tiempo real tradicionales que se centran en la optimización de la arquitectura, YOLOv7 introduce un enfoque en la optimización del proceso de entrenamiento. Esto incluye módulos y métodos de optimización diseñados para mejorar la precisión de la detección de objetos sin aumentar el costo de inferencia, un concepto conocido como "bolsas de características entrenables". |
||||
|
||||
## Características clave |
||||
|
||||
YOLOv7 introduce varias características clave: |
||||
|
||||
1. **Re-parametrización del modelo**: YOLOv7 propone un modelo re-parametrizado planificado, que es una estrategia aplicable a capas en diferentes redes con el concepto de propagación del gradiente. |
||||
|
||||
2. **Asignación dinámica de etiquetas**: El entrenamiento del modelo con múltiples capas de salida presenta un nuevo problema: "¿Cómo asignar objetivos dinámicos para las salidas de diferentes ramas?" Para resolver este problema, YOLOv7 introduce un nuevo método de asignación de etiquetas llamado asignación de etiquetas guiadas de manera gruesa a fina. |
||||
|
||||
3. **Escalado extendido y compuesto**: YOLOv7 propone métodos de "escalado extendido" y "escalado compuesto" para el detector de objetos en tiempo real que pueden utilizar eficazmente los parámetros y cálculos. |
||||
|
||||
4. **Eficiencia**: El método propuesto por YOLOv7 puede reducir eficazmente aproximadamente el 40% de los parámetros y el 50% de los cálculos del detector de objetos en tiempo real de última generación y tiene una velocidad de inferencia más rápida y una mayor precisión de detección. |
||||
|
||||
## Ejemplos de uso |
||||
|
||||
Hasta la fecha de redacción de este documento, Ultralytics no admite actualmente modelos YOLOv7. Por lo tanto, los usuarios interesados en utilizar YOLOv7 deberán consultar directamente el repositorio de GitHub de YOLOv7 para obtener instrucciones de instalación y uso. |
||||
|
||||
Aquí hay un resumen breve de los pasos típicos que podrías seguir para usar YOLOv7: |
||||
|
||||
1. Visita el repositorio de GitHub de YOLOv7: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7). |
||||
|
||||
2. Sigue las instrucciones proporcionadas en el archivo README para la instalación. Esto generalmente implica clonar el repositorio, instalar las dependencias necesarias y configurar las variables de entorno necesarias. |
||||
|
||||
3. Una vez que la instalación esté completa, puedes entrenar y utilizar el modelo según las instrucciones de uso proporcionadas en el repositorio. Esto generalmente implica preparar tu conjunto de datos, configurar los parámetros del modelo, entrenar el modelo y luego utilizar el modelo entrenado para realizar la detección de objetos. |
||||
|
||||
Ten en cuenta que los pasos específicos pueden variar según tu caso de uso específico y el estado actual del repositorio YOLOv7. Por lo tanto, se recomienda encarecidamente consultar directamente las instrucciones proporcionadas en el repositorio de GitHub de YOLOv7. |
||||
|
||||
Lamentamos cualquier inconveniente que esto pueda causar y nos esforzaremos por actualizar este documento con ejemplos de uso para Ultralytics una vez que se implemente el soporte para YOLOv7. |
||||
|
||||
## Citaciones y Agradecimientos |
||||
|
||||
Nos gustaría agradecer a los autores de YOLOv7 por sus importantes contribuciones en el campo de la detección de objetos en tiempo real: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{wang2022yolov7, |
||||
title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors}, |
||||
author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark}, |
||||
journal={arXiv preprint arXiv:2207.02696}, |
||||
year={2022} |
||||
} |
||||
``` |
||||
|
||||
El artículo original de YOLOv7 se puede encontrar en [arXiv](https://arxiv.org/pdf/2207.02696.pdf). Los autores han hecho su trabajo públicamente disponible y el código se puede acceder en [GitHub](https://github.com/WongKinYiu/yolov7). Agradecemos sus esfuerzos en el avance del campo y en hacer su trabajo accesible a la comunidad en general. |
||||
@ -1,162 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: ¡Explora las emocionantes características de YOLOv8, la última versión de nuestro detector de objetos en tiempo real! Aprende cómo las arquitecturas avanzadas, los modelos preentrenados y el equilibrio óptimo entre precisión y velocidad hacen de YOLOv8 la elección perfecta para tus tareas de detección de objetos. |
||||
keywords: YOLOv8, Ultralytics, detector de objetos en tiempo real, modelos preentrenados, documentación, detección de objetos, serie YOLO, arquitecturas avanzadas, precisión, velocidad |
||||
--- |
||||
|
||||
# YOLOv8 |
||||
|
||||
## Descripción general |
||||
|
||||
YOLOv8 es la última versión de la serie YOLO de detectores de objetos en tiempo real, ofreciendo un rendimiento de vanguardia en términos de precisión y velocidad. Basándose en los avances de las versiones anteriores de YOLO, YOLOv8 presenta nuevas características y optimizaciones que lo convierten en una opción ideal para diversas tareas de detección de objetos en una amplia gama de aplicaciones. |
||||
|
||||
 |
||||
|
||||
## Características principales |
||||
|
||||
- **Arquitecturas avanzadas de columna vertebral y cuello:** YOLOv8 utiliza arquitecturas de columna vertebral y cuello de última generación, lo que resulta en una mejor extracción de características y rendimiento de detección de objetos. |
||||
- **Cabeza Ultralytics dividida sin anclaje:** YOLOv8 adopta una cabeza Ultralytics dividida sin anclaje, lo que contribuye a una mejor precisión y a un proceso de detección más eficiente en comparación con los enfoques basados en anclaje. |
||||
- **Equilibrio optimizado entre precisión y velocidad:** Con un enfoque en mantener un equilibrio óptimo entre precisión y velocidad, YOLOv8 es adecuado para tareas de detección de objetos en tiempo real en diversas áreas de aplicación. |
||||
- **Variedad de modelos preentrenados:** YOLOv8 ofrece una variedad de modelos preentrenados para adaptarse a diversas tareas y requisitos de rendimiento, lo que facilita encontrar el modelo adecuado para tu caso de uso específico. |
||||
|
||||
## Tareas y modos compatibles |
||||
|
||||
La serie YOLOv8 ofrece una amplia gama de modelos, cada uno especializado en tareas específicas en visión por computadora. Estos modelos están diseñados para adaptarse a diversos requisitos, desde la detección de objetos hasta tareas más complejas como la segmentación de instancias, la detección de poses/puntos clave y la clasificación. |
||||
|
||||
Cada variante de la serie YOLOv8 está optimizada para su respectiva tarea, garantizando un alto rendimiento y precisión. Además, estos modelos son compatibles con varios modos operativos, incluyendo [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) y [Export](../modes/export.md), lo que facilita su uso en diferentes etapas de implementación y desarrollo. |
||||
|
||||
| Modelo | Nombres de archivo | Tarea | Inferencia | Validación | Entrenamiento | Exportación | |
||||
|-------------|----------------------------------------------------------------------------------------------------------------|---------------------------------------------------|------------|------------|---------------|-------------| |
||||
| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Detección](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Segmentación de instancias](../tasks/segment.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [Pose/Puntos clave](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Clasificación](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Esta tabla proporciona una descripción general de las variantes de modelos YOLOv8, resaltando su aplicabilidad en tareas específicas y su compatibilidad con varios modos operativos como Inferencia, Validación, Entrenamiento y Exportación. Muestra la versatilidad y robustez de la serie YOLOv8, haciéndolos adecuados para una variedad de aplicaciones en visión por computadora. |
||||
|
||||
## Métricas de rendimiento |
||||
|
||||
!!! Rendimiento |
||||
|
||||
=== "Detección (COCO)" |
||||
|
||||
Consulta la [documentación de Detección](https://docs.ultralytics.com/tasks/detect/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/detect/coco/), que incluyen 80 clases preentrenadas. |
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | mAP<sup>val<br>50-95 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| ------------------------------------------------------------------------------------ | ----------------------- | --------------------- | ------------------------------ | --------------------------------------- | ---------------------- | ----------------- | |
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | |
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | |
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | |
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | |
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | |
||||
|
||||
=== "Detección (Open Images V7)" |
||||
|
||||
Consulta la [documentación de Detección](https://docs.ultralytics.com/tasks/detect/) para ejemplos de uso con estos modelos entrenados en [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), que incluyen 600 clases preentrenadas. |
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | mAP<sup>val<br>50-95 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| ----------------------------------------------------------------------------------------- | ----------------------- | --------------------- | -------------------------------- | --------------------------------------- | ---------------------- | ----------------- | |
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 | |
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 | |
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 | |
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 | |
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 | |
||||
|
||||
=== "Segmentación (COCO)" |
||||
|
||||
Consulta la [documentación de Segmentación](https://docs.ultralytics.com/tasks/segment/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/segment/coco/), que incluyen 80 clases preentrenadas. |
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | mAP<sup>caja<br>50-95 | mAP<sup>máscara<br>50-95 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| -------------------------------------------------------------------------------------------- | ----------------------- | ---------------------- | ----------------------- | -------------------------------- | --------------------------------------- | ---------------------- | ----------------- | |
||||
| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | |
||||
|
||||
=== "Clasificación (ImageNet)" |
||||
|
||||
Consulta la [documentación de Clasificación](https://docs.ultralytics.com/tasks/classify/) para ejemplos de uso con estos modelos entrenados en [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), que incluyen 1000 clases preentrenadas. |
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | acc<br><sup>top1 | acc<br><sup>top5 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) a 640 | |
||||
| -------------------------------------------------------------------------------------------- | ----------------------- | ---------------- | ---------------- | -------------------------------- | --------------------------------------- | ---------------------- | ------------------------ | |
||||
| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | |
||||
|
||||
=== "Pose (COCO)" |
||||
|
||||
Consulta la [documentación de Estimación de Poses](https://docs.ultralytics.com/tasks/segment/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/pose/coco/), que incluyen 1 clase preentrenada, 'person'. |
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| ---------------------------------------------------------------------------------------------------- | ----------------------- | --------------------- | ------------------ | -------------------------------- | --------------------------------------- | ---------------------- | ----------------- | |
||||
| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 | |
||||
|
||||
## Ejemplos de uso |
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia con YOLOv8. Para obtener documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md). |
||||
|
||||
Ten en cuenta que el siguiente ejemplo es para modelos de detección YOLOv8. Para ver las tareas adicionales compatibles, consulta la documentación de [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) y [Pose](../tasks/pose.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
Los modelos preentrenados en PyTorch `*.pt`, así como los archivos de configuración `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia del modelo en Python: |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Carga un modelo YOLOv8n preentrenado en COCO |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Muestra información del modelo (opcional) |
||||
model.info() |
||||
|
||||
# Entrena el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Realiza inferencia con el modelo YOLOv8n en la imagen 'bus.jpg' |
||||
results = model('ruta/a/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Hay comandos de CLI disponibles para ejecutar directamente los modelos: |
||||
|
||||
```bash |
||||
# Carga un modelo YOLOv8n preentrenado en COCO y entrénalo en el conjunto de datos de ejemplo COCO8 durante 100 épocas |
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Carga un modelo YOLOv8n preentrenado en COCO y realiza inferencia en la imagen 'bus.jpg' |
||||
yolo predict model=yolov8n.pt source=ruta/a/bus.jpg |
||||
``` |
||||
|
||||
## Citas y reconocimientos |
||||
|
||||
Si utilizas el modelo YOLOv8 u otro software de este repositorio en tu trabajo, por favor cítalo utilizando el siguiente formato: |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@software{yolov8_ultralytics, |
||||
author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu}, |
||||
title = {Ultralytics YOLOv8}, |
||||
version = {8.0.0}, |
||||
year = {2023}, |
||||
url = {https://github.com/ultralytics/ultralytics}, |
||||
orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069}, |
||||
license = {AGPL-3.0} |
||||
} |
||||
``` |
||||
|
||||
Ten en cuenta que el DOI está pendiente y se agregará a la cita una vez que esté disponible. Los modelos de YOLOv8 se proporcionan bajo las licencias [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) y [Enterprise](https://ultralytics.com/license). |
||||
@ -1,94 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Aprenda cómo perfilar la velocidad y exactitud de YOLOv8 en varios formatos de exportación; obtenga perspectivas sobre las métricas mAP50-95, accuracy_top5 y más. |
||||
keywords: Ultralytics, YOLOv8, benchmarking, perfilado de velocidad, perfilado de exactitud, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formatos de exportación YOLO |
||||
--- |
||||
|
||||
# Model Benchmarking con Ultralytics YOLO |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema e integraciones de Ultralytics YOLO"> |
||||
|
||||
## Introducción |
||||
|
||||
Una vez que su modelo está entrenado y validado, el siguiente paso lógico es evaluar su rendimiento en varios escenarios del mundo real. El modo benchmark en Ultralytics YOLOv8 cumple con este propósito proporcionando un marco sólido para valorar la velocidad y exactitud de su modelo a través de una gama de formatos de exportación. |
||||
|
||||
## ¿Por Qué Es Crucial el Benchmarking? |
||||
|
||||
- **Decisiones Informadas:** Obtenga perspectivas sobre el equilibrio entre velocidad y precisión. |
||||
- **Asignación de Recursos:** Entienda cómo diferentes formatos de exportación se desempeñan en diferentes hardware. |
||||
- **Optimización:** Aprenda cuál formato de exportación ofrece el mejor rendimiento para su caso de uso específico. |
||||
- **Eficiencia de Costo:** Haga un uso más eficiente de los recursos de hardware basado en los resultados del benchmark. |
||||
|
||||
### Métricas Clave en el Modo Benchmark |
||||
|
||||
- **mAP50-95:** Para detección de objetos, segmentación y estimación de pose. |
||||
- **accuracy_top5:** Para clasificación de imágenes. |
||||
- **Tiempo de Inferencia:** Tiempo tomado para cada imagen en milisegundos. |
||||
|
||||
### Formatos de Exportación Soportados |
||||
|
||||
- **ONNX:** Para un rendimiento óptimo de CPU |
||||
- **TensorRT:** Para la máxima eficiencia de GPU |
||||
- **OpenVINO:** Para la optimización en hardware de Intel |
||||
- **CoreML, TensorFlow SavedModel y Más:** Para necesidades de despliegue diversas. |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
* Exporte a ONNX o OpenVINO para acelerar la velocidad de CPU hasta 3 veces. |
||||
* Exporte a TensorRT para acelerar la velocidad de GPU hasta 5 veces. |
||||
|
||||
## Ejemplos de Uso |
||||
|
||||
Ejecute benchmarks de YOLOv8n en todos los formatos de exportación soportados incluyendo ONNX, TensorRT, etc. Vea la sección de Argumentos a continuación para una lista completa de argumentos de exportación. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics.utils.benchmarks import benchmark |
||||
|
||||
# Benchmark en 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 |
||||
``` |
||||
|
||||
## Argumentos |
||||
|
||||
Argumentos como `model`, `data`, `imgsz`, `half`, `device`, y `verbose` proporcionan a los usuarios la flexibilidad de ajustar los benchmarks a sus necesidades específicas y comparar el rendimiento de diferentes formatos de exportación con facilidad. |
||||
|
||||
| Clave | Valor | Descripción | |
||||
|-----------|---------|----------------------------------------------------------------------------------------------------------| |
||||
| `model` | `None` | ruta al archivo del modelo, es decir, yolov8n.pt, yolov8n.yaml | |
||||
| `data` | `None` | ruta a YAML que referencia el conjunto de datos de benchmarking (bajo la etiqueta `val`) | |
||||
| `imgsz` | `640` | tamaño de imagen como escalar o lista (h, w), es decir, (640, 480) | |
||||
| `half` | `False` | cuantificación FP16 | |
||||
| `int8` | `False` | cuantificación INT8 | |
||||
| `device` | `None` | dispositivo en el que se ejecutará, es decir, dispositivo cuda=0 o dispositivo=0,1,2,3 o dispositivo=cpu | |
||||
| `verbose` | `False` | no continuar en caso de error (bool), o umbral de piso de valor (float) | |
||||
|
||||
## Formatos de Exportación |
||||
|
||||
Los benchmarks intentarán ejecutarse automáticamente en todos los posibles formatos de exportación a continuación. |
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | |
||||
|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------| |
||||
| [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` | |
||||
|
||||
Vea los detalles completos de `export` en la página [Export](https://docs.ultralytics.com/modes/export/). |
||||
@ -1,108 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Guía paso a paso sobre cómo exportar sus modelos YOLOv8 a varios formatos como ONNX, TensorRT, CoreML y más para su despliegue. ¡Explora ahora!. |
||||
keywords: YOLO, YOLOv8, Ultralytics, Exportación de modelos, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exportar modelo |
||||
--- |
||||
|
||||
# Exportación de Modelos con Ultralytics YOLO |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema de Ultralytics YOLO e integraciones"> |
||||
|
||||
## Introducción |
||||
|
||||
El objetivo final de entrenar un modelo es desplegarlo para aplicaciones en el mundo real. El modo exportación en Ultralytics YOLOv8 ofrece una gama versátil de opciones para exportar tu modelo entrenado a diferentes formatos, haciéndolo desplegable en varias plataformas y dispositivos. Esta guía integral pretende guiarte a través de los matices de la exportación de modelos, mostrando cómo lograr la máxima compatibilidad y rendimiento. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/WbomGeoOT_k?si=aGmuyooWftA0ue9X" |
||||
title="Reproductor de vídeo de YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Ver:</strong> Cómo Exportar un Modelo Entrenado Personalizado de Ultralytics YOLOv8 y Ejecutar Inferencia en Vivo en la Webcam. |
||||
</p> |
||||
|
||||
## ¿Por Qué Elegir el Modo Exportación de YOLOv8? |
||||
|
||||
- **Versatilidad:** Exporta a múltiples formatos incluyendo ONNX, TensorRT, CoreML y más. |
||||
- **Rendimiento:** Acelera hasta 5 veces la velocidad en GPU con TensorRT y 3 veces en CPU con ONNX o OpenVINO. |
||||
- **Compatibilidad:** Hacer que tu modelo sea universalmente desplegable en numerosos entornos de hardware y software. |
||||
- **Facilidad de Uso:** Interfaz de línea de comandos simple y API de Python para una exportación de modelos rápida y sencilla. |
||||
|
||||
### Características Clave del Modo de Exportación |
||||
|
||||
Aquí tienes algunas de las funcionalidades destacadas: |
||||
|
||||
- **Exportación con Un Solo Clic:** Comandos simples para exportar a diferentes formatos. |
||||
- **Exportación por Lotes:** Exporta modelos capaces de inferencia por lotes. |
||||
- **Inferencia Optimizada:** Los modelos exportados están optimizados para tiempos de inferencia más rápidos. |
||||
- **Vídeos Tutoriales:** Guías y tutoriales en profundidad para una experiencia de exportación fluida. |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
* Exporta a ONNX u OpenVINO para acelerar la CPU hasta 3 veces. |
||||
* Exporta a TensorRT para acelerar la GPU hasta 5 veces. |
||||
|
||||
## Ejemplos de Uso |
||||
|
||||
Exporta un modelo YOLOv8n a un formato diferente como ONNX o TensorRT. Consulta la sección Argumentos más abajo para una lista completa de argumentos de exportación. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Carga un modelo |
||||
model = YOLO('yolov8n.pt') # carga un modelo oficial |
||||
model = YOLO('path/to/best.pt') # carga un modelo entrenado personalizado |
||||
|
||||
# Exporta el modelo |
||||
model.export(format='onnx') |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo export model=yolov8n.pt format=onnx # exporta modelo oficial |
||||
yolo export model=path/to/best.pt format=onnx # exporta modelo entrenado personalizado |
||||
``` |
||||
|
||||
## Argumentos |
||||
|
||||
Los ajustes de exportación para modelos YOLO se refieren a las diversas configuraciones y opciones utilizadas para guardar o exportar el modelo para su uso en otros entornos o plataformas. Estos ajustes pueden afectar el rendimiento del modelo, su tamaño y su compatibilidad con diferentes sistemas. Algunos ajustes comunes de exportación de YOLO incluyen el formato del archivo del modelo exportado (p. ej., ONNX, TensorFlow SavedModel), el dispositivo en el que se ejecutará el modelo (p. ej., CPU, GPU) y la presencia de características adicionales como máscaras o múltiples etiquetas por caja. Otros factores que pueden afectar el proceso de exportación incluyen la tarea específica para la que se está utilizando el modelo y los requisitos o limitaciones del entorno o plataforma objetivo. Es importante considerar y configurar cuidadosamente estos ajustes para asegurar que el modelo exportado está optimizado para el caso de uso previsto y se pueda utilizar eficazmente en el entorno objetivo. |
||||
|
||||
| Llave | Valor | Descripción | |
||||
|-------------|-----------------|-----------------------------------------------------------------| |
||||
| `format` | `'torchscript'` | formato al que exportar | |
||||
| `imgsz` | `640` | tamaño de imagen como escalar o lista (h, w), p. ej. (640, 480) | |
||||
| `keras` | `False` | usu Keras para la exportación de TF SavedModel | |
||||
| `optimize` | `False` | TorchScript: optimizar para móvil | |
||||
| `half` | `False` | cuantificación FP16 | |
||||
| `int8` | `False` | cuantificación INT8 | |
||||
| `dynamic` | `False` | ONNX/TensorRT: ejes dinámicos | |
||||
| `simplify` | `False` | ONNX/TensorRT: simplificar modelo | |
||||
| `opset` | `None` | ONNX: versión de opset (opcional, por defecto la más reciente) | |
||||
| `workspace` | `4` | TensorRT: tamaño del espacio de trabajo (GB) | |
||||
| `nms` | `False` | CoreML: añadir NMS | |
||||
|
||||
## Formatos de Exportación |
||||
|
||||
Los formatos de exportación disponibles de YOLOv8 están en la tabla a continuación. Puedes exportar a cualquier formato usando el argumento `format`, por ejemplo, `format='onnx'` o `format='engine'`. |
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | |
||||
|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------| |
||||
| [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` | |
||||
@ -1,73 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Desde el entrenamiento hasta el seguimiento, aprovecha al máximo YOLOv8 con Ultralytics. Obtén información y ejemplos para cada modo compatible incluyendo validación, exportación y evaluación comparativa. |
||||
keywords: Ultralytics, YOLOv8, Aprendizaje Automático, Detección de Objetos, Entrenamiento, Validación, Predicción, Exportación, Seguimiento, Benchmarking |
||||
--- |
||||
|
||||
# Modos de Ultralytics YOLOv8 |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema Ultralytics YOLO e integraciones"> |
||||
|
||||
## Introducción |
||||
|
||||
Ultralytics YOLOv8 no es solo otro modelo de detección de objetos; es un marco de trabajo versátil diseñado para cubrir todo el ciclo de vida de los modelos de aprendizaje automático, desde la ingesta de datos y el entrenamiento del modelo hasta la validación, implementación y seguimiento en el mundo real. Cada modo sirve para un propósito específico y está diseñado para ofrecerte la flexibilidad y eficiencia necesarias para diferentes tareas y casos de uso. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/j8uQc0qB91s?si=dhnGKgqvs7nPgeaM" |
||||
title="Reproductor de video de YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Mira:</strong> Tutorial de Modos Ultralytics: Entrenar, Validar, Predecir, Exportar y Hacer Benchmarking. |
||||
</p> |
||||
|
||||
### Modos a Primera Vista |
||||
|
||||
Comprender los diferentes **modos** que soporta Ultralytics YOLOv8 es crítico para sacar el máximo provecho a tus modelos: |
||||
|
||||
- **Modo Entrenar (Train)**: Afina tu modelo en conjuntos de datos personalizados o pre-cargados. |
||||
- **Modo Validar (Val)**: Un punto de control post-entrenamiento para validar el rendimiento del modelo. |
||||
- **Modo Predecir (Predict)**: Libera el poder predictivo de tu modelo en datos del mundo real. |
||||
- **Modo Exportar (Export)**: Prepara tu modelo para la implementación en varios formatos. |
||||
- **Modo Seguir (Track)**: Extiende tu modelo de detección de objetos a aplicaciones de seguimiento en tiempo real. |
||||
- **Modo Benchmark (Benchmark)**: Analiza la velocidad y precisión de tu modelo en diversos entornos de implementación. |
||||
|
||||
Esta guía completa tiene como objetivo proporcionarte una visión general y conocimientos prácticos de cada modo, ayudándote a aprovechar todo el potencial de YOLOv8. |
||||
|
||||
## [Entrenar (Train)](train.md) |
||||
|
||||
El modo Entrenar se utiliza para entrenar un modelo YOLOv8 en un conjunto de datos personalizado. En este modo, el modelo se entrena utilizando el conjunto de datos y los hiperparámetros especificados. El proceso de entrenamiento implica optimizar los parámetros del modelo para que pueda predecir con precisión las clases y ubicaciones de los objetos en una imagen. |
||||
|
||||
[Ejemplos de Entrenamiento](train.md){ .md-button } |
||||
|
||||
## [Validar (Val)](val.md) |
||||
|
||||
El modo Validar se usa para validar un modelo YOLOv8 después de haber sido entrenado. En este modo, el modelo se evalúa en un conjunto de validación para medir su precisión y rendimiento de generalización. Este modo se puede usar para ajustar los hiperparámetros del modelo y mejorar su rendimiento. |
||||
|
||||
[Ejemplos de Validación](val.md){ .md-button } |
||||
|
||||
## [Predecir (Predict)](predict.md) |
||||
|
||||
El modo Predecir se utiliza para realizar predicciones usando un modelo YOLOv8 entrenado en imágenes o videos nuevos. En este modo, el modelo se carga desde un archivo de punto de control, y el usuario puede proporcionar imágenes o videos para realizar inferencias. El modelo predice las clases y ubicaciones de los objetos en las imágenes o videos de entrada. |
||||
|
||||
[Ejemplos de Predicción](predict.md){ .md-button } |
||||
|
||||
## [Exportar (Export)](export.md) |
||||
|
||||
El modo Exportar se utiliza para exportar un modelo YOLOv8 a un formato que se pueda usar para la implementación. En este modo, el modelo se convierte a un formato que puede ser utilizado por otras aplicaciones de software o dispositivos de hardware. Este modo es útil al implementar el modelo en entornos de producción. |
||||
|
||||
[Ejemplos de Exportación](export.md){ .md-button } |
||||
|
||||
## [Seguir (Track)](track.md) |
||||
|
||||
El modo Seguir se usa para rastrear objetos en tiempo real utilizando un modelo YOLOv8. En este modo, el modelo se carga desde un archivo de punto de control, y el usuario puede proporcionar un flujo de video en vivo para realizar seguimiento de objetos en tiempo real. Este modo es útil para aplicaciones como sistemas de vigilancia o coches autónomos. |
||||
|
||||
[Ejemplos de Seguimiento](track.md){ .md-button } |
||||
|
||||
## [Benchmark (Benchmark)](benchmark.md) |
||||
|
||||
El modo Benchmark se utiliza para perfilar la velocidad y precisión de varios formatos de exportación de YOLOv8. Los benchmarks proporcionan información sobre el tamaño del formato de exportación, sus métricas de `mAP50-95` (para detección de objetos, segmentación y pose) o métricas de `accuracy_top5` (para clasificación), y el tiempo de inferencia en milisegundos por imagen a través de varios formatos de exportación como ONNX, OpenVINO, TensorRT y otros. Esta información puede ayudar a los usuarios a elegir el formato de exportación óptimo para su caso de uso específico, basado en sus requerimientos de velocidad y precisión. |
||||
|
||||
[Ejemplos de Benchmarking](benchmark.md){ .md-button } |
||||
@ -1,227 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Descubra cómo utilizar el modo predictivo de YOLOv8 para diversas tareas. Aprenda acerca de diferentes fuentes de inferencia como imágenes, videos y formatos de datos. |
||||
keywords: Ultralytics, YOLOv8, modo predictivo, fuentes de inferencia, tareas de predicción, modo de transmisión, procesamiento de imágenes, procesamiento de videos, aprendizaje automático, IA |
||||
--- |
||||
|
||||
# Predicción del Modelo con YOLO de Ultralytics |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema de YOLO de Ultralytics e integraciones"> |
||||
|
||||
## Introducción |
||||
|
||||
En el mundo del aprendizaje automático y la visión por computadora, el proceso de dar sentido a los datos visuales se denomina 'inferencia' o 'predicción'. YOLOv8 de Ultralytics ofrece una característica poderosa conocida como **modo predictivo** que está diseñada para inferencias de alto rendimiento y en tiempo real en una amplia gama de fuentes de datos. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/QtsI0TnwDZs?si=ljesw75cMO2Eas14" |
||||
title="Reproductor de video de YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Ver:</strong> Cómo Extraer las Salidas del Modelo YOLOv8 de Ultralytics para Proyectos Personalizados. |
||||
</p> |
||||
|
||||
## Aplicaciones en el Mundo Real |
||||
|
||||
| Manufactura | Deportes | Seguridad | |
||||
|:-----------------------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------------------:|:-------------------------------------------------------------------------------------------------------------------------------------:| |
||||
|  |  |  | |
||||
| Detección de Repuestos de Vehículos | Detección de Jugadores de Fútbol | Detección de Caídas de Personas | |
||||
|
||||
## ¿Por Qué Utilizar YOLO de Ultralytics para la Inferencia? |
||||
|
||||
Estas son algunas razones para considerar el modo predictivo de YOLOv8 para sus necesidades de inferencia: |
||||
|
||||
- **Versatilidad:** Capaz de realizar inferencias en imágenes, videos e incluso transmisiones en vivo. |
||||
- **Rendimiento:** Diseñado para procesamiento en tiempo real y de alta velocidad sin sacrificar precisión. |
||||
- **Facilidad de Uso:** Interfaces de Python y CLI intuitivas para una rápida implementación y pruebas. |
||||
- **Alta Personalización:** Diversos ajustes y parámetros para afinar el comportamiento de inferencia del modelo según sus requisitos específicos. |
||||
|
||||
### Características Principales del Modo Predictivo |
||||
|
||||
El modo predictivo de YOLOv8 está diseñado para ser robusto y versátil, y cuenta con: |
||||
|
||||
- **Compatibilidad con Múltiples Fuentes de Datos:** Ya sea que sus datos estén en forma de imágenes individuales, una colección de imágenes, archivos de video o transmisiones de video en tiempo real, el modo predictivo le tiene cubierto. |
||||
- **Modo de Transmisión:** Utilice la función de transmisión para generar un generador eficiente de memoria de objetos `Results`. Active esto configurando `stream=True` en el método de llamada del predictor. |
||||
- **Procesamiento por Lotes:** La capacidad de procesar múltiples imágenes o fotogramas de video en un solo lote, acelerando aún más el tiempo de inferencia. |
||||
- **Amigable para la Integración:** Se integra fácilmente con pipelines de datos existentes y otros componentes de software, gracias a su API flexible. |
||||
|
||||
Los modelos YOLO de Ultralytics devuelven ya sea una lista de objetos `Results` de Python, o un generador de objetos `Results` de Python eficiente en memoria cuando se pasa `stream=True` al modelo durante la inferencia: |
||||
|
||||
!!! Example "Predict" |
||||
|
||||
=== "Devolver una lista con `stream=False`" |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.pt') # modelo YOLOv8n preentrenado |
||||
|
||||
# Ejecutar inferencia por lotes en una lista de imágenes |
||||
results = model(['im1.jpg', 'im2.jpg']) # devuelve una lista de objetos Results |
||||
|
||||
# Procesar lista de resultados |
||||
for result in results: |
||||
boxes = result.boxes # Objeto Boxes para salidas de bbox |
||||
masks = result.masks # Objeto Masks para salidas de máscaras de segmentación |
||||
keypoints = result.keypoints # Objeto Keypoints para salidas de postura |
||||
probs = result.probs # Objeto Probs para salidas de clasificación |
||||
``` |
||||
|
||||
=== "Devolver un generador con `stream=True`" |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.pt') # modelo YOLOv8n preentrenado |
||||
|
||||
# Ejecutar inferencia por lotes en una lista de imágenes |
||||
results = model(['im1.jpg', 'im2.jpg'], stream=True) # devuelve un generador de objetos Results |
||||
|
||||
# Procesar generador de resultados |
||||
for result in results: |
||||
boxes = result.boxes # Objeto Boxes para salidas de bbox |
||||
.masks = result.masks # Objeto Masks para salidas de máscaras de segmentación |
||||
keypoints = result.keypoints # Objeto Keypoints para salidas de postura |
||||
probs = result.probs # Objeto Probs para salidas de clasificación |
||||
``` |
||||
|
||||
## Fuentes de Inferencia |
||||
|
||||
YOLOv8 puede procesar diferentes tipos de fuentes de entrada para la inferencia, como se muestra en la tabla a continuación. Las fuentes incluyen imágenes estáticas, transmisiones de video y varios formatos de datos. La tabla también indica si cada fuente se puede utilizar en modo de transmisión con el argumento `stream=True` ✅. El modo de transmisión es beneficioso para procesar videos o transmisiones en vivo ya que crea un generador de resultados en lugar de cargar todos los fotogramas en la memoria. |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
Utilice `stream=True` para procesar videos largos o conjuntos de datos grandes para gestionar eficientemente la memoria. Cuando `stream=False`, los resultados de todos los fotogramas o puntos de datos se almacenan en la memoria, lo que puede aumentar rápidamente y causar errores de memoria insuficiente para entradas grandes. En contraste, `stream=True` utiliza un generador, que solo mantiene los resultados del fotograma o punto de datos actual en la memoria, reduciendo significativamente el consumo de memoria y previniendo problemas de falta de memoria. |
||||
|
||||
| Fuente | Argumento | Tipo | Notas | |
||||
|---------------------|--------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------| |
||||
| imagen | `'image.jpg'` | `str` o `Path` | Archivo único de imagen. | |
||||
| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL a una imagen. | |
||||
| captura de pantalla | `'screen'` | `str` | Captura una captura de pantalla. | |
||||
| PIL | `Image.open('im.jpg')` | `PIL.Image` | Formato HWC con canales RGB. | |
||||
| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Formato HWC con canales BGR `uint8 (0-255)`. | |
||||
| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Formato HWC con canales BGR `uint8 (0-255)`. | |
||||
| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Formato BCHW con canales RGB `float32 (0.0-1.0)`. | |
||||
| CSV | `'sources.csv'` | `str` o `Path` | Archivo CSV que contiene rutas a imágenes, videos o directorios. | |
||||
| video ✅ | `'video.mp4'` | `str` o `Path` | Archivo de video en formatos como MP4, AVI, etc. | |
||||
| directorio ✅ | `'path/'` | `str` o `Path` | Ruta a un directorio que contiene imágenes o videos. | |
||||
| glob ✅ | `'path/*.jpg'` | `str` | Patrón glob para coincidir con múltiples archivos. Utilice el carácter `*` como comodín. | |
||||
| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL a un video de YouTube. | |
||||
| transmisión ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL para protocolos de transmisión como RTSP, RTMP, TCP o una dirección IP. | |
||||
| multi-transmisión ✅ | `'list.streams'` | `str` o `Path` | Archivo de texto `*.streams` con una URL de transmisión por fila, es decir, 8 transmisiones se ejecutarán con tamaño de lote 8. | |
||||
|
||||
A continuación se muestran ejemplos de código para usar cada tipo de fuente: |
||||
|
||||
!!! Example "Fuentes de predicción" |
||||
|
||||
=== "imagen" |
||||
Ejecute inferencia en un archivo de imagen. |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar el modelo YOLOv8n preentrenado |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Definir la ruta al archivo de imagen |
||||
source = 'ruta/a/imagen.jpg' |
||||
|
||||
# Ejecutar inferencia en la fuente |
||||
results = model(source) # lista de objetos Results |
||||
``` |
||||
|
||||
=== "captura de pantalla" |
||||
Ejecute inferencia en el contenido actual de la pantalla como captura de pantalla. |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar el modelo YOLOv8n preentrenado |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Definir captura de pantalla actual como fuente |
||||
source = 'screen' |
||||
|
||||
# Ejecutar inferencia en la fuente |
||||
results = model(source) # lista de objetos Results |
||||
``` |
||||
|
||||
=== "URL" |
||||
Ejecute inferencia en una imagen o video alojados remotamente a través de URL. |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar el modelo YOLOv8n preentrenado |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Definir URL remota de imagen o video |
||||
source = 'https://ultralytics.com/images/bus.jpg' |
||||
|
||||
# Ejecutar inferencia en la fuente |
||||
results = model(source) # lista de objetos Results |
||||
``` |
||||
|
||||
=== "PIL" |
||||
Ejecute inferencia en una imagen abierta con la Biblioteca de Imágenes de Python (PIL). |
||||
```python |
||||
from PIL import Image |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar el modelo YOLOv8n preentrenado |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Abrir una imagen usando PIL |
||||
source = Image.open('ruta/a/imagen.jpg') |
||||
|
||||
# Ejecutar inferencia en la fuente |
||||
results = model(source) # lista de objetos Results |
||||
``` |
||||
|
||||
=== "OpenCV" |
||||
Ejecute inferencia en una imagen leída con OpenCV. |
||||
```python |
||||
import cv2 |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar el modelo YOLOv8n preentrenado |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Leer una imagen usando OpenCV |
||||
source = cv2.imread('ruta/a/imagen.jpg') |
||||
|
||||
# Ejecutar inferencia en la fuente |
||||
results = model(source) # lista de objetos Results |
||||
``` |
||||
|
||||
=== "numpy" |
||||
Ejecute inferencia en una imagen representada como un array de numpy. |
||||
```python |
||||
import numpy as np |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar el modelo YOLOv8n preentrenado |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Crear un array aleatorio de numpy con forma HWC (640, 640, 3) con valores en rango [0, 255] y tipo uint8 |
||||
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') |
||||
|
||||
# Ejecutar inferencia en la fuente |
||||
results = model(source) # lista de objetos Results |
||||
``` |
||||
|
||||
=== "torch" |
||||
Ejecute inferencia en una imagen representada como un tensor de PyTorch. |
||||
```python |
||||
import torch |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar el modelo YOLOv8n preentrenado |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Crear un tensor aleatorio de torch con forma BCHW (1, 3, 640, 640) con valores en rango [0, 1] y tipo float32 |
||||
source = torch.rand(1, 3, 640, 640, dtype=torch.float32) |
||||
|
||||
# Ejecutar inferencia en la fuente |
||||
results = model(source) # lista de objetos Results |
||||
``` |
||||
@ -1,206 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Guía paso a paso para entrenar modelos YOLOv8 con Ultralytics YOLO incluyendo ejemplos de entrenamiento con una sola GPU y múltiples GPUs |
||||
keywords: Ultralytics, YOLOv8, YOLO, detección de objetos, modo de entrenamiento, conjunto de datos personalizado, entrenamiento GPU, multi-GPU, hiperparámetros, ejemplos CLI, ejemplos Python |
||||
--- |
||||
|
||||
# Entrenamiento de Modelos con Ultralytics YOLO |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema e integraciones de Ultralytics YOLO"> |
||||
|
||||
## Introducción |
||||
|
||||
Entrenar un modelo de aprendizaje profundo implica alimentarlo con datos y ajustar sus parámetros para que pueda hacer predicciones precisas. El modo de entrenamiento en Ultralytics YOLOv8 está diseñado para un entrenamiento efectivo y eficiente de modelos de detección de objetos, aprovechando al máximo las capacidades del hardware moderno. Esta guía tiene como objetivo cubrir todos los detalles que necesita para comenzar a entrenar sus propios modelos utilizando el robusto conjunto de características de YOLOv8. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs" |
||||
title="Reproductor de video de YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Ver:</strong> Cómo Entrenar un modelo YOLOv8 en Tu Conjunto de Datos Personalizado en Google Colab. |
||||
</p> |
||||
|
||||
## ¿Por Qué Elegir Ultralytics YOLO para Entrenamiento? |
||||
|
||||
Aquí hay algunas razones convincentes para optar por el modo Entrenamiento de YOLOv8: |
||||
|
||||
- **Eficiencia:** Aprovecha al máximo tu hardware, ya sea en una configuración de una sola GPU o escalando entre múltiples GPUs. |
||||
- **Versatilidad:** Entrena con conjuntos de datos personalizados además de los ya disponibles como COCO, VOC e ImageNet. |
||||
- **Amigable al Usuario:** Interfaces CLI y Python simples pero potentes para una experiencia de entrenamiento sencilla. |
||||
- **Flexibilidad de Hiperparámetros:** Una amplia gama de hiperparámetros personalizables para ajustar el rendimiento del modelo. |
||||
|
||||
### Características Clave del Modo Entrenamiento |
||||
|
||||
Las siguientes son algunas características notables del modo Entrenamiento de YOLOv8: |
||||
|
||||
- **Descarga Automática de Conjuntos de Datos:** Conjuntos de datos estándar como COCO, VOC e ImageNet se descargan automáticamente en el primer uso. |
||||
- **Soporte Multi-GPU:** Escala tus esfuerzos de entrenamiento sin problemas en múltiples GPUs para acelerar el proceso. |
||||
- **Configuración de Hiperparámetros:** La opción de modificar hiperparámetros a través de archivos de configuración YAML o argumentos CLI. |
||||
- **Visualización y Monitoreo:** Seguimiento en tiempo real de métricas de entrenamiento y visualización del proceso de aprendizaje para una mejor comprensión. |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
* Los conjuntos de datos de YOLOv8 como COCO, VOC, ImageNet y muchos otros se descargan automáticamente en el primer uso, es decir, `yolo train data=coco.yaml` |
||||
|
||||
## Ejemplos de Uso |
||||
|
||||
Entrena YOLOv8n en el conjunto de datos COCO128 durante 100 épocas con un tamaño de imagen de 640. El dispositivo de entrenamiento se puede especificar usando el argumento `device`. Si no se pasa ningún argumento, se usará la GPU `device=0` si está disponible; de lo contrario, se usará `device=cpu`. Consulta la sección de Argumentos a continuación para una lista completa de argumentos de entrenamiento. |
||||
|
||||
!!! Example "Ejemplo de Entrenamiento con una sola GPU y CPU" |
||||
|
||||
El dispositivo se determina automáticamente. Si hay una GPU disponible, se usará; de lo contrario, el entrenamiento comenzará en la CPU. |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.yaml') # construir un modelo nuevo desde YAML |
||||
model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) |
||||
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construir desde YAML y transferir pesos |
||||
|
||||
# Entrenar el modelo |
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640) |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Construir un modelo nuevo desde YAML y comenzar el entrenamiento desde cero |
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 |
||||
|
||||
# Comenzar el entrenamiento desde un modelo preentrenado *.pt |
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 |
||||
|
||||
# Construir un modelo nuevo desde YAML, transferir pesos preentrenados a él y comenzar el entrenamiento |
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 |
||||
``` |
||||
|
||||
### Entrenamiento Multi-GPU |
||||
|
||||
El entrenamiento Multi-GPU permite una utilización más eficiente de los recursos de hardware disponibles, distribuyendo la carga de entrenamiento en varias GPUs. Esta característica está disponible tanto a través de la API de Python como de la interfaz de línea de comandos. Para habilitar el entrenamiento Multi-GPU, especifica los IDs de los dispositivos GPU que deseas usar. |
||||
|
||||
!!! Example "Ejemplo de Entrenamiento Multi-GPU" |
||||
|
||||
Para entrenar con 2 GPUs, dispositivos CUDA 0 y 1, usa los siguientes comandos. Amplía a GPUs adicionales según sea necesario. |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) |
||||
|
||||
# Entrenar el modelo con 2 GPUs |
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1]) |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Comenzar el entrenamiento desde un modelo preentrenado *.pt usando las GPUs 0 y 1 |
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1 |
||||
``` |
||||
|
||||
### Entrenamiento con Apple M1 y M2 MPS |
||||
|
||||
Con el soporte para los chips Apple M1 y M2 integrados en los modelos Ultralytics YOLO, ahora es posible entrenar tus modelos en dispositivos que utilizan el potente marco de Metal Performance Shaders (MPS). El MPS ofrece una forma de alto rendimiento para ejecutar tareas de cálculo y procesamiento de imágenes en el silicio personalizado de Apple. |
||||
|
||||
Para habilitar el entrenamiento en chips Apple M1 y M2, debes especificar 'mps' como tu dispositivo al iniciar el proceso de entrenamiento. A continuación se muestra un ejemplo de cómo podrías hacer esto en Python y a través de la línea de comandos: |
||||
|
||||
!!! Example "Ejemplo de Entrenamiento MPS" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) |
||||
|
||||
# Entrenar el modelo con 2 GPUs |
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Comenzar el entrenamiento desde un modelo preentrenado *.pt usando las GPUs 0 y 1 |
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps |
||||
``` |
||||
|
||||
Al aprovechar el poder computacional de los chips M1/M2, esto permite un procesamiento más eficiente de las tareas de entrenamiento. Para obtener una guía más detallada y opciones de configuración avanzadas, consulta la [documentación de PyTorch MPS](https://pytorch.org/docs/stable/notes/mps.html). |
||||
|
||||
## Registros (Logging) |
||||
|
||||
Al entrenar un modelo YOLOv8, puedes encontrar valioso llevar un registro del rendimiento del modelo con el tiempo. Aquí es donde entra en juego el registro. Ultralytics' YOLO ofrece soporte para tres tipos de registradores: Comet, ClearML y TensorBoard. |
||||
|
||||
Para usar un registrador, selecciónalo en el menú desplegable en el fragmento de código anterior y ejecútalo. El registrador elegido se instalará e inicializará. |
||||
|
||||
### Comet |
||||
|
||||
[Comet](https://www.comet.ml/site/) es una plataforma que permite a los científicos de datos y desarrolladores rastrear, comparar, explicar y optimizar experimentos y modelos. Ofrece funcionalidades como métricas en tiempo real, diferencias de código y seguimiento de hiperparámetros. |
||||
|
||||
Para usar Comet: |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
```python |
||||
# pip install comet_ml |
||||
import comet_ml |
||||
|
||||
comet_ml.init() |
||||
``` |
||||
|
||||
Recuerda iniciar sesión en tu cuenta de Comet en su sitio web y obtener tu clave API. Necesitarás agregar esto a tus variables de entorno o tu script para registrar tus experimentos. |
||||
|
||||
### ClearML |
||||
|
||||
[ClearML](https://www.clear.ml/) es una plataforma de código abierto que automatiza el seguimiento de experimentos y ayuda con la compartición eficiente de recursos. Está diseñado para ayudar a los equipos a gestionar, ejecutar y reproducir su trabajo de ML de manera más eficiente. |
||||
|
||||
Para usar ClearML: |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
```python |
||||
# pip install clearml |
||||
import clearml |
||||
|
||||
clearml.browser_login() |
||||
``` |
||||
|
||||
Después de ejecutar este script, necesitarás iniciar sesión en tu cuenta de ClearML en el navegador y autenticar tu sesión. |
||||
|
||||
### TensorBoard |
||||
|
||||
[TensorBoard](https://www.tensorflow.org/tensorboard) es una herramienta de visualización para TensorFlow. Te permite visualizar tu grafo TensorFlow, trazar métricas cuantitativas sobre la ejecución de tu grafo y mostrar datos adicionales como imágenes que lo atraviesan. |
||||
|
||||
Para usar TensorBoard en [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb): |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "CLI" |
||||
```bash |
||||
load_ext tensorboard |
||||
tensorboard --logdir ultralytics/runs # reemplazar con el directorio 'runs' |
||||
``` |
||||
|
||||
Para usar TensorBoard localmente, ejecuta el siguiente comando y visualiza los resultados en http://localhost:6006/. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "CLI" |
||||
```bash |
||||
tensorboard --logdir ultralytics/runs # reemplazar con el directorio 'runs' |
||||
``` |
||||
|
||||
Esto cargará TensorBoard y lo dirigirá al directorio donde se guardan tus registros de entrenamiento. |
||||
|
||||
Después de configurar tu registrador, puedes proceder con tu entrenamiento de modelo. Todas las métricas de entrenamiento se registrarán automáticamente en la plataforma elegida y podrás acceder a estos registros para monitorear el rendimiento de tu modelo con el tiempo, comparar diferentes modelos e identificar áreas de mejora. |
||||
@ -1,86 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Guía para validar modelos YOLOv8. Aprenda a evaluar el rendimiento de sus modelos YOLO utilizando configuraciones y métricas de validación con ejemplos en Python y CLI. |
||||
keywords: Ultralytics, Documentación YOLO, YOLOv8, validación, evaluación de modelos, hiperparámetros, precisión, métricas, Python, CLI |
||||
--- |
||||
|
||||
# Validación de modelos con Ultralytics YOLO |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema e integraciones de Ultralytics YOLO"> |
||||
|
||||
## Introducción |
||||
|
||||
La validación es un paso crítico en el flujo de trabajo de aprendizaje automático, permitiéndole evaluar la calidad de sus modelos entrenados. El modo Val en Ultralytics YOLOv8 proporciona un robusto conjunto de herramientas y métricas para evaluar el rendimiento de sus modelos de detección de objetos. Esta guía sirve como un recurso completo para comprender cómo utilizar efectivamente el modo Val para asegurar que sus modelos sean precisos y confiables. |
||||
|
||||
## ¿Por qué validar con Ultralytics YOLO? |
||||
|
||||
Estas son las ventajas de usar el modo Val de YOLOv8: |
||||
|
||||
- **Precisión:** Obtenga métricas precisas como mAP50, mAP75 y mAP50-95 para evaluar de manera integral su modelo. |
||||
- **Comodidad:** Utilice funciones integradas que recuerdan los ajustes de entrenamiento, simplificando el proceso de validación. |
||||
- **Flexibilidad:** Valide su modelo con el mismo conjunto de datos o diferentes conjuntos de datos y tamaños de imagen. |
||||
- **Ajuste de Hiperparámetros:** Use las métricas de validación para ajustar su modelo y mejorar el rendimiento. |
||||
|
||||
### Características principales del modo Val |
||||
|
||||
Estas son las funcionalidades notables ofrecidas por el modo Val de YOLOv8: |
||||
|
||||
- **Configuraciones Automatizadas:** Los modelos recuerdan sus configuraciones de entrenamiento para una validación sencilla. |
||||
- **Soporte de Múltiples Métricas:** Evalúe su modelo basado en una gama de métricas de precisión. |
||||
- **CLI y API de Python:** Elija entre la interfaz de línea de comandos o API de Python basada en su preferencia para validación. |
||||
- **Compatibilidad de Datos:** Funciona sin problemas con conjuntos de datos utilizados durante la fase de entrenamiento así como con conjuntos de datos personalizados. |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
* Los modelos YOLOv8 recuerdan automáticamente sus ajustes de entrenamiento, así que puede validar un modelo en el mismo tamaño de imagen y en el conjunto de datos original fácilmente con solo `yolo val model=yolov8n.pt` o `model('yolov8n.pt').val()` |
||||
|
||||
## Ejemplos de Uso |
||||
|
||||
Valide la precisión del modelo YOLOv8n entrenado en el conjunto de datos COCO128. No es necesario pasar ningún argumento ya que el `modelo` retiene sus `datos` de entrenamiento y argumentos como atributos del modelo. Vea la sección de Argumentos a continuación para una lista completa de argumentos de exportación. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.pt') # cargar un modelo oficial |
||||
model = YOLO('ruta/a/best.pt') # cargar un modelo personalizado |
||||
|
||||
# Validar el modelo |
||||
metrics = model.val() # no se necesitan argumentos, el conjunto de datos y ajustes se recuerdan |
||||
metrics.box.map # map50-95 |
||||
metrics.box.map50 # map50 |
||||
metrics.box.map75 # map75 |
||||
metrics.box.maps # una lista que contiene map50-95 de cada categoría |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo detect val model=yolov8n.pt # val model oficial |
||||
yolo detect val model=ruta/a/best.pt # val model personalizado |
||||
``` |
||||
|
||||
## Argumentos |
||||
|
||||
Los ajustes de validación para modelos YOLO se refieren a los diversos hiperparámetros y configuraciones utilizados para evaluar el rendimiento del modelo en un conjunto de datos de validación. Estos ajustes pueden afectar el rendimiento, la velocidad y la precisión del modelo. Algunos ajustes comunes de validación YOLO incluyen el tamaño del lote, la frecuencia con la que se realiza la validación durante el entrenamiento y las métricas utilizadas para evaluar el rendimiento del modelo. Otros factores que pueden afectar el proceso de validación incluyen el tamaño y la composición del conjunto de datos de validación y la tarea específica para la que se utiliza el modelo. Es importante ajustar y experimentar cuidadosamente con estos ajustes para asegurarse de que el modelo esté funcionando bien en el conjunto de datos de validación y para detectar y prevenir el sobreajuste. |
||||
|
||||
| Clave | Valor | Descripción | |
||||
|---------------|---------|---------------------------------------------------------------------------------------------------| |
||||
| `data` | `None` | ruta al archivo de datos, por ejemplo coco128.yaml | |
||||
| `imgsz` | `640` | tamaño de las imágenes de entrada como entero | |
||||
| `batch` | `16` | número de imágenes por lote (-1 para AutoBatch) | |
||||
| `save_json` | `False` | guardar resultados en archivo JSON | |
||||
| `save_hybrid` | `False` | guardar versión híbrida de las etiquetas (etiquetas + predicciones adicionales) | |
||||
| `conf` | `0.001` | umbral de confianza del objeto para detección | |
||||
| `iou` | `0.6` | umbral de Intersección sobre Unión (IoU) para NMS | |
||||
| `max_det` | `300` | número máximo de detecciones por imagen | |
||||
| `half` | `True` | usar precisión de punto flotante de media preción (FP16) | |
||||
| `device` | `None` | dispositivo en el que se ejecuta, por ejemplo dispositivo cuda=0/1/2/3 o dispositivo=cpu | |
||||
| `dnn` | `False` | utilizar OpenCV DNN para inferencia ONNX | |
||||
| `plots` | `False` | mostrar gráficos durante el entrenamiento | |
||||
| `rect` | `False` | val rectangular con cada lote compilado para el mínimo relleno | |
||||
| `split` | `val` | división del conjunto de datos a utilizar para la validación, por ejemplo 'val', 'test' o 'train' | |
||||
| |
||||
@ -1,198 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explore diversos métodos para instalar Ultralytics usando pip, conda, git y Docker. Aprende cómo usar Ultralytics con la interfaz de línea de comandos o dentro de tus proyectos de Python. |
||||
keywords: instalación de Ultralytics, pip install Ultralytics, instalación de Docker Ultralytics, interfaz de línea de comandos de Ultralytics, interfaz de Python de Ultralytics |
||||
--- |
||||
|
||||
## Instalar Ultralytics |
||||
|
||||
Ultralytics ofrece varios métodos de instalación incluyendo pip, conda y Docker. Instala YOLOv8 a través del paquete `ultralytics` de pip para la última versión estable o clonando el [repositorio de GitHub de Ultralytics](https://github.com/ultralytics/ultralytics) para obtener la versión más actualizada. Docker se puede utilizar para ejecutar el paquete en un contenedor aislado, evitando la instalación local. |
||||
|
||||
!!! Example "Instalar" |
||||
|
||||
=== "Instalación con Pip (recomendado)" |
||||
Instala el paquete `ultralytics` usando pip o actualiza una instalación existente ejecutando `pip install -U ultralytics`. Visita el Índice de Paquetes de Python (PyPI) para más detalles sobre el paquete `ultralytics`: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/). |
||||
|
||||
[](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/project/ultralytics) |
||||
|
||||
```bash |
||||
# Instalar el paquete ultralytics desde PyPI |
||||
pip install ultralytics |
||||
``` |
||||
|
||||
También puedes instalar el paquete `ultralytics` directamente del [repositorio](https://github.com/ultralytics/ultralytics) en GitHub. Esto puede ser útil si quieres la última versión de desarrollo. Asegúrate de tener la herramienta de línea de comandos Git instalada en tu sistema. El comando `@main` instala la rama `main` y puede modificarse a otra rama, es decir, `@my-branch`, o eliminarse por completo para volver por defecto a la rama `main`. |
||||
|
||||
```bash |
||||
# Instalar el paquete ultralytics desde GitHub |
||||
pip install git+https://github.com/ultralytics/ultralytics.git@main |
||||
``` |
||||
|
||||
|
||||
=== "Instalación con Conda" |
||||
Conda es un gestor de paquetes alternativo a pip que también puede utilizarse para la instalación. Visita Anaconda para más detalles en [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). El repositorio de paquetes de alimentación de Ultralytics para actualizar el paquete de conda está en [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 |
||||
# Instalar el paquete ultralytics usando conda |
||||
conda install -c conda-forge ultralytics |
||||
``` |
||||
|
||||
!!! Note "Nota" |
||||
|
||||
Si estás instalando en un entorno CUDA, la mejor práctica es instalar `ultralytics`, `pytorch` y `pytorch-cuda` en el mismo comando para permitir que el gestor de paquetes de conda resuelva cualquier conflicto, o en su defecto instalar `pytorch-cuda` al final para permitir que sobrescriba el paquete específico de CPU `pytorch` si es necesario. |
||||
```bash |
||||
# Instalar todos los paquetes juntos usando conda |
||||
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics |
||||
``` |
||||
|
||||
### Imagen Docker de Conda |
||||
|
||||
Las imágenes Docker de Conda de Ultralytics también están disponibles en [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Estas imágenes están basadas en [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) y son una manera simple de comenzar a usar `ultralytics` en un entorno Conda. |
||||
|
||||
```bash |
||||
# Establecer el nombre de la imagen como una variable |
||||
t=ultralytics/ultralytics:latest-conda |
||||
|
||||
# Descargar la última imagen de ultralytics de Docker Hub |
||||
sudo docker pull $t |
||||
|
||||
# Ejecutar la imagen de ultralytics en un contenedor con soporte para GPU |
||||
sudo docker run -it --ipc=host --gpus all $t # todas las GPUs |
||||
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # especificar GPUs |
||||
``` |
||||
|
||||
=== "Clonar con Git" |
||||
Clona el repositorio `ultralytics` si estás interesado en contribuir al desarrollo o deseas experimentar con el código fuente más reciente. Después de clonar, navega al directorio e instala el paquete en modo editable `-e` usando pip. |
||||
```bash |
||||
# Clonar el repositorio ultralytics |
||||
git clone https://github.com/ultralytics/ultralytics |
||||
|
||||
# Navegar al directorio clonado |
||||
cd ultralytics |
||||
|
||||
# Instalar el paquete en modo editable para desarrollo |
||||
pip install -e . |
||||
``` |
||||
|
||||
Consulta el archivo [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) de `ultralytics` para ver una lista de dependencias. Ten en cuenta que todos los ejemplos anteriores instalan todas las dependencias requeridas. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/_a7cVL9hqnk" |
||||
title="YouTube video player" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Watch:</strong> Ultralytics YOLO Quick Start Guide |
||||
</p> |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
Los requisitos de PyTorch varían según el sistema operativo y los requisitos de CUDA, por lo que se recomienda instalar primero PyTorch siguiendo las instrucciones en [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally). |
||||
|
||||
<a href="https://pytorch.org/get-started/locally/"> |
||||
<img width="800" alt="Instrucciones de Instalación de PyTorch" src="https://user-images.githubusercontent.com/26833433/228650108-ab0ec98a-b328-4f40-a40d-95355e8a84e3.png"> |
||||
</a> |
||||
|
||||
## Usar Ultralytics con CLI |
||||
|
||||
La interfaz de línea de comandos (CLI) de Ultralytics permite el uso de comandos simples de una sola línea sin la necesidad de un entorno de Python. La CLI no requiere personalización ni código Python. Puedes simplemente ejecutar todas las tareas desde el terminal con el comando `yolo`. Consulta la [Guía de CLI](/../usage/cli.md) para aprender más sobre el uso de YOLOv8 desde la línea de comandos. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Sintaxis" |
||||
|
||||
Los comandos `yolo` de Ultralytics usan la siguiente sintaxis: |
||||
```bash |
||||
yolo TAREA MODO ARGUMENTOS |
||||
|
||||
Donde TAREA (opcional) es uno de [detectar, segmentar, clasificar] |
||||
MODO (requerido) es uno de [train, val, predict, export, track] |
||||
ARGUMENTOS (opcionales) son cualquier número de pares personalizados 'arg=valor' como 'imgsz=320' que sobrescriben los valores por defecto. |
||||
``` |
||||
Ver todos los ARGUMENTOS en la guía completa [Configuration Guide](/../usage/cfg.md) o con `yolo cfg` |
||||
|
||||
=== "Entrenar" |
||||
|
||||
Entrenar un modelo de detección durante 10 épocas con una tasa de aprendizaje inicial de 0.01 |
||||
```bash |
||||
yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01 |
||||
``` |
||||
|
||||
=== "Predecir" |
||||
|
||||
Predecir un video de YouTube usando un modelo de segmentación preentrenado con un tamaño de imagen de 320: |
||||
```bash |
||||
yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320 |
||||
``` |
||||
|
||||
=== "Validar" |
||||
|
||||
Validar un modelo de detección preentrenado con un tamaño de lote de 1 y un tamaño de imagen de 640: |
||||
```bash |
||||
yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640 |
||||
``` |
||||
|
||||
=== "Exportar" |
||||
|
||||
Exportar un modelo de clasificación YOLOv8n a formato ONNX con un tamaño de imagen de 224 por 128 (no se requiere TAREA) |
||||
```bash |
||||
yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128 |
||||
``` |
||||
|
||||
=== "Especial" |
||||
|
||||
Ejecutar comandos especiales para ver la versión, ver configuraciones, ejecutar chequeos y más: |
||||
```bash |
||||
yolo help |
||||
yolo checks |
||||
yolo version |
||||
yolo settings |
||||
yolo copy-cfg |
||||
yolo cfg |
||||
``` |
||||
|
||||
!!! Warning "Advertencia" |
||||
|
||||
Los argumentos deben pasarse como pares `arg=valor`, separados por un signo igual `=` y delimitados por espacios ` ` entre pares. No utilices prefijos de argumentos `--` ni comas `,` entre los argumentos. |
||||
|
||||
- `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` ❌ |
||||
|
||||
[Guía de CLI](/../usage/cli.md){.md-button .md-button--primary} |
||||
|
||||
## Usar Ultralytics con Python |
||||
|
||||
La interfaz de Python de YOLOv8 permite una integración perfecta en tus proyectos de Python, facilitando la carga, ejecución y procesamiento de la salida del modelo. Diseñada con sencillez y facilidad de uso en mente, la interfaz de Python permite a los usuarios implementar rápidamente la detección de objetos, segmentación y clasificación en sus proyectos. Esto hace que la interfaz de Python de YOLOv8 sea una herramienta invaluable para cualquier persona que busque incorporar estas funcionalidades en sus proyectos de Python. |
||||
|
||||
Por ejemplo, los usuarios pueden cargar un modelo, entrenarlo, evaluar su rendimiento en un conjunto de validación e incluso exportarlo al formato ONNX con solo unas pocas líneas de código. Consulta la [Guía de Python](/../usage/python.md) para aprender más sobre el uso de YOLOv8 dentro de tus proyectos de Python. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Crear un nuevo modelo YOLO desde cero |
||||
model = YOLO('yolov8n.yaml') |
||||
|
||||
# Cargar un modelo YOLO preentrenado (recomendado para entrenamiento) |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Entrenar el modelo usando el conjunto de datos 'coco128.yaml' durante 3 épocas |
||||
results = model.train(data='coco128.yaml', epochs=3) |
||||
|
||||
# Evaluar el rendimiento del modelo en el conjunto de validación |
||||
results = model.val() |
||||
|
||||
# Realizar detección de objetos en una imagen usando el modelo |
||||
results = model('https://ultralytics.com/images/bus.jpg') |
||||
|
||||
# Exportar el modelo al formato ONNX |
||||
success = model.export(format='onnx') |
||||
``` |
||||
|
||||
[Guía de Python](/../usage/python.md){.md-button .md-button--primary} |
||||
@ -1,172 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Aprenda sobre los modelos de clasificación de imágenes YOLOv8 Classify. Obtenga información detallada sobre la Lista de Modelos Preentrenados y cómo Entrenar, Validar, Predecir y Exportar modelos. |
||||
keywords: Ultralytics, YOLOv8, Clasificación de imágenes, Modelos preentrenados, YOLOv8n-cls, Entrenamiento, Validación, Predicción, Exportación de modelos |
||||
--- |
||||
|
||||
# Clasificación de Imágenes |
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418606-adf35c62-2e11-405d-84c6-b84e7d013804.png" alt="Ejemplos de clasificación de imágenes"> |
||||
|
||||
La clasificación de imágenes es la tarea más sencilla de las tres y consiste en clasificar una imagen completa en una de un conjunto de clases predefinidas. |
||||
|
||||
La salida de un clasificador de imágenes es una única etiqueta de clase y una puntuación de confianza. La clasificación de imágenes es útil cuando solo necesita saber a qué clase pertenece una imagen y no necesita conocer dónde están ubicados los objetos de esa clase o cuál es su forma exacta. |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
Los modelos YOLOv8 Classify utilizan el sufijo `-cls`, por ejemplo, `yolov8n-cls.pt` y están preentrenados en [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). |
||||
|
||||
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) |
||||
|
||||
Los modelos Classify preentrenados YOLOv8 se muestran aquí. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). |
||||
|
||||
Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último [lanzamiento](https://github.com/ultralytics/assets/releases) de Ultralytics en el primer uso. |
||||
|
||||
| Modelo | Tamaño<br><sup>(píxeles) | Exactitud<br><sup>top1 | Exactitud<br><sup>top5 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | Parámetros<br><sup>(M) | FLOPs<br><sup>(B) en 640 | |
||||
|----------------------------------------------------------------------------------------------|--------------------------|------------------------|------------------------|------------------------------------|-----------------------------------------|------------------------|--------------------------| |
||||
| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | |
||||
|
||||
- Los valores de **Exactitud** son las precisiones de los modelos en el conjunto de datos de validación de [ImageNet](https://www.image-net.org/). |
||||
<br>Para reproducir usar `yolo val classify data=path/to/ImageNet device=0` |
||||
- **Velocidad** promediada sobre imágenes de validación de ImageNet usando una instancia de [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) |
||||
<br>Para reproducir usar `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu` |
||||
|
||||
## Entrenamiento |
||||
|
||||
Entrena el modelo YOLOv8n-cls en el conjunto de datos MNIST160 durante 100 épocas con un tamaño de imagen de 64. Para obtener una lista completa de argumentos disponibles, consulte la página de [Configuración](/../usage/cfg.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-cls.yaml') # construir un nuevo modelo desde YAML |
||||
model = YOLO('yolov8n-cls.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) |
||||
model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construir desde YAML y transferir pesos |
||||
|
||||
# Entrenar el modelo |
||||
results = model.train(data='mnist160', epochs=100, imgsz=64) |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Construir un nuevo modelo desde YAML y empezar entrenamiento desde cero |
||||
yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64 |
||||
|
||||
# Empezar entrenamiento desde un modelo *.pt preentrenado |
||||
yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64 |
||||
|
||||
# Construir un nuevo modelo desde YAML, transferir pesos preentrenados e iniciar entrenamiento |
||||
yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64 |
||||
``` |
||||
|
||||
### Formato del conjunto de datos |
||||
|
||||
El formato del conjunto de datos de clasificación YOLO puede encontrarse en detalle en la [Guía de Conjuntos de Datos](../../../datasets/classify/index.md). |
||||
|
||||
## Validación |
||||
|
||||
Validar la exactitud del modelo YOLOv8n-cls entrenado en el conjunto de datos MNIST160. No es necesario pasar ningún argumento ya que el `modelo` retiene su `data` y argumentos como atributos del modelo. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial |
||||
model = YOLO('path/to/best.pt') # cargar un modelo personalizado |
||||
|
||||
# Validar el modelo |
||||
metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan |
||||
metrics.top1 # precisión top1 |
||||
metrics.top5 # precisión top5 |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo classify val model=yolov8n-cls.pt # validar modelo oficial |
||||
yolo classify val model=path/to/best.pt # validar modelo personalizado |
||||
``` |
||||
|
||||
## Predicción |
||||
|
||||
Usar un modelo YOLOv8n-cls entrenado para realizar predicciones en imágenes. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial |
||||
model = YOLO('path/to/best.pt') # cargar un modelo personalizado |
||||
|
||||
# Predecir con el modelo |
||||
results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial |
||||
yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado |
||||
``` |
||||
|
||||
Ver detalles completos del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/). |
||||
|
||||
## Exportación |
||||
|
||||
Exportar un modelo YOLOv8n-cls a un formato diferente como ONNX, CoreML, etc. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial |
||||
model = YOLO('path/to/best.pt') # cargar un modelo entrenado personalizado |
||||
|
||||
# Exportar el modelo |
||||
model.export(format='onnx') |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo export model=yolov8n-cls.pt format=onnx # exportar modelo oficial |
||||
yolo export model=path/to/best.pt format=onnx # exportar modelo entrenado personalizado |
||||
``` |
||||
|
||||
Los formatos de exportación disponibles para YOLOv8-cls se encuentran en la tabla a continuación. Puede predecir o validar directamente en modelos exportados, por ejemplo, `yolo predict model=yolov8n-cls.onnx`. Ejemplos de uso se muestran para su modelo después de que se completa la exportación. |
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | |
||||
|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------| |
||||
| [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` | |
||||
|
||||
Vea detalles completos de `exportación` en la página de [Exportación](https://docs.ultralytics.com/modes/export/). |
||||
@ -1,184 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Documentación oficial de YOLOv8 de Ultralytics. Aprende a entrenar, validar, predecir y exportar modelos en varios formatos. Incluyendo estadísticas detalladas de rendimiento. |
||||
keywords: YOLOv8, Ultralytics, detección de objetos, modelos preentrenados, entrenamiento, validación, predicción, exportación de modelos, COCO, ImageNet, PyTorch, ONNX, CoreML |
||||
--- |
||||
|
||||
# Detección de Objetos |
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418624-5785cb93-74c9-4541-9179-d5c6782d491a.png" alt="Ejemplos de detección de objetos"> |
||||
|
||||
La detección de objetos es una tarea que implica identificar la ubicación y clase de objetos en una imagen o flujo de video. |
||||
|
||||
La salida de un detector de objetos es un conjunto de cajas delimitadoras que encierran a los objetos en la imagen, junto con etiquetas de clase y puntajes de confianza para cada caja. La detección de objetos es una buena opción cuando necesitas identificar objetos de interés en una escena, pero no necesitas saber exactamente dónde se encuentra el objeto o su forma exacta. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/5ku7npMrW40?si=6HQO1dDXunV8gekh" |
||||
title="Reproductor de video YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
permitir pantalla completa> |
||||
</iframe> |
||||
<br> |
||||
<strong>Ver:</strong> Detección de Objetos con Modelo Preentrenado YOLOv8 de Ultralytics. |
||||
</p> |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
Los modelos YOLOv8 Detect son los modelos predeterminados de YOLOv8, es decir, `yolov8n.pt` y están preentrenados en [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). |
||||
|
||||
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) |
||||
|
||||
Los modelos preentrenados de YOLOv8 Detect se muestran aquí. Los modelos de Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos de Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). |
||||
|
||||
Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en el primer uso. |
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | mAP<sup>val<br>50-95 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
|--------------------------------------------------------------------------------------|--------------------------|----------------------|------------------------------------|-----------------------------------------|------------------------|-------------------| |
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | |
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | |
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | |
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | |
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | |
||||
|
||||
- Los valores de **mAP<sup>val</sup>** son para un solo modelo a una sola escala en el conjunto de datos [COCO val2017](https://cocodataset.org). |
||||
<br>Reproduce utilizando `yolo val detect data=coco.yaml device=0` |
||||
- La **Velocidad** es el promedio sobre las imágenes de COCO val utilizando una instancia [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). |
||||
<br>Reproduce utilizando `yolo val detect data=coco128.yaml batch=1 device=0|cpu` |
||||
|
||||
## Entrenamiento |
||||
|
||||
Entrena a YOLOv8n en el conjunto de datos COCO128 durante 100 épocas a tamaño de imagen 640. Para una lista completa de argumentos disponibles, consulta la página [Configuración](/../usage/cfg.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.yaml') # construye un nuevo modelo desde YAML |
||||
model = YOLO('yolov8n.pt') # carga un modelo preentrenado (recomendado para entrenamiento) |
||||
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construye desde YAML y transfiere los pesos |
||||
|
||||
# Entrenar el modelo |
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640) |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Construir un nuevo modelo desde YAML y comenzar entrenamiento desde cero |
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 |
||||
|
||||
# Comenzar entrenamiento desde un modelo *.pt preentrenado |
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 |
||||
|
||||
# Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar entrenamiento |
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 |
||||
``` |
||||
|
||||
### Formato del conjunto de datos |
||||
|
||||
El formato del conjunto de datos de detección de YOLO se puede encontrar en detalle en la [Guía de Conjuntos de Datos](../../../datasets/detect/index.md). Para convertir tu conjunto de datos existente desde otros formatos (como COCO, etc.) al formato YOLO, por favor usa la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics. |
||||
|
||||
## Validación |
||||
|
||||
Valida la precisión del modelo YOLOv8n entrenado en el conjunto de datos COCO128. No es necesario pasar ningún argumento, ya que el `modelo` retiene sus datos de `entrenamiento` y argumentos como atributos del modelo. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.pt') # cargar un modelo oficial |
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado |
||||
|
||||
# Validar el modelo |
||||
metrics = model.val() # sin argumentos necesarios, el conjunto de datos y configuraciones se recuerdan |
||||
metrics.box.map # map50-95 |
||||
metrics.box.map50 # map50 |
||||
metrics.box.map75 # map75 |
||||
metrics.box.maps # una lista contiene map50-95 de cada categoría |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo detect val model=yolov8n.pt # validar modelo oficial |
||||
yolo detect val model=ruta/a/mejor.pt # validar modelo personalizado |
||||
``` |
||||
|
||||
## Predicción |
||||
|
||||
Utiliza un modelo YOLOv8n entrenado para realizar predicciones en imágenes. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.pt') # cargar un modelo oficial |
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado |
||||
|
||||
# Predecir con el modelo |
||||
results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial |
||||
yolo detect predict model=ruta/a/mejor.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado |
||||
``` |
||||
|
||||
Consulta los detalles completos del modo `predict` en la página [Predicción](https://docs.ultralytics.com/modes/predict/). |
||||
|
||||
## Exportación |
||||
|
||||
Exporta un modelo YOLOv8n a un formato diferente como ONNX, CoreML, etc. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n.pt') # cargar un modelo oficial |
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo entrenado personalizado |
||||
|
||||
# Exportar el modelo |
||||
model.export(format='onnx') |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo export model=yolov8n.pt format=onnx # exportar modelo oficial |
||||
yolo export model=ruta/a/mejor.pt format=onnx # exportar modelo entrenado personalizado |
||||
``` |
||||
|
||||
Los formatos de exportación de YOLOv8 disponibles se encuentran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, es decir, `yolo predict model=yolov8n.onnx`. Ejemplos de uso se muestran para tu modelo después de que la exportación se completa. |
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadata | Argumentos | |
||||
|--------------------------------------------------------------------|--------------------|----------------------------|----------|------------------------------------------------------------------------| |
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | |
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimizar` | |
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `mitad`, `dinámico`, `simplificar`, `conjunto de operaciones` | |
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `modelo_yolov8n_openvino/` | ✅ | `imgsz`, `mitad` | |
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `mitad`, `dinámico`, `simplificar`, `espacio de trabajo` | |
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `mitad`, `int8`, `nms` | |
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `modelo_guardado_yolov8n/` | ✅ | `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`, `mitad`, `int8` | |
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | |
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `modelo_web_yolov8n/` | ✅ | `imgsz` | |
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `modelo_yolov8n_paddle/` | ✅ | `imgsz` | |
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `modelo_ncnn_yolov8n/` | ✅ | `imgsz`, `mitad` | |
||||
|
||||
Consulta los detalles completos de la `exportación` en la página [Exportar](https://docs.ultralytics.com/modes/export/). |
||||
@ -1,55 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Aprenda sobre las tareas fundamentales de visión por computadora que YOLOv8 puede realizar, incluyendo detección, segmentación, clasificación y estimación de pose. Comprenda sus usos en sus proyectos de IA. |
||||
keywords: Ultralytics, YOLOv8, Detección, Segmentación, Clasificación, Estimación de Pose, Marco de IA, Tareas de Visión por Computadora |
||||
--- |
||||
|
||||
# Tareas de Ultralytics YOLOv8 |
||||
|
||||
<br> |
||||
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png" alt="Tareas soportadas por Ultralytics YOLO"> |
||||
|
||||
YOLOv8 es un marco de trabajo de IA que soporta múltiples **tareas** de visión por computadora. El marco puede usarse para realizar [detección](detect.md), [segmentación](segment.md), [clasificación](classify.md) y estimación de [pose](pose.md). Cada una de estas tareas tiene un objetivo y caso de uso diferente. |
||||
|
||||
!!! Note "Nota" |
||||
|
||||
🚧 Nuestra documentación multilenguaje está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por su paciencia! 🙏 |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/NAs-cfq9BDw" |
||||
title="Reproductor de video YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Mire:</strong> Explore las Tareas de Ultralytics YOLO: Detección de Objetos, Segmentación, Seguimiento y Estimación de Pose. |
||||
</p> |
||||
|
||||
## [Detección](detect.md) |
||||
|
||||
La detección es la tarea principal soportada por YOLOv8. Implica detectar objetos en una imagen o cuadro de video y dibujar cuadros delimitadores alrededor de ellos. Los objetos detectados se clasifican en diferentes categorías basadas en sus características. YOLOv8 puede detectar múltiples objetos en una sola imagen o cuadro de video con alta precisión y velocidad. |
||||
|
||||
[Ejemplos de Detección](detect.md){ .md-button } |
||||
|
||||
## [Segmentación](segment.md) |
||||
|
||||
La segmentación es una tarea que implica segmentar una imagen en diferentes regiones basadas en el contenido de la imagen. A cada región se le asigna una etiqueta basada en su contenido. Esta tarea es útil en aplicaciones tales como segmentación de imágenes y imágenes médicas. YOLOv8 utiliza una variante de la arquitectura U-Net para realizar la segmentación. |
||||
|
||||
[Ejemplos de Segmentación](segment.md){ .md-button } |
||||
|
||||
## [Clasificación](classify.md) |
||||
|
||||
La clasificación es una tarea que implica clasificar una imagen en diferentes categorías. YOLOv8 puede usarse para clasificar imágenes basadas en su contenido. Utiliza una variante de la arquitectura EfficientNet para realizar la clasificación. |
||||
|
||||
[Ejemplos de Clasificación](classify.md){ .md-button } |
||||
|
||||
## [Pose](pose.md) |
||||
|
||||
La detección de pose/puntos clave es una tarea que implica detectar puntos específicos en una imagen o cuadro de video. Estos puntos se conocen como puntos clave y se utilizan para rastrear el movimiento o la estimación de la pose. YOLOv8 puede detectar puntos clave en una imagen o cuadro de video con alta precisión y velocidad. |
||||
|
||||
[Ejemplos de Pose](pose.md){ .md-button } |
||||
|
||||
## Conclusión |
||||
|
||||
YOLOv8 soporta múltiples tareas, incluyendo detección, segmentación, clasificación y detección de puntos clave. Cada una de estas tareas tiene diferentes objetivos y casos de uso. Al entender las diferencias entre estas tareas, puede elegir la tarea adecuada para su aplicación de visión por computadora. |
||||
@ -1,185 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Aprende a utilizar Ultralytics YOLOv8 para tareas de estimación de pose. Encuentra modelos preentrenados, aprende a entrenar, validar, predecir y exportar tus propios modelos. |
||||
keywords: Ultralytics, YOLO, YOLOv8, estimación de pose, detección de puntos clave, detección de objetos, modelos preentrenados, aprendizaje automático, inteligencia artificial |
||||
--- |
||||
|
||||
# Estimación de Pose |
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png" alt="Ejemplos de estimación de pose"> |
||||
|
||||
La estimación de pose es una tarea que implica identificar la ubicación de puntos específicos en una imagen, comúnmente referidos como puntos clave. Estos puntos clave pueden representar varias partes del objeto, como articulaciones, puntos de referencia u otras características distintivas. La ubicación de los puntos clave generalmente se representa como un conjunto de coordenadas 2D `[x, y]` o 3D `[x, y, visible]`. |
||||
|
||||
La salida de un modelo de estimación de pose es un conjunto de puntos que representan los puntos clave en un objeto de la imagen, generalmente junto con las puntuaciones de confianza para cada punto. La estimación de pose es una buena opción cuando se necesita identificar partes específicas de un objeto en una escena y su ubicación relativa entre ellas. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ" |
||||
title="Reproductor de video de YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Ver:</strong> Estimación de Pose con Ultralytics YOLOv8. |
||||
</p> |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
Los modelos _pose_ YOLOv8 utilizan el sufijo `-pose`, por ejemplo, `yolov8n-pose.pt`. Estos modelos están entrenados en el conjunto de datos [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) y son adecuados para una variedad de tareas de estimación de pose. |
||||
|
||||
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) |
||||
|
||||
Aquí se muestran los modelos preentrenados de YOLOv8 Pose. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). |
||||
|
||||
Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en el primer uso. |
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
|------------------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------|------------------------------------|-----------------------------------------|------------------------|-------------------| |
||||
| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 | |
||||
|
||||
- Los valores de **mAP<sup>val</sup>** son para un solo modelo a una sola escala en el conjunto de datos [COCO Keypoints val2017](https://cocodataset.org). |
||||
<br>Reproducir con `yolo val pose data=coco-pose.yaml device=0` |
||||
- **Velocidad** promediada sobre imágenes COCO val usando una instancia [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). |
||||
<br>Reproducir con `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu` |
||||
|
||||
## Entrenar |
||||
|
||||
Entrena un modelo YOLOv8-pose en el conjunto de datos COCO128-pose. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-pose.yaml') # construir un nuevo modelo desde YAML |
||||
model = YOLO('yolov8n-pose.pt') # cargar un modelo preentrenado (recomendado para entrenar) |
||||
model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # construir desde YAML y transferir los pesos |
||||
|
||||
# Entrenar el modelo |
||||
results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640) |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Construir un nuevo modelo desde YAML y comenzar entrenamiento desde cero |
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640 |
||||
|
||||
# Empezar entrenamiento desde un modelo *.pt preentrenado |
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640 |
||||
|
||||
# Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar entrenamiento |
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640 |
||||
``` |
||||
|
||||
### Formato del conjunto de datos |
||||
|
||||
El formato del conjunto de datos de pose de YOLO se puede encontrar en detalle en la [Guía de Conjuntos de Datos](../../../datasets/pose/index.md). Para convertir tu conjunto de datos existente de otros formatos (como COCO, etc.) al formato de YOLO, usa la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics. |
||||
|
||||
## Validar |
||||
|
||||
Valida la precisión del modelo YOLOv8n-pose entrenado en el conjunto de datos COCO128-pose. No es necesario pasar ningún argumento ya que el `modelo` mantiene sus `datos` de entrenamiento y argumentos como atributos del modelo. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial |
||||
model = YOLO('path/to/best.pt') # cargar un modelo personalizado |
||||
|
||||
# Validar el modelo |
||||
metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan |
||||
metrics.box.map # map50-95 |
||||
metrics.box.map50 # map50 |
||||
metrics.box.map75 # map75 |
||||
metrics.box.maps # una lista contiene map50-95 de cada categoría |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo pose val model=yolov8n-pose.pt # modelo oficial de val |
||||
yolo pose val model=path/to/best.pt # modelo personalizado de val |
||||
``` |
||||
|
||||
## Predecir |
||||
|
||||
Usa un modelo YOLOv8n-pose entrenado para realizar predicciones en imágenes. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial |
||||
model = YOLO('path/to/best.pt') # cargar un modelo personalizado |
||||
|
||||
# Predecir con el modelo |
||||
results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial |
||||
yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado |
||||
``` |
||||
|
||||
Consulta los detalles completos del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/). |
||||
|
||||
## Exportar |
||||
|
||||
Exporta un modelo YOLOv8n Pose a un formato diferente como ONNX, CoreML, etc. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial |
||||
model = YOLO('path/to/best.pt') # cargar un modelo entrenado personalizado |
||||
|
||||
# Exportar el modelo |
||||
model.export(format='onnx') |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo export model=yolov8n-pose.pt format=onnx # exportar modelo oficial |
||||
yolo export model=path/to/best.pt format=onnx # exportar modelo entrenado personalizado |
||||
``` |
||||
|
||||
Los formatos de exportación de YOLOv8-pose disponibles se muestran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, por ejemplo, `yolo predict model=yolov8n-pose.onnx`. Los ejemplos de uso se muestran para tu modelo después de que la exportación se completa. |
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | |
||||
|--------------------------------------------------------------------|--------------------|--------------------------------|-----------|---------------------------------------------------------------| |
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - | |
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` | |
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dinámico`, `simplify`, `opset` | |
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` | |
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dinámico`, `simplify`, `espacio de trabajo` | |
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `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`, `half`, `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`, `half` | |
||||
|
||||
Consulta los detalles completos del modo `export` en la página de [Exportación](https://docs.ultralytics.com/modes/export/). |
||||
@ -1,188 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Aprende a utilizar modelos de segmentación de instancias con Ultralytics YOLO. Instrucciones sobre entrenamiento, validación, predicción de imágenes y exportación de modelos. |
||||
keywords: yolov8, segmentación de instancias, Ultralytics, conjunto de datos COCO, segmentación de imágenes, detección de objetos, entrenamiento de modelos, validación de modelos, predicción de imágenes, exportación de modelos. |
||||
--- |
||||
|
||||
# Segmentación de Instancias |
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418644-7df320b8-098d-47f1-85c5-26604d761286.png" alt="Ejemplos de segmentación de instancias"> |
||||
|
||||
La segmentación de instancias va un paso más allá de la detección de objetos e implica identificar objetos individuales en una imagen y segmentarlos del resto de la imagen. |
||||
|
||||
La salida de un modelo de segmentación de instancias es un conjunto de máscaras o contornos que delimitan cada objeto en la imagen, junto con etiquetas de clase y puntajes de confianza para cada objeto. La segmentación de instancias es útil cuando necesitas saber no solo dónde están los objetos en una imagen, sino también cuál es su forma exacta. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/o4Zd-IeMlSY?si=37nusCzDTd74Obsp" |
||||
title="Reproductor de video de YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Mira:</strong> Ejecuta la Segmentación con el Modelo Ultralytics YOLOv8 Preentrenado en Python. |
||||
</p> |
||||
|
||||
!!! Tip "Consejo" |
||||
|
||||
Los modelos YOLOv8 Segment utilizan el sufijo `-seg`, es decir, `yolov8n-seg.pt` y están preentrenados en el [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). |
||||
|
||||
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) |
||||
|
||||
Aquí se muestran los modelos Segment preentrenados YOLOv8. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). |
||||
|
||||
Los [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en su primer uso. |
||||
|
||||
| Modelo | Tamaño<br><sup>(píxeles) | mAP<sup>caja<br>50-95 | mAP<sup>máscara<br>50-95 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | Parámetros<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
|----------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------------|------------------------------------|-----------------------------------------|------------------------|-------------------| |
||||
| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | |
||||
|
||||
- Los valores **mAP<sup>val</sup>** son para un único modelo a una única escala en el conjunto de datos [COCO val2017](https://cocodataset.org). |
||||
<br>Reproducir utilizando `yolo val segment data=coco.yaml device=0` |
||||
- La **Velocidad** promediada sobre imágenes de COCO val utilizando una instancia de [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). |
||||
<br>Reproducir utilizando `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` |
||||
|
||||
## Entrenamiento |
||||
|
||||
Entrena el modelo YOLOv8n-seg en el conjunto de datos COCO128-seg durante 100 épocas con tamaño de imagen de 640. Para una lista completa de argumentos disponibles, consulta la página de [Configuración](/../usage/cfg.md). |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-seg.yaml') # construir un nuevo modelo desde YAML |
||||
model = YOLO('yolov8n-seg.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) |
||||
model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # construir desde YAML y transferir pesos |
||||
|
||||
# Entrenar el modelo |
||||
results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640) |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Construir un nuevo modelo desde YAML y comenzar a entrenar desde cero |
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640 |
||||
|
||||
# Comenzar a entrenar desde un modelo *.pt preentrenado |
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640 |
||||
|
||||
# Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar a entrenar |
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640 |
||||
``` |
||||
|
||||
### Formato del conjunto de datos |
||||
|
||||
El formato del conjunto de datos de segmentación YOLO puede encontrarse detallado en la [Guía de Conjuntos de Datos](../../../datasets/segment/index.md). Para convertir tu conjunto de datos existente de otros formatos (como COCO, etc.) al formato YOLO, utiliza la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics. |
||||
|
||||
## Validación |
||||
|
||||
Valida la precisión del modelo YOLOv8n-seg entrenado en el conjunto de datos COCO128-seg. No es necesario pasar ningún argumento ya que el `modelo` retiene sus `datos` de entrenamiento y argumentos como atributos del modelo. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial |
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado |
||||
|
||||
# Validar el modelo |
||||
metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan |
||||
metrics.box.map # map50-95(B) |
||||
metrics.box.map50 # map50(B) |
||||
metrics.box.map75 # map75(B) |
||||
metrics.box.maps # una lista contiene map50-95(B) de cada categoría |
||||
metrics.seg.map # map50-95(M) |
||||
metrics.seg.map50 # map50(M) |
||||
metrics.seg.map75 # map75(M) |
||||
metrics.seg.maps # una lista contiene map50-95(M) de cada categoría |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo segment val model=yolov8n-seg.pt # validar el modelo oficial |
||||
yolo segment val model=ruta/a/mejor.pt # validar el modelo personalizado |
||||
``` |
||||
|
||||
## Predicción |
||||
|
||||
Usa un modelo YOLOv8n-seg entrenado para realizar predicciones en imágenes. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial |
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado |
||||
|
||||
# Predecir con el modelo |
||||
results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # predecir con el modelo oficial |
||||
yolo segment predict model=ruta/a/mejor.pt source='https://ultralytics.com/images/bus.jpg' # predecir con el modelo personalizado |
||||
``` |
||||
|
||||
Consulta todos los detalles del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/). |
||||
|
||||
## Exportación |
||||
|
||||
Exporta un modelo YOLOv8n-seg a un formato diferente como ONNX, CoreML, etc. |
||||
|
||||
!!! Example "Ejemplo" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Cargar un modelo |
||||
model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial |
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo entrenado personalizado |
||||
|
||||
# Exportar el modelo |
||||
model.export(format='onnx') |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo export model=yolov8n-seg.pt format=onnx # exportar el modelo oficial |
||||
yolo export model=ruta/a/mejor.pt format=onnx # exportar el modelo entrenado personalizado |
||||
``` |
||||
|
||||
Los formatos disponibles para exportar YOLOv8-seg se muestran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, es decir, `yolo predict model=yolov8n-seg.onnx`. Se muestran ejemplos de uso para tu modelo después de que se completa la exportación. |
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | |
||||
|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------| |
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - | |
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` | |
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | |
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` | |
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | |
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `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`, `half`, `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`, `half` | |
||||
|
||||
Consulta todos los detalles del modo `export` en la página de [Exportación](https://docs.ultralytics.com/modes/export/). |
||||
@ -1,127 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explorez divers ensembles de données de vision par ordinateur pris en charge par Ultralytics pour la détection d'objets, la segmentation, l'estimation de la pose, la classification d'images et le suivi multi-objets. |
||||
keywords: vision par ordinateur, ensembles de données, Ultralytics, YOLO, détection d'objets, segmentation d'instance, estimation de la pose, classification d'images, suivi multi-objets |
||||
--- |
||||
|
||||
# Aperçu des ensembles de données |
||||
|
||||
Ultralytics fournit un soutien pour divers ensembles de données pour faciliter les tâches de vision par ordinateur telles que la détection, la segmentation d'instance, l'estimation de la pose, la classification et le suivi multi-objets. Ci-dessous se trouve une liste des principaux ensembles de données Ultralytics, suivie d'un résumé de chaque tâche de vision par ordinateur et des ensembles de données respectifs. |
||||
|
||||
!!! Note "Note" |
||||
|
||||
🚧 Notre documentation multilingue est actuellement en cours de construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏 |
||||
|
||||
## [Ensembles de données de détection](../../datasets/detect/index.md) |
||||
|
||||
La détection d'objets par boîte englobante est une technique de vision par ordinateur qui consiste à détecter et localiser des objets dans une image en dessinant une boîte englobante autour de chaque objet. |
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md) : Un ensemble de données contenant des données de suivi 3D et de prévision de mouvement dans des environnements urbains avec des annotations détaillées. |
||||
- [COCO](../../datasets/detect/coco.md) : Un ensemble de données de grande échelle conçu pour la détection d'objets, la segmentation et l'annotation avec plus de 200K images étiquetées. |
||||
- [COCO8](../../datasets/detect/coco8.md) : Contient les 4 premières images de COCO train et COCO val, adaptées pour des tests rapides. |
||||
- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md) : Un ensemble de données d'images de têtes de blé recueillies dans le monde entier pour les tâches de détection et de localisation d'objets. |
||||
- [Objects365](../../datasets/detect/objects365.md) : Un ensemble de données de grande qualité et à grande échelle pour la détection d'objets avec 365 catégories d'objets et plus de 600K images annotées. |
||||
- [OpenImagesV7](../../datasets/detect/open-images-v7.md) : Un ensemble de données complet de Google avec 1.7M d'images d'entraînement et 42k images de validation. |
||||
- [SKU-110K](../../datasets/detect/sku-110k.md) : Un ensemble de données mettant en vedette la détection d'objets denses dans les environnements de vente au détail avec plus de 11K images et 1.7 million de boîtes englobantes. |
||||
- [VisDrone](../../datasets/detect/visdrone.md) : Un ensemble de données contenant des données de détection d'objets et de suivi multi-objets à partir d'images capturées par drone avec plus de 10K images et séquences vidéo. |
||||
- [VOC](../../datasets/detect/voc.md) : L'ensemble de données de classes d'objets visuels Pascal (VOC) pour la détection d'objets et la segmentation avec 20 classes d'objets et plus de 11K images. |
||||
- [xView](../../datasets/detect/xview.md) : Un ensemble de données pour la détection d'objets dans l'imagerie aérienne avec 60 catégories d'objets et plus d'un million d'objets annotés. |
||||
|
||||
## [Ensembles de données de segmentation d'instance](../../datasets/segment/index.md) |
||||
|
||||
La segmentation d'instance est une technique de vision par ordinateur qui consiste à identifier et localiser des objets dans une image au niveau des pixels. |
||||
|
||||
- [COCO](../../datasets/segment/coco.md) : Un ensemble de données de grande échelle conçu pour la détection d'objets, la segmentation et les tâches d'annotation avec plus de 200K images étiquetées. |
||||
- [COCO8-seg](../../datasets/segment/coco8-seg.md) : Un ensemble de données plus petit pour les tâches de segmentation d'instance, contenant un sous-ensemble de 8 images COCO avec des annotations de segmentation. |
||||
|
||||
## [Estimation de pose](../../datasets/pose/index.md) |
||||
|
||||
L'estimation de la pose est une technique utilisée pour déterminer la pose de l'objet par rapport à la caméra ou au système de coordonnées mondial. |
||||
|
||||
- [COCO](../../datasets/pose/coco.md) : Un ensemble de données de grande échelle avec des annotations de poses humaines conçu pour les tâches d'estimation de la pose. |
||||
- [COCO8-pose](../../datasets/pose/coco8-pose.md) : Un ensemble de données plus petit pour les tâches d'estimation de la pose, contenant un sous-ensemble de 8 images COCO avec des annotations de pose humaine. |
||||
- [Tiger-pose](../../datasets/pose/tiger-pose.md) : Un ensemble de données compact composé de 263 images centrées sur les tigres, annotées avec 12 points par tigre pour les tâches d'estimation de la pose. |
||||
|
||||
## [Classification](../../datasets/classify/index.md) |
||||
|
||||
La classification d'images est une tâche de vision par ordinateur qui implique de catégoriser une image dans une ou plusieurs classes ou catégories prédéfinies en fonction de son contenu visuel. |
||||
|
||||
- [Caltech 101](../../datasets/classify/caltech101.md) : Un ensemble de données contenant des images de 101 catégories d'objets pour les tâches de classification d'images. |
||||
- [Caltech 256](../../datasets/classify/caltech256.md) : Une version étendue de Caltech 101 avec 256 catégories d'objets et des images plus complexes. |
||||
- [CIFAR-10](../../datasets/classify/cifar10.md) : Un ensemble de données de 60K images couleur 32x32 réparties en 10 classes, avec 6K images par classe. |
||||
- [CIFAR-100](../../datasets/classify/cifar100.md) : Une version étendue de CIFAR-10 avec 100 catégories d'objets et 600 images par classe. |
||||
- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md) : Un ensemble de données composé de 70 000 images en niveaux de gris de 10 catégories de mode pour les tâches de classification d'images. |
||||
- [ImageNet](../../datasets/classify/imagenet.md) : Un ensemble de données à grande échelle pour la détection d'objets et la classification d'images avec plus de 14 millions d'images et 20 000 catégories. |
||||
- [ImageNet-10](../../datasets/classify/imagenet10.md) : Un sous-ensemble plus petit d'ImageNet avec 10 catégories pour des expériences et des tests plus rapides. |
||||
- [Imagenette](../../datasets/classify/imagenette.md) : Un sous-ensemble plus petit d'ImageNet qui contient 10 classes facilement distinctes pour un entraînement et des tests plus rapides. |
||||
- [Imagewoof](../../datasets/classify/imagewoof.md) : Un sous-ensemble d'ImageNet plus difficile contenant 10 catégories de races de chiens pour les tâches de classification d'images. |
||||
- [MNIST](../../datasets/classify/mnist.md) : Un ensemble de données de 70 000 images en niveaux de gris de chiffres manuscrits pour les tâches de classification d'images. |
||||
|
||||
## [Boîtes Englobantes Orientées (OBB)](../../datasets/obb/index.md) |
||||
|
||||
Les Boîtes Englobantes Orientées (OBB) sont une méthode en vision par ordinateur pour détecter des objets inclinés dans les images en utilisant des boîtes englobantes rotatives, souvent appliquée à l'imagerie aérienne et satellite. |
||||
|
||||
- [DOTAv2](../../datasets/obb/dota-v2.md) : Un ensemble de données d'imagerie aérienne populaire avec 1.7 million d'instances et 11 268 images. |
||||
|
||||
## [Suivi Multi-Objets](../../datasets/track/index.md) |
||||
|
||||
Le suivi multi-objets est une technique de vision par ordinateur qui consiste à détecter et suivre plusieurs objets dans le temps dans une séquence vidéo. |
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md) : Un ensemble de données contenant des données de suivi 3D et de prévision de mouvement dans des environnements urbains avec des annotations détaillées pour les tâches de suivi multi-objets. |
||||
- [VisDrone](../../datasets/detect/visdrone.md) : Un ensemble de données contenant des données de détection d'objets et de suivi multi-objets à partir d'images capturées par drone avec plus de 10K images et séquences vidéo. |
||||
|
||||
## Contribuer de Nouveaux Ensembles de Données |
||||
|
||||
Contribuer un nouvel ensemble de données implique plusieurs étapes pour s'assurer qu'il s'aligne bien avec l'infrastructure existante. Voici les étapes nécessaires : |
||||
|
||||
### Étapes pour Contribuer un Nouvel Ensemble de Données |
||||
|
||||
1. **Collecter des Images** : Rassemblez les images qui appartiennent à l'ensemble de données. Celles-ci pourraient être collectées à partir de différentes sources, telles que des bases de données publiques ou votre propre collection. |
||||
|
||||
2. **Annoter des Images** : Annotez ces images avec des boîtes englobantes, des segments ou des points clés, en fonction de la tâche. |
||||
|
||||
3. **Exporter des Annotations** : Convertissez ces annotations au format de fichier YOLO `*.txt` pris en charge par Ultralytics. |
||||
|
||||
4. **Organiser l'Ensemble de Données** : Rangez votre ensemble de données dans la bonne structure de dossiers. Vous devriez avoir des répertoires de niveau supérieur `train/` et `val/`, et à l'intérieur de chacun, un sous-répertoire `images/` et `labels/`. |
||||
|
||||
``` |
||||
dataset/ |
||||
├── train/ |
||||
│ ├── images/ |
||||
│ └── labels/ |
||||
└── val/ |
||||
├── images/ |
||||
└── labels/ |
||||
``` |
||||
|
||||
5. **Créer un Fichier `data.yaml`** : Dans le répertoire racine de votre ensemble de données, créez un fichier `data.yaml` qui décrit l'ensemble de données, les classes et les autres informations nécessaires. |
||||
|
||||
6. **Optimiser les Images (Optionnel)** : Si vous souhaitez réduire la taille de l'ensemble de données pour un traitement plus efficace, vous pouvez optimiser les images en utilisant le code ci-dessous. Ceci n'est pas requis, mais recommandé pour des tailles d'ensemble de données plus petites et des vitesses de téléchargement plus rapides. |
||||
|
||||
7. **Zipper l'Ensemble de Données** : Compressez le dossier complet de l'ensemble de données dans un fichier zip. |
||||
|
||||
8. **Documenter et PR** : Créez une page de documentation décrivant votre ensemble de données et comment il s'intègre dans le cadre existant. Après cela, soumettez une Pull Request (PR). Référez-vous aux [lignes directrices de contribution Ultralytics](https://docs.ultralytics.com/help/contributing) pour plus de détails sur la manière de soumettre une PR. |
||||
|
||||
### Exemple de Code pour Optimiser et Zipper un Ensemble de Données |
||||
|
||||
!!! Example "Optimiser et Zipper un Ensemble de Données" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from pathlib import Path |
||||
from ultralytics.data.utils import compress_one_image |
||||
from ultralytics.utils.downloads import zip_directory |
||||
|
||||
# Définir le répertoire de l'ensemble de données |
||||
path = Path('chemin/vers/ensemble-de-données') |
||||
|
||||
# Optimiser les images dans l'ensemble de données (optionnel) |
||||
for f in path.rglob('*.jpg'): |
||||
compress_one_image(f) |
||||
|
||||
# Zipper l'ensemble de données dans 'chemin/vers/ensemble-de-données.zip' |
||||
zip_directory(path) |
||||
``` |
||||
|
||||
En suivant ces étapes, vous pouvez contribuer un nouvel ensemble de données qui s'intègre bien avec la structure existante d'Ultralytics. |
||||
@ -1,193 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Découvrez FastSAM, une solution basée sur les réseaux de neurones à convolution (CNN) pour la segmentation d'objets en temps réel dans les images. Interaction utilisateur améliorée, efficacité computationnelle et adaptabilité à différentes tâches de vision. |
||||
keywords: FastSAM, apprentissage automatique, solution basée sur les CNN, segmentation d'objets, solution en temps réel, Ultralytics, tâches de vision, traitement d'images, applications industrielles, interaction utilisateur |
||||
--- |
||||
|
||||
# Fast Segment Anything Model (FastSAM) |
||||
|
||||
Le Fast Segment Anything Model (FastSAM) est une solution basée sur les réseaux de neurones à convolution (CNN) en temps réel pour la tâche Segment Anything. Cette tâche est conçue pour segmenter n'importe quel objet dans une image en fonction de différentes interactions utilisateur possibles. FastSAM réduit considérablement les demandes computationnelles tout en maintenant des performances compétitives, ce qui en fait un choix pratique pour diverses tâches de vision. |
||||
|
||||
 |
||||
|
||||
## Vue d'ensemble |
||||
|
||||
FastSAM est conçu pour remédier aux limitations du [Segment Anything Model (SAM)](sam.md), un modèle Transformer lourd nécessitant des ressources computationnelles importantes. FastSAM découpe la tâche de segmentation en deux étapes séquentielles : la segmentation de toutes les instances et la sélection guidée par une invitation. La première étape utilise [YOLOv8-seg](../tasks/segment.md) pour produire les masques de segmentation de toutes les instances de l'image. Dans la deuxième étape, il génère la région d'intérêt correspondant à l'invitation. |
||||
|
||||
## Fonctionnalités clés |
||||
|
||||
1. **Solution en temps réel :** En exploitant l'efficacité computationnelle des CNN, FastSAM fournit une solution en temps réel pour la tâche Segment Anything, ce qui en fait une solution précieuse pour les applications industrielles nécessitant des résultats rapides. |
||||
|
||||
2. **Efficacité et performances :** FastSAM offre une réduction significative des demandes computationnelles et des ressources sans compromettre la qualité des performances. Il atteint des performances comparables à SAM, mais avec une réduction drastique des ressources computationnelles, ce qui permet une application en temps réel. |
||||
|
||||
3. **Segmentation guidée par une invitation :** FastSAM peut segmenter n'importe quel objet dans une image, guidé par différentes invitations d'interaction utilisateur possibles, offrant ainsi flexibilité et adaptabilité dans différents scénarios. |
||||
|
||||
4. **Basé sur YOLOv8-seg :** FastSAM est basé sur [YOLOv8-seg](../tasks/segment.md), un détecteur d'objets équipé d'une branche de segmentation d'instances. Cela lui permet de produire efficacement les masques de segmentation de toutes les instances dans une image. |
||||
|
||||
5. **Résultats concurrentiels sur les bancs d'essai :** Dans la tâche de proposition d'objets sur MS COCO, FastSAM obtient des scores élevés à une vitesse significativement plus rapide que [SAM](sam.md) sur une seule NVIDIA RTX 3090, démontrant ainsi son efficacité et sa capacité. |
||||
|
||||
6. **Applications pratiques :** Cette approche propose une nouvelle solution pratique pour un grand nombre de tâches de vision à une vitesse très élevée, des dizaines ou des centaines de fois plus rapide que les méthodes actuelles. |
||||
|
||||
7. **Faisabilité de la compression du modèle :** FastSAM démontre la faisabilité d'une voie qui peut réduire considérablement l'effort computationnel en introduisant une contrainte artificielle dans la structure, ouvrant ainsi de nouvelles possibilités pour l'architecture de modèles de grande taille pour les tâches de vision générales. |
||||
|
||||
## Modèles disponibles, tâches prises en charge et modes d'exploitation |
||||
|
||||
Ce tableau présente les modèles disponibles avec leurs poids pré-entraînés spécifiques, les tâches qu'ils prennent en charge et leur compatibilité avec différents modes d'exploitation tels que [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Exportation](../modes/export.md), indiqués par des emojis ✅ pour les modes pris en charge et des emojis ❌ pour les modes non pris en charge. |
||||
|
||||
| Type de modèle | Poids pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Exportation | |
||||
|----------------|---------------------|-------------------------------------------------|-----------|------------|--------------|-------------| |
||||
| FastSAM-s | `FastSAM-s.pt` | [Segmentation d'instances](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
| FastSAM-x | `FastSAM-x.pt` | [Segmentation d'instances](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Exemples d'utilisation |
||||
|
||||
Les modèles FastSAM sont faciles à intégrer dans vos applications Python. Ultralytics propose une API Python conviviale et des commandes CLI pour simplifier le développement. |
||||
|
||||
### Utilisation de la prédiction |
||||
|
||||
Pour effectuer une détection d'objets sur une image, utilisez la méthode `Predict` comme indiqué ci-dessous : |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM |
||||
from ultralytics.models.fastsam import FastSAMPrompt |
||||
|
||||
# Définir une source d'inférence |
||||
source = 'chemin/vers/bus.jpg' |
||||
|
||||
# Créer un modèle FastSAM |
||||
model = FastSAM('FastSAM-s.pt') # ou FastSAM-x.pt |
||||
|
||||
# Effectuer une inférence sur une image |
||||
everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9) |
||||
|
||||
# Préparer un objet Processus Invitation |
||||
prompt_process = FastSAMPrompt(source, everything_results, device='cpu') |
||||
|
||||
# Invitation Everything |
||||
ann = prompt_process.everything_prompt() |
||||
|
||||
# Bbox shape par défaut [0,0,0,0] -> [x1,y1,x2,y2] |
||||
ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300]) |
||||
|
||||
# Invitation Text |
||||
ann = prompt_process.text_prompt(text='une photo d\'un chien') |
||||
|
||||
# Invitation Point |
||||
# points par défaut [[0,0]] [[x1,y1],[x2,y2]] |
||||
# point_label par défaut [0] [1,0] 0:fond, 1:premier plan |
||||
ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1]) |
||||
prompt_process.plot(annotations=ann, output='./') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
```bash |
||||
# Charger un modèle FastSAM et segmenter tout avec |
||||
yolo segment predict model=FastSAM-s.pt source=chemin/vers/bus.jpg imgsz=640 |
||||
``` |
||||
|
||||
Cet exemple démontre la simplicité du chargement d'un modèle pré-entraîné et de l'exécution d'une prédiction sur une image. |
||||
|
||||
### Utilisation de la validation |
||||
|
||||
La validation du modèle sur un ensemble de données peut être effectuée de la manière suivante : |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM |
||||
|
||||
# Créer un modèle FastSAM |
||||
model = FastSAM('FastSAM-s.pt') # ou FastSAM-x.pt |
||||
|
||||
# Valider le modèle |
||||
results = model.val(data='coco8-seg.yaml') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
```bash |
||||
# Charger un modèle FastSAM et le valider sur l'ensemble de données d'exemple COCO8 avec une taille d'image de 640 pixels |
||||
yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640 |
||||
``` |
||||
|
||||
Veuillez noter que FastSAM ne prend en charge que la détection et la segmentation d'une seule classe d'objet. Cela signifie qu'il reconnaîtra et segmentera tous les objets comme étant de la même classe. Par conséquent, lors de la préparation de l'ensemble de données, vous devez convertir tous les identifiants de catégorie d'objet en 0. |
||||
|
||||
## Utilisation officielle de FastSAM |
||||
|
||||
FastSAM est également disponible directement à partir du dépôt [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM). Voici un bref aperçu des étapes typiques que vous pourriez suivre pour utiliser FastSAM : |
||||
|
||||
### Installation |
||||
|
||||
1. Clonez le dépôt FastSAM : |
||||
```shell |
||||
git clone https://github.com/CASIA-IVA-Lab/FastSAM.git |
||||
``` |
||||
|
||||
2. Créez et activez un environnement Conda avec Python 3.9 : |
||||
```shell |
||||
conda create -n FastSAM python=3.9 |
||||
conda activate FastSAM |
||||
``` |
||||
|
||||
3. Accédez au dépôt cloné et installez les packages requis : |
||||
```shell |
||||
cd FastSAM |
||||
pip install -r requirements.txt |
||||
``` |
||||
|
||||
4. Installez le modèle CLIP : |
||||
```shell |
||||
pip install git+https://github.com/openai/CLIP.git |
||||
``` |
||||
|
||||
### Exemple d'utilisation |
||||
|
||||
1. Téléchargez un [point de contrôle de modèle](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing). |
||||
|
||||
2. Utilisez FastSAM pour l'inférence. Exemples de commandes : |
||||
|
||||
- Segmentez tout dans une image : |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg |
||||
``` |
||||
|
||||
- Segmentez des objets spécifiques à l'aide de l'invitation de texte : |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "le chien jaune" |
||||
``` |
||||
|
||||
- Segmentez des objets dans un rectangle englobant (fournir les coordonnées du rectangle au format xywh) : |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]" |
||||
``` |
||||
|
||||
- Segmentez des objets à proximité de points spécifiques : |
||||
```shell |
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]" |
||||
``` |
||||
|
||||
De plus, vous pouvez essayer FastSAM via une [démonstration Colab](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) ou sur la [démonstration Web HuggingFace](https://huggingface.co/spaces/An-619/FastSAM) pour une expérience visuelle. |
||||
|
||||
## Citations et remerciements |
||||
|
||||
Nous tenons à remercier les auteurs de FastSAM pour leurs contributions importantes dans le domaine de la segmentation d'instances en temps réel : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{zhao2023fast, |
||||
title={Fast Segment Anything}, |
||||
author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang}, |
||||
year={2023}, |
||||
eprint={2306.12156}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Le document original FastSAM peut être consulté sur [arXiv](https://arxiv.org/abs/2306.12156). Les auteurs ont rendu leur travail accessible au public, et le code source peut être consulté sur [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). Nous apprécions leurs efforts pour faire avancer le domaine et rendre leur travail accessible à la communauté dans son ensemble. |
||||
@ -1,98 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explorez la gamme diversifiée de modèles de la famille YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS et RT-DETR pris en charge par Ultralytics. Commencez avec des exemples pour l'utilisation CLI et Python. |
||||
keywords: Ultralytics, documentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modèles, architectures, Python, CLI |
||||
--- |
||||
|
||||
# Modèles pris en charge par Ultralytics |
||||
|
||||
Bienvenue dans la documentation des modèles d'Ultralytics ! Nous offrons un soutien pour une large gamme de modèles, chacun étant adapté à des tâches spécifiques comme [la détection d'objets](../tasks/detect.md), [la segmentation d'instance](../tasks/segment.md), [la classification d'images](../tasks/classify.md), [l'estimation de pose](../tasks/pose.md), et [le suivi multi-objets](../modes/track.md). Si vous êtes intéressé à contribuer avec votre architecture de modèle à Ultralytics, consultez notre [Guide de Contribution](../../help/contributing.md). |
||||
|
||||
!!! Note "Remarque" |
||||
|
||||
🚧 Notre documentation dans différentes langues est actuellement en construction, et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏 |
||||
|
||||
## Modèles en vedette |
||||
|
||||
Voici quelques-uns des modèles clés pris en charge : |
||||
|
||||
1. **[YOLOv3](yolov3.md)** : La troisième itération de la famille de modèles YOLO, initialement par Joseph Redmon, connue pour ses capacités de détection d'objets en temps réel efficaces. |
||||
2. **[YOLOv4](yolov4.md)** : Une mise à jour native darknet de YOLOv3, publiée par Alexey Bochkovskiy en 2020. |
||||
3. **[YOLOv5](yolov5.md)** : Une version améliorée de l'architecture YOLO par Ultralytics, offrant de meilleures performances et compromis de vitesse par rapport aux versions précédentes. |
||||
4. **[YOLOv6](yolov6.md)** : Publié par [Meituan](https://about.meituan.com/) en 2022, et utilisé dans beaucoup de ses robots de livraison autonomes. |
||||
5. **[YOLOv7](yolov7.md)** : Modèles YOLO mis à jour publiés en 2022 par les auteurs de YOLOv4. |
||||
6. **[YOLOv8](yolov8.md) NOUVEAU 🚀**: La dernière version de la famille YOLO, présentant des capacités améliorées telles que la segmentation d'instance, l'estimation de pose/points clés et la classification. |
||||
7. **[Segment Anything Model (SAM)](sam.md)** : Le modèle Segment Anything Model (SAM) de Meta. |
||||
8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)** : MobileSAM pour applications mobiles, développé par l'Université de Kyung Hee. |
||||
9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)** : FastSAM par le Image & Video Analysis Group, Institute of Automation, Chinese Academy of Sciences. |
||||
10. **[YOLO-NAS](yolo-nas.md)** : Modèles de Recherche d'Architecture Neuronale YOLO (NAS). |
||||
11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)** : Modèles du Transformateur de Détection en Temps Réel (RT-DETR) de PaddlePaddle de Baidu. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/MWq1UxqTClU?si=nHAW-lYDzrz68jR0" |
||||
title="Lecteur vidéo YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Regardez :</strong> Exécutez les modèles YOLO d'Ultralytics en seulement quelques lignes de code. |
||||
</p> |
||||
|
||||
## Pour Commencer : Exemples d'Utilisation |
||||
|
||||
Cet exemple fournit des exemples simples d'entraînement et d'inférence YOLO. Pour une documentation complète sur ces [modes](../modes/index.md) et d'autres, consultez les pages de documentation [Prédire](../modes/predict.md), [Entraîner](../modes/train.md), [Val](../modes/val.md) et [Exporter](../modes/export.md). |
||||
|
||||
Notez que l'exemple ci-dessous concerne les modèles [Detect](../tasks/detect.md) YOLOv8 pour la détection d'objets. Pour des tâches supplémentaires prises en charge, voir les documentations [Segmenter](../tasks/segment.md), [Classifier](../tasks/classify.md) et [Poser](../tasks/pose.md). |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
|
||||
Des modèles pré-entraînés PyTorch `*.pt` ainsi que des fichiers de configuration `*.yaml` peuvent être passés aux classes `YOLO()`, `SAM()`, `NAS()` et `RTDETR()` pour créer une instance de modèle en Python : |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné sur COCO |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Afficher les informations du modèle (optionnel) |
||||
model.info() |
||||
|
||||
# Entraîner le modèle sur le jeu de données exemple COCO8 pendant 100 époques |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Exécuter l'inférence avec le modèle YOLOv8n sur l'image 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Des commandes CLI sont disponibles pour exécuter directement les modèles : |
||||
|
||||
```bash |
||||
# Charger un modèle YOLOv8n pré-entraîné sur COCO et l'entraîner sur le jeu de données exemple COCO8 pendant 100 époques |
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné sur COCO et exécuter l'inférence sur l'image 'bus.jpg' |
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Contribution de Nouveaux Modèles |
||||
|
||||
Vous êtes intéressé à contribuer votre modèle à Ultralytics ? Génial ! Nous sommes toujours ouverts à l'expansion de notre portefeuille de modèles. |
||||
|
||||
1. **Forkez le Référentiel** : Commencez par forker le [référentiel GitHub d'Ultralytics](https://github.com/ultralytics/ultralytics). |
||||
|
||||
2. **Clonez Votre Fork** : Clonez votre fork sur votre machine locale et créez une nouvelle branche pour travailler dessus. |
||||
|
||||
3. **Implémentez Votre Modèle** : Ajoutez votre modèle en suivant les normes et directives de codage fournies dans notre [Guide de Contribution](../../help/contributing.md). |
||||
|
||||
4. **Testez Rigoureusement** : Assurez-vous de tester votre modèle de manière rigoureuse, à la fois isolément et comme partie du pipeline. |
||||
|
||||
5. **Créez une Pull Request** : Une fois que vous êtes satisfait de votre modèle, créez une pull request au répertoire principal pour examen. |
||||
|
||||
6. **Revue de Code & Fusion** : Après examen, si votre modèle répond à nos critères, il sera fusionné dans le répertoire principal. |
||||
|
||||
Pour des étapes détaillées, consultez notre [Guide de Contribution](../../help/contributing.md). |
||||
@ -1,116 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: En savoir plus sur MobileSAM, son implémentation, la comparaison avec SAM d'origine, et comment le télécharger et le tester dans le cadre de l'environnement Ultralytics. Améliorez vos applications mobiles dès aujourd'hui. |
||||
keywords: MobileSAM, Ultralytics, SAM, applications mobiles, Arxiv, GPU, API, encodeur d'image, décodeur de masque, téléchargement de modèle, méthode de test |
||||
--- |
||||
|
||||
 |
||||
|
||||
# Segmenter N'importe Quoi sur Mobile (MobileSAM) |
||||
|
||||
Le document MobileSAM est maintenant disponible sur [arXiv](https://arxiv.org/pdf/2306.14289.pdf). |
||||
|
||||
Une démonstration de MobileSAM exécutée sur un processeur CPU est accessible via ce [lien de démonstration](https://huggingface.co/spaces/dhkim2810/MobileSAM). Les performances sur un CPU Mac i5 prennent environ 3 secondes. Sur la démo de Hugging Face, l'interface ainsi que les CPU moins performants contribuent à une réponse plus lente, mais cela continue de fonctionner efficacement. |
||||
|
||||
MobileSAM est implémenté dans divers projets, notamment [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling), et [Segment Anything en 3D](https://github.com/Jumpat/SegmentAnythingin3D). |
||||
|
||||
MobileSAM est entraîné sur un seul GPU avec un ensemble de données de 100 000 images (1% des images originales) en moins d'une journée. Le code de cet entraînement sera disponible à l'avenir. |
||||
|
||||
## Modèles Disponibles, Tâches Prises en Charge et Modes d'Utilisation |
||||
|
||||
Ce tableau présente les modèles disponibles avec leurs poids pré-entraînés spécifiques, les tâches qu'ils prennent en charge, et leur compatibilité avec les différents modes d'utilisation tels que [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Export](../modes/export.md), indiqués par les emojis ✅ pour les modes pris en charge et ❌ pour les modes non pris en charge. |
||||
|
||||
| Type de Modèle | Poids Pré-entraînés | Tâches Prises en Charge | Inférence | Validation | Entraînement | Export | |
||||
|----------------|---------------------|-------------------------------------------------|-----------|------------|--------------|--------| |
||||
| MobileSAM | `mobile_sam.pt` | [Segmentation d'Instances](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Passage de SAM à MobileSAM |
||||
|
||||
Étant donné que MobileSAM conserve le même pipeline que SAM d'origine, nous avons incorporé le pré-traitement, le post-traitement et toutes les autres interfaces de l'original. Par conséquent, ceux qui utilisent actuellement SAM d'origine peuvent passer à MobileSAM avec un effort minimal. |
||||
|
||||
MobileSAM a des performances comparables à celles de SAM d'origine et conserve le même pipeline à l'exception d'un changement dans l'encodeur d'image. Plus précisément, nous remplaçons l'encodeur d'image lourd original ViT-H (632M) par un encodeur Tiny-ViT plus petit (5M). Sur un seul GPU, MobileSAM fonctionne à environ 12 ms par image : 8 ms sur l'encodeur d'image et 4 ms sur le décodeur de masque. |
||||
|
||||
Le tableau suivant présente une comparaison des encodeurs d'image basés sur ViT : |
||||
|
||||
| Encodeur d'Image | SAM d'Origine | MobileSAM | |
||||
|------------------|---------------|-----------| |
||||
| Paramètres | 611M | 5M | |
||||
| Vitesse | 452 ms | 8 ms | |
||||
|
||||
SAM d'origine et MobileSAM utilisent tous deux le même décodeur de masque basé sur une instruction : |
||||
|
||||
| Décodeur de Masque | SAM d'Origine | MobileSAM | |
||||
|--------------------|---------------|-----------| |
||||
| Paramètres | 3.876M | 3.876M | |
||||
| Vitesse | 4 ms | 4 ms | |
||||
|
||||
Voici une comparaison du pipeline complet : |
||||
|
||||
| Pipeline Complet (Enc+Dec) | SAM d'Origine | MobileSAM | |
||||
|----------------------------|---------------|-----------| |
||||
| Paramètres | 615M | 9.66M | |
||||
| Vitesse | 456 ms | 12 ms | |
||||
|
||||
Les performances de MobileSAM et de SAM d'origine sont démontrées en utilisant à la fois un point et une boîte comme instructions. |
||||
|
||||
 |
||||
|
||||
 |
||||
|
||||
Avec ses performances supérieures, MobileSAM est environ 5 fois plus petit et 7 fois plus rapide que FastSAM actuel. Plus de détails sont disponibles sur la [page du projet MobileSAM](https://github.com/ChaoningZhang/MobileSAM). |
||||
|
||||
## Test de MobileSAM dans Ultralytics |
||||
|
||||
Tout comme SAM d'origine, nous proposons une méthode de test simple dans Ultralytics, comprenant des modes pour les instructions Point et Boîte. |
||||
|
||||
### Téléchargement du modèle |
||||
|
||||
Vous pouvez télécharger le modèle [ici](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt). |
||||
|
||||
### Instruction Point |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Chargement du modèle |
||||
model = SAM('mobile_sam.pt') |
||||
|
||||
# Prédiction d'un segment à partir d'une instruction Point |
||||
model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1]) |
||||
``` |
||||
|
||||
### Instruction Boîte |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Chargement du modèle |
||||
model = SAM('mobile_sam.pt') |
||||
|
||||
# Prédiction d'un segment à partir d'une instruction Boîte |
||||
model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709]) |
||||
``` |
||||
|
||||
Nous avons mis en œuvre `MobileSAM` et `SAM` en utilisant la même API. Pour plus d'informations sur l'utilisation, veuillez consulter la [page SAM](sam.md). |
||||
|
||||
## Citations et Remerciements |
||||
|
||||
Si vous trouvez MobileSAM utile dans vos travaux de recherche ou de développement, veuillez envisager de citer notre document : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{mobile_sam, |
||||
title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications}, |
||||
author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon}, |
||||
journal={arXiv preprint arXiv:2306.14289}, |
||||
year={2023} |
||||
} |
||||
@ -1,93 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Découvrez les fonctionnalités et les avantages de RT-DETR de Baidu, un détecteur d'objets en temps réel efficace et adaptable grâce aux Vision Transformers, incluant des modèles pré-entraînés. |
||||
keywords: RT-DETR, Baidu, Vision Transformers, détection d'objets, performance en temps réel, CUDA, TensorRT, sélection de requêtes informée par IoU, Ultralytics, API Python, PaddlePaddle |
||||
--- |
||||
|
||||
# RT-DETR de Baidu : un détecteur d'objets en temps réel basé sur les Vision Transformers |
||||
|
||||
## Présentation |
||||
|
||||
Le Real-Time Detection Transformer (RT-DETR), développé par Baidu, est un détecteur d'objets de pointe de bout en bout qui offre des performances en temps réel tout en maintenant une grande précision. Il exploite la puissance des Vision Transformers (ViT) pour traiter efficacement les caractéristiques multiscalaires en dissociant l'interaction intra-échelle et la fusion inter-échelles. RT-DETR est hautement adaptable, permettant un ajustement flexible de la vitesse d'inférence en utilisant différentes couches de décodeur sans nécessiter de nouvelle formation. Le modèle est performant sur des infrastructures accélérées telles que CUDA avec TensorRT, surpassant de nombreux autres détecteurs d'objets en temps réel. |
||||
|
||||
 |
||||
**Vue d'ensemble du RT-DETR de Baidu.** Le diagramme d'architecture du modèle RT-DETR montre les trois dernières étapes du réseau {S3, S4, S5} comme entrée de l'encodeur. L'encodeur hybride efficace transforme les caractéristiques multiscalaires en une séquence de caractéristiques d'image grâce à l'interaction à l'intérieur de l'échelle (AIFI - *Adeptation of Intra-scale Feature Interaction*) et au module de fusion inter-échelles (CCFM - *Cross-scale Context-aware Feature Fusion Module*). La sélection de requêtes informée par IoU est utilisée pour sélectionner un nombre fixe de caractéristiques d'image pour servir de requêtes d'objets initiales pour le décodeur. Enfin, le décodeur avec des têtes de prédictions auxiliaires optimise de manière itérative les requêtes d'objets pour générer des boîtes et des scores de confiance ([source](https://arxiv.org/pdf/2304.08069.pdf)). |
||||
|
||||
### Fonctionnalités principales |
||||
|
||||
- **Encodeur hybride efficace :** RT-DETR de Baidu utilise un encodeur hybride efficace qui traite les caractéristiques multiscalaires en dissociant l'interaction intra-échelle et la fusion inter-échelles. Cette conception unique basée sur les Vision Transformers réduit les coûts de calcul et permet une détection d'objets en temps réel. |
||||
- **Sélection de requêtes informée par IoU :** RT-DETR de Baidu améliore l'initialisation des requêtes d'objets en utilisant une sélection de requêtes informée par IoU. Cela permet au modèle de se concentrer sur les objets les plus pertinents de la scène, améliorant ainsi la précision de la détection. |
||||
- **Vitesse d'inférence adaptable :** RT-DETR de Baidu prend en charge des ajustements flexibles de la vitesse d'inférence en utilisant différentes couches de décodeur sans nécessiter de nouvelle formation. Cette adaptabilité facilite l'application pratique dans différents scénarios de détection d'objets en temps réel. |
||||
|
||||
## Modèles pré-entraînés |
||||
|
||||
L'API Python Ultralytics fournit des modèles pré-entraînés RT-DETR de PaddlePaddle avec différentes échelles : |
||||
|
||||
- RT-DETR-L : 53,0 % de précision moyenne (AP) sur COCO val2017, 114 images par seconde (FPS) sur GPU T4 |
||||
- RT-DETR-X : 54,8 % de précision moyenne (AP) sur COCO val2017, 74 images par seconde (FPS) sur GPU T4 |
||||
|
||||
## Exemples d'utilisation |
||||
|
||||
Cet exemple présente des exemples simples d'entraînement et d'inférence avec RT-DETRR. Pour une documentation complète sur ceux-ci et d'autres [modes](../modes/index.md), consultez les pages de documentation [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md). |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import RTDETR |
||||
|
||||
# Charger un modèle RT-DETR-l pré-entraîné sur COCO |
||||
model = RTDETR('rtdetr-l.pt') |
||||
|
||||
# Afficher des informations sur le modèle (facultatif) |
||||
model.info() |
||||
|
||||
# Entraîner le modèle sur l'ensemble de données d'exemple COCO8 pendant 100 époques |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Effectuer une inférence avec le modèle RT-DETR-l sur l'image 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Charger un modèle RT-DETR-l pré-entraîné sur COCO et l'entraîner sur l'ensemble de données d'exemple COCO8 pendant 100 époques |
||||
yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Charger un modèle RT-DETR-l pré-entraîné sur COCO et effectuer une inférence sur l'image 'bus.jpg' |
||||
yolo predict model=rtdetr-l.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Tâches et modes pris en charge |
||||
|
||||
Ce tableau présente les types de modèles, les poids pré-entraînés spécifiques, les tâches prises en charge par chaque modèle et les différents modes ([Train](../modes/train.md), [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)) pris en charge, indiqués par des emojis ✅. |
||||
|
||||
| Type de modèle | Poids pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Export | |
||||
|---------------------|---------------------|------------------------------------------|-----------|------------|--------------|--------| |
||||
| RT-DETR Large | `rtdetr-l.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| RT-DETR Extra-Large | `rtdetr-x.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
## Citations et Remerciements |
||||
|
||||
Si vous utilisez RT-DETR de Baidu dans votre travail de recherche ou de développement, veuillez citer l'[article original](https://arxiv.org/abs/2304.08069) : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{lv2023detrs, |
||||
title={DETRs Beat YOLOs on Real-time Object Detection}, |
||||
author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu}, |
||||
year={2023}, |
||||
eprint={2304.08069}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Nous tenons à remercier Baidu et l'équipe [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) pour la création et la maintenance de cette précieuse ressource pour la communauté de la vision par ordinateur. Leur contribution au domaine avec le développement du détecteur d'objets en temps réel basé sur les Vision Transformers, RT-DETR, est grandement appréciée. |
||||
|
||||
*keywords: RT-DETR, Transformer, ViT, Vision Transformers, RT-DETR de Baidu, PaddlePaddle, Modèles PaddlePaddle RT-DETR pré-entraînés, utilisation de RT-DETR de Baidu, API Python Ultralytics, détection d'objets en temps réel* |
||||
@ -1,226 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Découvrez le modèle Segment Anything (SAM) de pointe d'Ultralytics permettant la segmentation d'images en temps réel. Apprenez-en davantage sur sa segmentation promptable, ses performances hors échantillon et comment l'utiliser. |
||||
keywords: Ultralytics, segmentation d'image, Segment Anything Model, SAM, SA-1B dataset, performances en temps réel, transfert hors échantillon, détection d'objets, analyse d'images, apprentissage automatique |
||||
--- |
||||
|
||||
# Segment Anything Model (SAM) |
||||
|
||||
Bienvenue à la pointe de la segmentation d'image avec le modèle Segment Anything, ou SAM. Ce modèle révolutionnaire a changé la donne en introduisant la segmentation d'image promptable avec des performances en temps réel, établissant de nouvelles normes dans le domaine. |
||||
|
||||
## Introduction à SAM : Le modèle Segment Anything |
||||
|
||||
Le modèle Segment Anything, ou SAM, est un modèle de segmentation d'image de pointe qui permet une segmentation promptable, offrant une polyvalence inégalée dans les tâches d'analyse d'image. SAM forme le cœur de l'initiative Segment Anything, un projet innovant qui introduit un modèle, une tâche et un jeu de données novateurs pour la segmentation d'images. |
||||
|
||||
La conception avancée de SAM lui permet de s'adapter à de nouvelles distributions et tâches d'images sans connaissance préalable, une fonctionnalité connue sous le nom de transfert hors échantillon. Entraîné sur le vaste ensemble de données [SA-1B](https://ai.facebook.com/datasets/segment-anything/), qui contient plus d'un milliard de masques répartis sur 11 millions d'images soigneusement sélectionnées, SAM a affiché des performances hors échantillon impressionnantes, dépassant les résultats entièrement supervisés précédents dans de nombreux cas. |
||||
|
||||
 |
||||
Exemple d'images avec des masques superposés provenant de notre nouveau jeu de données, SA-1B. SA-1B contient 11 millions d'images diverses, haute résolution, autorisées et protégeant la vie privée, ainsi que 1,1 milliard de masques de segmentation de haute qualité. Ces masques ont été annotés entièrement automatiquement par SAM, et comme le confirment des évaluations humaines et de nombreux tests, leur qualité et leur diversité sont élevées. Les images sont regroupées par nombre de masques par image pour la visualisation (il y a environ 100 masques par image en moyenne). |
||||
|
||||
## Caractéristiques clés du modèle Segment Anything (SAM) |
||||
|
||||
- **Tâche de segmentation promptable :** SAM a été conçu en gardant à l'esprit une tâche de segmentation promptable, ce qui lui permet de générer des masques de segmentation valides à partir de n'importe quelle indication donnée, telle que des indices spatiaux ou des indices textuels identifiant un objet. |
||||
- **Architecture avancée :** Le modèle Segment Anything utilise un puissant encodeur d'images, un encodeur de prompt et un décodeur de masques léger. Cette architecture unique permet une invitation flexible, un calcul de masques en temps réel et une prise en compte de l'ambiguïté dans les tâches de segmentation. |
||||
- **Le jeu de données SA-1B :** Introduit par le projet Segment Anything, le jeu de données SA-1B comprend plus d'un milliard de masques sur 11 millions d'images. En tant que plus grand jeu de données de segmentation à ce jour, il offre à SAM une source de données d'entraînement diversifiée et à grande échelle. |
||||
- **Performances hors échantillon :** SAM affiche des performances hors échantillon exceptionnelles dans diverses tâches de segmentation, ce qui en fait un outil prêt à l'emploi pour des applications diverses nécessitant un minimum d'ingénierie de prompt. |
||||
|
||||
Pour une analyse approfondie du modèle Segment Anything et du jeu de données SA-1B, veuillez visiter le [site web Segment Anything](https://segment-anything.com) et consulter l'article de recherche [Segment Anything](https://arxiv.org/abs/2304.02643). |
||||
|
||||
## Modèles disponibles, tâches prises en charge et modes d'exploitation |
||||
|
||||
Ce tableau présente les modèles disponibles avec leurs poids pré-entraînés spécifiques, les tâches qu'ils prennent en charge et leur compatibilité avec différents modes d'exploitation tels que [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Exportation](../modes/export.md), indiqués par des emojis ✅ pour les modes pris en charge et des emojis ❌ pour les modes non pris en charge. |
||||
|
||||
| Type de modèle | Poids pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Exportation | |
||||
|----------------|---------------------|------------------------------------------------|-----------|------------|--------------|-------------| |
||||
| SAM de base | `sam_b.pt` | [Segmentation d'instance](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
| SAM large | `sam_l.pt` | [Segmentation d'instance](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ | |
||||
|
||||
## Comment utiliser SAM : Polyvalence et puissance dans la segmentation d'images |
||||
|
||||
Le modèle Segment Anything peut être utilisé pour une multitude de tâches secondaires qui vont au-delà de ses données d'entraînement. Cela comprend la détection des contours, la génération de propositions d'objets, la segmentation d'instances et la prédiction préliminaire texte-à-masque. Grâce à l'ingénierie de prompts, SAM peut s'adapter rapidement à de nouvelles tâches et distributions de données de manière sans apprentissage, ce qui en fait un outil polyvalent et puissant pour tous vos besoins en matière de segmentation d'images. |
||||
|
||||
### Exemple de prédiction SAM |
||||
|
||||
!!! Example "Segmentation avec des prompts" |
||||
|
||||
Segmenter l'image avec des prompts donnés. |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Charger un modèle |
||||
model = SAM('sam_b.pt') |
||||
|
||||
# Afficher les informations sur le modèle (facultatif) |
||||
model.info() |
||||
|
||||
# Exécuter l'inférence avec un prompt de zones de délimitation |
||||
model('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709]) |
||||
|
||||
# Exécuter l'inférence avec un prompt de points |
||||
model('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1]) |
||||
``` |
||||
|
||||
!!! Example "Segmenter tout" |
||||
|
||||
Segmenter toute l'image. |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import SAM |
||||
|
||||
# Charger un modèle |
||||
model = SAM('sam_b.pt') |
||||
|
||||
# Afficher les informations sur le modèle (facultatif) |
||||
model.info() |
||||
|
||||
# Exécuter l'inférence |
||||
model('path/to/image.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
```bash |
||||
# Exécuter l'inférence avec un modèle SAM |
||||
yolo predict model=sam_b.pt source=path/to/image.jpg |
||||
``` |
||||
|
||||
- La logique ici est de segmenter toute l'image si vous ne passez aucun prompt (bboxes/points/masks). |
||||
|
||||
!!! Example "Exemple SAMPredictor" |
||||
|
||||
De cette manière, vous pouvez définir l'image une fois et exécuter l'inférence des prompts plusieurs fois sans exécuter l'encodeur d'image plusieurs fois. |
||||
|
||||
=== "Inférence avec des prompts" |
||||
|
||||
```python |
||||
from ultralytics.models.sam import Predictor as SAMPredictor |
||||
|
||||
# Créer un SAMPredictor |
||||
overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt") |
||||
predictor = SAMPredictor(overrides=overrides) |
||||
|
||||
# Définir l'image |
||||
predictor.set_image("ultralytics/assets/zidane.jpg") # définir avec un fichier image |
||||
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # définir avec np.ndarray |
||||
results = predictor(bboxes=[439, 437, 524, 709]) |
||||
results = predictor(points=[900, 370], labels=[1]) |
||||
|
||||
# Réinitialiser l'image |
||||
predictor.reset_image() |
||||
``` |
||||
|
||||
Segmenter toute l'image avec des arguments supplémentaires. |
||||
|
||||
=== "Segmenter tout" |
||||
|
||||
```python |
||||
from ultralytics.models.sam import Predictor as SAMPredictor |
||||
|
||||
# Créer un SAMPredictor |
||||
overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt") |
||||
predictor = SAMPredictor(overrides=overrides) |
||||
|
||||
# Segmenter avec des arguments supplémentaires |
||||
results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64) |
||||
``` |
||||
|
||||
- Plus d'arguments supplémentaires pour `Segmenter tout` voir la référence [`Predictor/generate`](../../../reference/models/sam/predict.md). |
||||
|
||||
## Comparaison de SAM avec YOLOv8 |
||||
|
||||
Nous comparons ici le plus petit modèle SAM de Meta, SAM-b, avec le plus petit modèle de segmentation d'Ultralytics, [YOLOv8n-seg](../tasks/segment.md) : |
||||
|
||||
| Modèle | Taille | Paramètres | Vitesse (CPU) | |
||||
|--------------------------------------------------------------|-----------------------------------|-----------------------------|-------------------------------------| |
||||
| SAM-b - Meta's SAM-b | 358 Mo | 94,7 M | 51096 ms/im | |
||||
| [MobileSAM](mobile-sam.md) | 40,7 Mo | 10,1 M | 46122 ms/im | |
||||
| [FastSAM-s](fast-sam.md) with YOLOv8 backbone | 23,7 Mo | 11,8 M | 115 ms/im | |
||||
| YOLOv8n-seg - Ultralytics [YOLOv8n-seg](../tasks/segment.md) | **6,7 Mo** (53,4 fois plus petit) | **3,4 M** (27,9 fois moins) | **59 ms/im** (866 fois plus rapide) | |
||||
|
||||
Cette comparaison montre les différences d'ordre de grandeur dans les tailles et les vitesses des modèles. Alors que SAM présente des fonctionnalités uniques pour la segmentation automatique, il ne rivalise pas directement avec les modèles de segmentation YOLOv8, qui sont plus petits, plus rapides et plus efficaces. |
||||
|
||||
Tests effectués sur un MacBook Apple M2 de 2023 avec 16 Go de RAM. Pour reproduire ce test : |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics import FastSAM, SAM, YOLO |
||||
|
||||
# Profiler SAM-b |
||||
modèle = SAM('sam_b.pt') |
||||
modèle.info() |
||||
modèle('ultralytics/assets') |
||||
|
||||
# Profiler MobileSAM |
||||
modèle = SAM('mobile_sam.pt') |
||||
modèle.info() |
||||
modèle('ultralytics/assets') |
||||
|
||||
# Profiler FastSAM-s |
||||
modèle = FastSAM('FastSAM-s.pt') |
||||
modèle.info() |
||||
modèle('ultralytics/assets') |
||||
|
||||
# Profiler YOLOv8n-seg |
||||
modèle = YOLO('yolov8n-seg.pt') |
||||
modèle.info() |
||||
modèle('ultralytics/assets') |
||||
``` |
||||
|
||||
## Annotation automatique : Un moyen rapide d'obtenir des jeux de données de segmentation |
||||
|
||||
L'annotation automatique est une fonctionnalité clé de SAM, permettant aux utilisateurs de générer un [jeu de données de segmentation](https://docs.ultralytics.com/datasets/segment) à l'aide d'un modèle de détection pré-entraîné. Cette fonctionnalité permet une annotation rapide et précise d'un grand nombre d'images, en contournant la nécessité d'une annotation manuelle chronophage. |
||||
|
||||
### Générez votre jeu de données de segmentation à l'aide d'un modèle de détection |
||||
|
||||
Pour annoter automatiquement votre jeu de données avec le framework Ultralytics, utilisez la fonction `auto_annotate` comme indiqué ci-dessous : |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
```python |
||||
from ultralytics.data.annotator import auto_annotate |
||||
|
||||
auto_annotate(data="path/to/images", det_model="yolov8x.pt", sam_model='sam_b.pt') |
||||
``` |
||||
|
||||
| Argument | Type | Description | Default | |
||||
|------------|----------------------|------------------------------------------------------------------------------------------------------------------------|--------------| |
||||
| data | str | Chemin d'accès à un dossier contenant les images à annoter. | | |
||||
| det_model | str, optionnel | Modèle de détection pré-entraîné YOLO. Par défaut, 'yolov8x.pt'. | 'yolov8x.pt' | |
||||
| sam_model | str, optionnel | Modèle de segmentation pré-entraîné SAM. Par défaut, 'sam_b.pt'. | 'sam_b.pt' | |
||||
| device | str, optionnel | Appareil sur lequel exécuter les modèles. Par défaut, une chaîne vide (CPU ou GPU, si disponible). | | |
||||
| output_dir | str, None, optionnel | Répertoire pour enregistrer les résultats annotés. Par défaut, un dossier 'labels' dans le même répertoire que 'data'. | None | |
||||
|
||||
La fonction `auto_annotate` prend en compte le chemin de vos images, avec des arguments optionnels pour spécifier les modèles de détection et de segmentation SAM pré-entraînés, l'appareil sur lequel exécuter les modèles et le répertoire de sortie pour enregistrer les résultats annotés. |
||||
|
||||
L'annotation automatique avec des modèles pré-entraînés peut réduire considérablement le temps et les efforts nécessaires pour créer des jeux de données de segmentation de haute qualité. Cette fonctionnalité est particulièrement bénéfique pour les chercheurs et les développeurs travaillant avec de grandes collections d'images, car elle leur permet de se concentrer sur le développement et l'évaluation des modèles plutôt que sur l'annotation manuelle. |
||||
|
||||
## Citations et remerciements |
||||
|
||||
Si vous trouvez SAM utile dans vos travaux de recherche ou de développement, veuillez envisager de citer notre article : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{kirillov2023segment, |
||||
title={Segment Anything}, |
||||
author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollár and Ross Girshick}, |
||||
year={2023}, |
||||
eprint={2304.02643}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Nous tenons à exprimer notre gratitude à Meta AI pour la création et la maintenance de cette ressource précieuse pour la communauté de la vision par ordinateur. |
||||
|
||||
*keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, segmentation d'image, segmentation promptable, performances hors échantillon, jeu de données SA-1B, architecture avancée, annotation automatique, Ultralytics, modèles pré-entraînés, SAM de base, SAM large, segmentation d'instance, vision par ordinateur, IA, intelligence artificielle, apprentissage automatique, annotation de données, masques de segmentation, modèle de détection, modèle de détection YOLO, bibtex, Meta AI.* |
||||
@ -1,121 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Découvrez une documentation détaillée sur YOLO-NAS, un modèle de détection d'objets supérieur. Apprenez-en davantage sur ses fonctionnalités, les modèles pré-entraînés, son utilisation avec l'API Python d'Ultralytics, et bien plus encore. |
||||
keywords: YOLO-NAS, Deci AI, détection d'objets, apprentissage profond, recherche architecturale neuronale, API Python d'Ultralytics, modèle YOLO, modèles pré-entraînés, quantification, optimisation, COCO, Objects365, Roboflow 100 |
||||
--- |
||||
|
||||
# YOLO-NAS |
||||
|
||||
## Aperçu |
||||
|
||||
Développé par Deci AI, YOLO-NAS est un modèle de détection d'objets révolutionnaire. Il est le fruit d'une technologie avancée de recherche architecturale neuronale, minutieusement conçu pour pallier les limitations des précédents modèles YOLO. Avec des améliorations significatives en matière de prise en charge de la quantification et de compromis entre précision et latence, YOLO-NAS représente une avancée majeure en matière de détection d'objets. |
||||
|
||||
 |
||||
**Aperçu de YOLO-NAS**. YOLO-NAS utilise des blocs adaptés à la quantification et une quantification sélective pour des performances optimales. Le modèle, une fois converti en version quantifiée INT8, présente une baisse de précision minimale, ce qui constitue une amélioration significative par rapport aux autres modèles. Ces avancées aboutissent à une architecture supérieure offrant des capacités de détection d'objets inégalées et des performances exceptionnelles. |
||||
|
||||
### Fonctionnalités clés |
||||
|
||||
- **Bloc de base compatible avec la quantification:** YOLO-NAS introduit un nouveau bloc de base adapté à la quantification, ce qui permet de pallier l'une des principales limitations des précédents modèles YOLO. |
||||
- **Entraînement sophistiqué et quantification:** YOLO-NAS utilise des schémas d'entraînement avancés et une quantification après l'entraînement pour améliorer les performances. |
||||
- **Optimisation AutoNAC et pré-entraînement:** YOLO-NAS utilise l'optimisation AutoNAC et est pré-entraîné sur des ensembles de données renommés tels que COCO, Objects365 et Roboflow 100. Ce pré-entraînement le rend extrêmement adapté aux tâches de détection d'objets ultérieures dans des environnements de production. |
||||
|
||||
## Modèles pré-entraînés |
||||
|
||||
Découvrez la puissance de la détection d'objets de nouvelle génération avec les modèles YOLO-NAS pré-entraînés fournis par Ultralytics. Ces modèles sont conçus pour offrir des performances exceptionnelles en termes de vitesse et de précision. Choisissez parmi une variété d'options adaptées à vos besoins spécifiques : |
||||
|
||||
| Modèle | mAP | Latence (ms) | |
||||
|------------------|-------|--------------| |
||||
| YOLO-NAS S | 47.5 | 3.21 | |
||||
| YOLO-NAS M | 51.55 | 5.85 | |
||||
| YOLO-NAS L | 52.22 | 7.87 | |
||||
| YOLO-NAS S INT-8 | 47.03 | 2.36 | |
||||
| YOLO-NAS M INT-8 | 51.0 | 3.78 | |
||||
| YOLO-NAS L INT-8 | 52.1 | 4.78 | |
||||
|
||||
Chaque variante de modèle est conçue pour offrir un équilibre entre la précision moyenne (mAP) et la latence, vous permettant ainsi d'optimiser vos tâches de détection d'objets en termes de performance et de vitesse. |
||||
|
||||
## Exemples d'utilisation |
||||
|
||||
Ultralytics a rendu les modèles YOLO-NAS faciles à intégrer dans vos applications Python grâce à notre package Python `ultralytics`. Le package fournit une interface conviviale pour simplifier le processus. |
||||
|
||||
Les exemples suivants montrent comment utiliser les modèles YOLO-NAS avec le package `ultralytics` pour l'inférence et la validation : |
||||
|
||||
### Exemples d'inférence et de validation |
||||
|
||||
Dans cet exemple, nous validons YOLO-NAS-s sur l'ensemble de données COCO8. |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
Cet exemple fournit un code simple pour l'inférence et la validation de YOLO-NAS. Pour gérer les résultats de l'inférence, consultez le mode [Predict](../modes/predict.md). Pour utiliser YOLO-NAS avec des modes supplémentaires, consultez [Val](../modes/val.md) et [Export](../modes/export.md). L'entraînement n'est pas pris en charge pour YOLO-NAS avec le package `ultralytics`. |
||||
|
||||
=== "Python" |
||||
|
||||
Il est possible de passer des modèles pré-entraînés `*.pt` de PyTorch à la classe `NAS()` pour créer une instance de modèle en Python : |
||||
|
||||
```python |
||||
from ultralytics import NAS |
||||
|
||||
# Charger un modèle YOLO-NAS-s pré-entraîné sur COCO |
||||
model = NAS('yolo_nas_s.pt') |
||||
|
||||
# Afficher les informations sur le modèle (facultatif) |
||||
model.info() |
||||
|
||||
# Valider le modèle sur l'ensemble de données COCO8 |
||||
results = model.val(data='coco8.yaml') |
||||
|
||||
# Effectuer une inférence avec le modèle YOLO-NAS-s sur l'image 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Des commandes CLI sont disponibles pour exécuter directement les modèles : |
||||
|
||||
```bash |
||||
# Charger un modèle YOLO-NAS-s pré-entraîné sur COCO et valider ses performances sur l'ensemble de données COCO8 |
||||
yolo val model=yolo_nas_s.pt data=coco8.yaml |
||||
|
||||
# Charger un modèle YOLO-NAS-s pré-entraîné sur COCO et effectuer une inférence sur l'image 'bus.jpg' |
||||
yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Tâches et modes pris en charge |
||||
|
||||
Nous proposons trois variantes des modèles YOLO-NAS : Small (s), Medium (m) et Large (l). Chaque variante est conçue pour répondre à des besoins computationnels et de performances différents : |
||||
|
||||
- **YOLO-NAS-s** : Optimisé pour les environnements où les ressources computationnelles sont limitées mais l'efficacité est primordiale. |
||||
- **YOLO-NAS-m** : Offre une approche équilibrée, adaptée à la détection d'objets polyvalente avec une précision accrue. |
||||
- **YOLO-NAS-l** : Adapté aux scénarios nécessitant la plus haute précision, où les ressources computationnelles sont moins contraignantes. |
||||
|
||||
Voici un aperçu détaillé de chaque modèle, comprenant des liens vers leurs poids pré-entraînés, les tâches qu'ils prennent en charge et leur compatibilité avec différents modes opérationnels. |
||||
|
||||
| Type de modèle | Poids pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Export | |
||||
|----------------|-----------------------------------------------------------------------------------------------|------------------------------------------|-----------|------------|--------------|--------| |
||||
| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_s.pt) | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_m.pt) | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_l.pt) | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ | |
||||
|
||||
## Citations et remerciements |
||||
|
||||
Si vous utilisez YOLO-NAS dans vos travaux de recherche ou de développement, veuillez citer SuperGradients : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{supergradients, |
||||
doi = {10.5281/ZENODO.7789328}, |
||||
url = {https://zenodo.org/record/7789328}, |
||||
author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}}, |
||||
title = {Super-Gradients}, |
||||
publisher = {GitHub}, |
||||
journal = {GitHub repository}, |
||||
year = {2021}, |
||||
} |
||||
``` |
||||
|
||||
Nous exprimons notre gratitude à l'équipe [Super-Gradients](https://github.com/Deci-AI/super-gradients/) de Deci AI pour ses efforts dans la création et la maintenance de cette précieuse ressource pour la communauté de la vision par ordinateur. Nous sommes convaincus que YOLO-NAS, avec son architecture innovante et ses capacités de détection d'objets supérieures, deviendra un outil essentiel pour les développeurs et les chercheurs. |
||||
|
||||
*keywords: YOLO-NAS, Deci AI, détection d'objets, apprentissage profond, recherche architecturale neuronale, API Python d'Ultralytics, modèle YOLO, SuperGradients, modèles pré-entraînés, bloc de base compatible avec la quantification, schémas d'entraînement avancés, quantification après l'entraînement, optimisation AutoNAC, COCO, Objects365, Roboflow 100* |
||||
@ -1,98 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Obtenez un aperçu des modèles YOLOv3, YOLOv3-Ultralytics et YOLOv3u. Apprenez-en davantage sur leurs fonctionnalités clés, leur utilisation et les tâches prises en charge pour la détection d'objets. |
||||
keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Détection d'objets, Inférence, Entraînement, Ultralytics |
||||
--- |
||||
|
||||
# YOLOv3, YOLOv3-Ultralytics et YOLOv3u |
||||
|
||||
## Aperçu |
||||
|
||||
Ce document présente un aperçu de trois modèles de détection d'objets étroitement liés, à savoir [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) et [YOLOv3u](https://github.com/ultralytics/ultralytics). |
||||
|
||||
1. **YOLOv3**: Il s'agit de la troisième version de l'algorithme de détection d'objets You Only Look Once (YOLO). Initiée par Joseph Redmon, YOLOv3 a amélioré ses prédécesseurs en introduisant des fonctionnalités telles que des prédictions à plusieurs échelles et trois tailles différentes de noyaux de détection. |
||||
|
||||
2. **YOLOv3-Ultralytics**: Il s'agit de l'implémentation par Ultralytics du modèle YOLOv3. Il reproduit l'architecture d'origine de YOLOv3 et offre des fonctionnalités supplémentaires, telles que la prise en charge de plusieurs modèles pré-entraînés et des options de personnalisation plus faciles. |
||||
|
||||
3. **YOLOv3u**: Il s'agit d'une version mise à jour de YOLOv3-Ultralytics qui intègre la nouvelle tête de détection sans ancrage et sans objectivité utilisée dans les modèles YOLOv8. YOLOv3u conserve la même architecture de base et de cou de YOLOv3, mais avec la nouvelle tête de détection de YOLOv8. |
||||
|
||||
 |
||||
|
||||
## Caractéristiques clés |
||||
|
||||
- **YOLOv3**: A introduit l'utilisation de trois échelles différentes pour la détection, en tirant parti de trois tailles différentes de noyaux de détection : 13x13, 26x26 et 52x52. Cela a considérablement amélioré la précision de la détection pour les objets de différentes tailles. De plus, YOLOv3 a ajouté des fonctionnalités telles que des prédictions multi-étiquettes pour chaque boîte englobante et un meilleur réseau d'extraction de caractéristiques. |
||||
|
||||
- **YOLOv3-Ultralytics**: L'implémentation d'Ultralytics de YOLOv3 offre les mêmes performances que le modèle d'origine, mais propose également un support supplémentaire pour plus de modèles pré-entraînés, des méthodes d'entraînement supplémentaires et des options de personnalisation plus faciles. Cela le rend plus polyvalent et convivial pour les applications pratiques. |
||||
|
||||
- **YOLOv3u**: Ce modèle mis à jour intègre la nouvelle tête de détection sans ancrage et sans objectivité de YOLOv8. En éliminant le besoin de boîtes d'ancrage prédéfinies et de scores d'objectivité, cette conception de tête de détection peut améliorer la capacité du modèle à détecter des objets de différentes tailles et formes. Cela rend YOLOv3u plus robuste et précis pour les tâches de détection d'objets. |
||||
|
||||
## Tâches et modes pris en charge |
||||
|
||||
Les modèles de la série YOLOv3, notamment YOLOv3, YOLOv3-Ultralytics et YOLOv3u, sont spécialement conçus pour les tâches de détection d'objets. Ces modèles sont réputés pour leur efficacité dans divers scénarios réels, alliant précision et rapidité. Chaque variante propose des fonctionnalités et des optimisations uniques, les rendant adaptés à une gamme d'applications. |
||||
|
||||
Les trois modèles prennent en charge un ensemble complet de modes, garantissant ainsi leur polyvalence à différentes étapes du déploiement et du développement du modèle. Ces modes comprennent [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Export](../modes/export.md), offrant aux utilisateurs un ensemble complet d'outils pour une détection d'objets efficace. |
||||
|
||||
| Type de modèle | Tâches prises en charge | Inférence | Validation | Entraînement | Export | |
||||
|--------------------|------------------------------------------|-----------|------------|--------------|--------| |
||||
| YOLOv3 | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv3-Ultralytics | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv3u | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Ce tableau offre un aperçu rapide des capacités de chaque variante de YOLOv3, mettant en évidence leur polyvalence et leur pertinence pour diverses tâches et modes opérationnels dans les flux de travail de détection d'objets. |
||||
|
||||
## Exemples d'utilisation |
||||
|
||||
Cet exemple présente des exemples simples d'entraînement et d'inférence de YOLOv3. Pour une documentation complète sur ces exemples et d'autres [modes](../modes/index.md), consultez les pages de documentation sur [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md). |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
|
||||
Les modèles pré-entraînés PyTorch `*.pt`, ainsi que les fichiers de configuration `*.yaml`, peuvent être transmis à la classe `YOLO()` pour créer une instance de modèle en Python : |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv3n pré-entraîné avec COCO |
||||
model = YOLO('yolov3n.pt') |
||||
|
||||
# Afficher les informations sur le modèle (facultatif) |
||||
model.info() |
||||
|
||||
# Entraîner le modèle sur l'ensemble de données d'exemple COCO8 pendant 100 époques |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Exécuter l'inférence avec le modèle YOLOv3n sur l'image 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Des commandes CLI sont disponibles pour exécuter directement les modèles : |
||||
|
||||
```bash |
||||
# Charger un modèle YOLOv3n pré-entraîné avec COCO et l'entraîner sur l'ensemble de données d'exemple COCO8 pendant 100 époques |
||||
yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Charger un modèle YOLOv3n pré-entraîné avec COCO et exécuter l'inférence sur l'image 'bus.jpg' |
||||
yolo predict model=yolov3n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Citations et remerciements |
||||
|
||||
Si vous utilisez YOLOv3 dans le cadre de vos recherches, veuillez citer les articles originaux sur YOLO et le référentiel YOLOv3 d'Ultralytics : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{redmon2018yolov3, |
||||
title={YOLOv3: An Incremental Improvement}, |
||||
author={Redmon, Joseph and Farhadi, Ali}, |
||||
journal={arXiv preprint arXiv:1804.02767}, |
||||
year={2018} |
||||
} |
||||
``` |
||||
|
||||
Merci à Joseph Redmon et Ali Farhadi pour le développement du YOLOv3 original. |
||||
@ -1,71 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Découvrez notre guide détaillé sur YOLOv4, un détecteur d'objets en temps réel de pointe. Comprenez ses points forts architecturaux, ses fonctionnalités innovantes et des exemples d'application. |
||||
keywords: ultralytics, YOLOv4, détection d'objets, réseau neuronal, détection en temps réel, détecteur d'objets, apprentissage automatique |
||||
--- |
||||
|
||||
# YOLOv4: Détection d'Objets Rapide et Précise |
||||
|
||||
Bienvenue sur la page de documentation d'Ultralytics pour YOLOv4, un détecteur d'objets en temps réel de pointe lancé en 2020 par Alexey Bochkovskiy sur [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). YOLOv4 est conçu pour offrir un équilibre optimal entre vitesse et précision, en en faisant un excellent choix pour de nombreuses applications. |
||||
|
||||
 |
||||
**Schéma d'architecture de YOLOv4**. Présentant la conception détaillée du réseau de YOLOv4, comprenant les composants backbone, neck et head, ainsi que leurs couches interconnectées pour une détection d'objets en temps réel optimale. |
||||
|
||||
## Introduction |
||||
|
||||
YOLOv4 signifie You Only Look Once version 4. Il s'agit d'un modèle de détection d'objets en temps réel développé pour remédier aux limitations des versions précédentes de YOLO comme [YOLOv3](yolov3.md) et d'autres modèles de détection d'objets. Contrairement à d'autres détecteurs d'objets basés sur des réseaux neuronaux convolutifs (CNN), YOLOv4 n'est pas seulement applicable aux systèmes de recommandation, mais aussi à la gestion de processus autonomes et à la réduction de l'entrée humaine. Son utilisation sur des unités de traitement graphique (GPU) conventionnelles permet une utilisation massive à un prix abordable, et il est conçu pour fonctionner en temps réel sur un GPU conventionnel tout en ne nécessitant qu'un seul de ces GPU pour l'entraînement. |
||||
|
||||
## Architecture |
||||
|
||||
YOLOv4 utilise plusieurs fonctionnalités innovantes qui travaillent ensemble pour optimiser ses performances. Celles-ci incluent les connexions résiduelles pondérées (WRC), les connexions partielles à travers les étapes (CSP), la normalisation mini-batch traversée (CmBN), l'entraînement auto-antagoniste (SAT), l'activation Mish, l'augmentation des données en mosaïque, la régularisation DropBlock et la perte CIoU. Ces fonctionnalités sont combinées pour obtenir des résultats de pointe. |
||||
|
||||
Un détecteur d'objets typique est composé de plusieurs parties, notamment l'entrée, le backbone, le neck et le head. Le backbone de YOLOv4 est pré-entraîné sur ImageNet et est utilisé pour prédire les classes et les boîtes englobantes des objets. Le backbone peut provenir de plusieurs modèles, notamment VGG, ResNet, ResNeXt ou DenseNet. La partie "neck" du détecteur est utilisée pour collecter des cartes de caractéristiques à partir de différentes étapes et comprend généralement plusieurs chemins "bottom-up" et plusieurs chemins "top-down". La partie "head" est ce qui est utilisé pour faire les détections et classifications finales des objets. |
||||
|
||||
## Ensemble de Bonus |
||||
|
||||
YOLOv4 utilise également des méthodes appelées "ensemble de bonus", qui sont des techniques permettant d'améliorer la précision du modèle lors de l'entraînement sans augmenter le coût de l'inférence. L'augmentation de données est une technique commune de l'ensemble de bonus utilisée dans la détection d'objets, qui augmente la variabilité des images d'entrée pour améliorer la robustesse du modèle. Quelques exemples d'augmentation de données incluent les distorsions photométriques (ajustement de la luminosité, du contraste, de la teinte, de la saturation et du bruit d'une image) et les distorsions géométriques (ajout d'échelle aléatoire, de recadrage, de retournement et de rotation). Ces techniques aident le modèle à mieux généraliser à différents types d'images. |
||||
|
||||
## Fonctionnalités et Performances |
||||
|
||||
YOLOv4 est conçu pour une vitesse et une précision optimales dans la détection d'objets. L'architecture de YOLOv4 comprend CSPDarknet53 en tant que backbone, PANet en tant que neck et YOLOv3 en tant que detection head. Ce design permet à YOLOv4 de réaliser une détection d'objets à une vitesse impressionnante, ce qui le rend adapté aux applications en temps réel. YOLOv4 excelle également en précision, atteignant des résultats de pointe dans les benchmarks de détection d'objets. |
||||
|
||||
## Exemples d'Utilisation |
||||
|
||||
Au moment de la rédaction de ce document, Ultralytics ne prend pas en charge les modèles YOLOv4. Par conséquent, les utilisateurs intéressés par l'utilisation de YOLOv4 devront consulter directement le référentiel GitHub de YOLOv4 pour les instructions d'installation et d'utilisation. |
||||
|
||||
Voici un bref aperçu des étapes typiques que vous pourriez suivre pour utiliser YOLOv4 : |
||||
|
||||
1. Rendez-vous sur le référentiel GitHub de YOLOv4 : [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). |
||||
|
||||
2. Suivez les instructions fournies dans le fichier README pour l'installation. Cela implique généralement de cloner le référentiel, d'installer les dépendances nécessaires et de configurer les variables d'environnement nécessaires. |
||||
|
||||
3. Une fois l'installation terminée, vous pouvez entraîner et utiliser le modèle selon les instructions d'utilisation fournies dans le référentiel. Cela implique généralement la préparation de votre ensemble de données, la configuration des paramètres du modèle, l'entraînement du modèle, puis l'utilisation du modèle entraîné pour effectuer la détection d'objets. |
||||
|
||||
Veuillez noter que les étapes spécifiques peuvent varier en fonction de votre cas d'utilisation spécifique et de l'état actuel du référentiel YOLOv4. Il est donc fortement recommandé de se référer directement aux instructions fournies dans le référentiel GitHub de YOLOv4. |
||||
|
||||
Nous regrettons tout inconvénient que cela pourrait causer et nous nous efforcerons de mettre à jour ce document avec des exemples d'utilisation pour Ultralytics une fois que le support de YOLOv4 sera implémenté. |
||||
|
||||
## Conclusion |
||||
|
||||
YOLOv4 est un modèle de détection d'objets puissant et efficace qui concilie vitesse et précision. Son utilisation de fonctionnalités uniques et de techniques "ensemble de bonus" lors de l'entraînement lui permet de réaliser d'excellentes performances dans les tâches de détection d'objets en temps réel. YOLOv4 peut être entraîné et utilisé par n'importe qui disposant d'un GPU conventionnel, le rendant accessible et pratique pour un large éventail d'applications. |
||||
|
||||
## Citations et Remerciements |
||||
|
||||
Nous tenons à remercier les auteurs de YOLOv4 pour leurs contributions importantes dans le domaine de la détection d'objets en temps réel : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{bochkovskiy2020yolov4, |
||||
title={YOLOv4: Optimal Speed and Accuracy of Object Detection}, |
||||
author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao}, |
||||
year={2020}, |
||||
eprint={2004.10934}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
L'article original de YOLOv4 peut être consulté sur [arXiv](https://arxiv.org/abs/2004.10934). Les auteurs ont rendu leur travail accessible au public, et le code source peut être consulté sur [GitHub](https://github.com/AlexeyAB/darknet). Nous apprécions leurs efforts pour faire progresser le domaine et rendre leur travail accessible à la communauté élargie. |
||||
@ -1,113 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Découvrez YOLOv5u, une version améliorée du modèle YOLOv5 offrant un meilleur compromis entre précision et vitesse, ainsi que de nombreux modèles pré-entraînés pour diverses tâches de détection d'objets. |
||||
keywords: YOLOv5u, détection d'objets, modèles pré-entraînés, Ultralytics, inférence, validation, YOLOv5, YOLOv8, sans ancre, sans objectivité, applications temps réel, apprentissage automatique |
||||
--- |
||||
|
||||
# YOLOv5 |
||||
|
||||
## Présentation |
||||
|
||||
YOLOv5u représente une avancée dans les méthodologies de détection d'objets. Originaire de l'architecture fondamentale du modèle [YOLOv5](https://github.com/ultralytics/yolov5) développé par Ultralytics, YOLOv5u intègre la division sans ancre et sans objectivité, une fonctionnalité précédemment introduite dans les modèles [YOLOv8](yolov8.md). Cette adaptation affine l'architecture du modèle, ce qui conduit à un meilleur compromis entre précision et vitesse dans les tâches de détection d'objets. Compte tenu des résultats empiriques et des fonctionnalités dérivées, YOLOv5u offre une alternative efficace pour ceux qui recherchent des solutions robustes à la fois pour la recherche et les applications pratiques. |
||||
|
||||
 |
||||
|
||||
## Principales fonctionnalités |
||||
|
||||
- **Division sans ancre Ultralytics :** Les modèles de détection d'objets traditionnels reposent sur des boîtes d'ancrage prédéfinies pour prédire les emplacements des objets. Cependant, YOLOv5u modernise cette approche. En adoptant une division sans ancre Ultralytics, il garantit un mécanisme de détection plus flexible et adaptatif, ce qui améliore les performances dans divers scénarios. |
||||
|
||||
- **Bon compromis entre précision et vitesse optimisée :** La vitesse et la précision sont souvent opposées. Mais YOLOv5u remet en question ce compromis. Il offre un équilibre calibré, garantissant des détections en temps réel sans compromettre la précision. Cette fonctionnalité est particulièrement précieuse pour les applications qui demandent des réponses rapides, comme les véhicules autonomes, la robotique et l'analyse vidéo en temps réel. |
||||
|
||||
- **Variété de modèles pré-entraînés :** Comprendre que différentes tâches nécessitent différents ensembles d'outils, YOLOv5u propose une pléthore de modèles pré-entraînés. Que vous vous concentriez sur l'inférence, la validation ou l'entraînement, un modèle sur mesure vous attend. Cette variété garantit que vous n'utilisez pas une solution universelle, mais un modèle spécifiquement ajusté à votre défi unique. |
||||
|
||||
## Tâches et modes pris en charge |
||||
|
||||
Les modèles YOLOv5u, avec divers poids pré-entraînés, excellent dans les tâches de [détection d'objets](../tasks/detect.md). Ils prennent en charge une gamme complète de modes, ce qui les rend adaptés à diverses applications, du développement au déploiement. |
||||
|
||||
| Type de modèle | Poids pré-entraînés | Tâche | Inférence | Validation | Entraînement | Export | |
||||
|----------------|-----------------------------------------------------------------------------------------------------------------------------|------------------------------------------|-----------|------------|--------------|--------| |
||||
| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Ce tableau fournit un aperçu détaillé des variantes de modèles YOLOv5u, mettant en évidence leur applicabilité dans les tâches de détection d'objets et leur prise en charge de divers modes opérationnels tels que [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Exportation](../modes/export.md). Cette prise en charge complète garantit que les utilisateurs peuvent exploiter pleinement les capacités des modèles YOLOv5u dans un large éventail de scénarios de détection d'objets. |
||||
|
||||
## Métriques de performance |
||||
|
||||
!!! Performance |
||||
|
||||
=== "Détection" |
||||
|
||||
Consultez la [documentation sur la détection](https://docs.ultralytics.com/tasks/detect/) pour des exemples d'utilisation avec ces modèles formés sur [COCO](https://docs.ultralytics.com/datasets/detect/coco/), qui comprennent 80 classes pré-entraînées. |
||||
|
||||
| Modèle | YAML | taille<br><sup>(pixels) | mAP<sup>val<br>50-95 | Vitesse<br><sup>CPU ONNX<br>(ms) | Vitesse<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
|-------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------| |
||||
| [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34,3 | 73,6 | 1,06 | 2,6 | 7,7 | |
||||
| [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43,0 | 120,7 | 1,27 | 9,1 | 24,0 | |
||||
| [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49,0 | 233,9 | 1,86 | 25,1 | 64,2 | |
||||
| [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52,2 | 408,4 | 2,50 | 53,2 | 135,0 | |
||||
| [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53,2 | 763,2 | 3,81 | 97,2 | 246,4 | |
||||
| | | | | | | | | |
||||
| [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 42,1 | 211,0 | 1,83 | 4,3 | 7,8 | |
||||
| [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 48,6 | 422,6 | 2,34 | 15,3 | 24,6 | |
||||
| [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 53,6 | 810,9 | 4,36 | 41,2 | 65,7 | |
||||
| [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 55,7 | 1470,9 | 5,47 | 86,1 | 137,4 | |
||||
| [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 56,8 | 2436,5 | 8,98 | 155,4 | 250,7 | |
||||
|
||||
## Exemples d'utilisation |
||||
|
||||
Cet exemple présente des exemples simples d'entraînement et d'inférence YOLOv5. Pour une documentation complète sur ces exemples et d'autres [modes](../modes/index.md), consultez les pages de documentation [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md). |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
|
||||
Les modèles PyTorch pré-entraînés `*.pt` ainsi que les fichiers de configuration `*.yaml` peuvent être passés à la classe `YOLO()` pour créer une instance de modèle en python : |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv5n pré-entraîné sur COCO |
||||
model = YOLO('yolov5n.pt') |
||||
|
||||
# Afficher les informations sur le modèle (facultatif) |
||||
model.info() |
||||
|
||||
# Former le modèle sur l'ensemble de données d'exemple COCO8 pendant 100 époques |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Exécuter l'inférence avec le modèle YOLOv5n sur l'image 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Des commandes CLI sont disponibles pour exécuter directement les modèles : |
||||
|
||||
```bash |
||||
# Charger un modèle YOLOv5n pré-entraîné sur COCO et l'entraîner sur l'ensemble de données d'exemple COCO8 pendant 100 époques |
||||
yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Charger un modèle YOLOv5n pré-entraîné sur COCO et exécuter l'inférence sur l'image 'bus.jpg' |
||||
yolo predict model=yolov5n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Citations et remerciements |
||||
|
||||
Si vous utilisez YOLOv5 ou YOLOv5u dans vos recherches, veuillez citer le référentiel Ultralytics YOLOv5 comme suit : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
```bibtex |
||||
@software{yolov5, |
||||
title = {Ultralytics YOLOv5}, |
||||
author = {Glenn Jocher}, |
||||
year = {2020}, |
||||
version = {7.0}, |
||||
license = {AGPL-3.0}, |
||||
url = {https://github.com/ultralytics/yolov5}, |
||||
doi = {10.5281/zenodo.3908559}, |
||||
orcid = {0000-0001-5950-6979} |
||||
} |
||||
``` |
||||
|
||||
Veuillez noter que les modèles YOLOv5 sont fournis sous les licences [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) et [Enterprise](https://ultralytics.com/license). |
||||
@ -1,107 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explorez Meituan YOLOv6, un modèle de détection d'objets à la pointe de la technologie offrant un équilibre entre vitesse et précision. Plongez-vous dans les fonctionnalités, les modèles pré-entraînés et l'utilisation de Python. |
||||
keywords: Meituan YOLOv6, détection d'objets, Ultralytics, YOLOv6 docs, Bi-directional Concatenation, Anchor-Aided Training, modèles pré-entraînés, applications en temps réel |
||||
--- |
||||
|
||||
# Meituan YOLOv6 |
||||
|
||||
## Vue d'ensemble |
||||
|
||||
[Meituan](https://about.meituan.com/) YOLOv6 est un détecteur d'objets de pointe qui offre un équilibre remarquable entre vitesse et précision, ce qui en fait un choix populaire pour les applications en temps réel. Ce modèle introduit plusieurs améliorations remarquables sur son architecture et son schéma d'entraînement, notamment la mise en œuvre d'un module de concaténation bidirectionnelle (BiC), d'une stratégie d'entraînement assistée par ancrage (AAT) et d'une conception améliorée de l'épine dorsale et du cou pour une précision de pointe sur l'ensemble de données COCO. |
||||
|
||||
 |
||||
 |
||||
**Aperçu de YOLOv6.** Diagramme de l'architecture du modèle montrant les composants du réseau redessinés et les stratégies d'entraînement qui ont conduit à d'importantes améliorations des performances. (a) L'épine dorsale de YOLOv6 (N et S sont indiqués). Notez que pour M/L, RepBlocks est remplacé par CSPStackRep. (b) La structure d'un module BiC. (c) Un bloc SimCSPSPPF. ([source](https://arxiv.org/pdf/2301.05586.pdf)). |
||||
|
||||
### Caractéristiques principales |
||||
|
||||
- **Module de concaténation bidirectionnelle (BiC) :** YOLOv6 introduit un module BiC dans le cou du détecteur, améliorant les signaux de localisation et offrant des gains de performance avec une dégradation de vitesse négligeable. |
||||
- **Stratégie d'entraînement assistée par ancrage (AAT) :** Ce modèle propose AAT pour profiter des avantages des paradigmes basés sur ancrage et sans ancrage sans compromettre l'efficacité de l'inférence. |
||||
- **Conception améliorée de l'épine dorsale et du cou :** En approfondissant YOLOv6 pour inclure une autre étape dans l'épine dorsale et le cou, ce modèle atteint des performances de pointe sur l'ensemble de données COCO avec une entrée haute résolution. |
||||
- **Stratégie d'autodistillation :** Une nouvelle stratégie d'autodistillation est mise en œuvre pour améliorer les performances des modèles plus petits de YOLOv6, en améliorant la branche de régression auxiliaire pendant l'entraînement et en la supprimant lors de l'inférence afin d'éviter une baisse notable de la vitesse. |
||||
|
||||
## Métriques de performance |
||||
|
||||
YOLOv6 propose différents modèles pré-entraînés avec différentes échelles : |
||||
|
||||
- YOLOv6-N : 37,5 % de précision sur COCO val2017 à 1187 FPS avec le GPU NVIDIA Tesla T4. |
||||
- YOLOv6-S : 45,0 % de précision à 484 FPS. |
||||
- YOLOv6-M : 50,0 % de précision à 226 FPS. |
||||
- YOLOv6-L : 52,8 % de précision à 116 FPS. |
||||
- YOLOv6-L6 : Précision de pointe en temps réel. |
||||
|
||||
YOLOv6 propose également des modèles quantifiés pour différentes précisions et des modèles optimisés pour les plates-formes mobiles. |
||||
|
||||
## Exemples d'utilisation |
||||
|
||||
Cet exemple fournit des exemples simples d'entraînement et d'inférence de YOLOv6. Pour une documentation complète sur ces exemples et d'autres [modes](../modes/index.md), consultez les pages de documentation [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md). |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
|
||||
Les modèles pré-entraînés PyTorch `*.pt`, ainsi que les fichiers de configuration `*.yaml`, peuvent être utilisés pour créer une instance de modèle en python en utilisant la classe `YOLO()` : |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Créer un modèle YOLOv6n à partir de zéro |
||||
model = YOLO('yolov6n.yaml') |
||||
|
||||
# Afficher les informations sur le modèle (facultatif) |
||||
model.info() |
||||
|
||||
# Entraîner le modèle sur l'ensemble de données d'exemple COCO8 pendant 100 epochs |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Effectuer une inférence avec le modèle YOLOv6n sur l'image 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Des commandes CLI sont disponibles pour exécuter directement les modèles : |
||||
|
||||
```bash |
||||
# Créer un modèle YOLOv6n à partir de zéro et l'entraîner sur l'ensemble de données d'exemple COCO8 pendant 100 epochs |
||||
yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Créer un modèle YOLOv6n à partir de zéro et effectuer une inférence sur l'image 'bus.jpg' |
||||
yolo predict model=yolov6n.yaml source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Tâches et modes pris en charge |
||||
|
||||
La série YOLOv6 propose une gamme de modèles, chacun optimisé pour la [détection d'objets](../tasks/detect.md) haute performance. Ces modèles répondent à des besoins computationnels et des exigences de précision variables, ce qui les rend polyvalents pour une large gamme d'applications. |
||||
|
||||
| Type de modèle | Modèles pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Export | |
||||
|----------------|-----------------------|------------------------------------------|-----------|------------|--------------|--------| |
||||
| YOLOv6-N | `yolov6-n.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-S | `yolov6-s.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-M | `yolov6-m.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-L | `yolov6-l.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv6-L6 | `yolov6-l6.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Ce tableau fournit un aperçu détaillé des variantes du modèle YOLOv6, mettant en évidence leurs capacités dans les tâches de détection d'objets et leur compatibilité avec différents modes opérationnels tels que l'[Inférence](../modes/predict.md), la [Validation](../modes/val.md), l'[Entraînement](../modes/train.md) et l'[Export](../modes/export.md). Cette prise en charge complète permet aux utilisateurs de tirer pleinement parti des capacités des modèles YOLOv6 dans un large éventail de scénarios de détection d'objets. |
||||
|
||||
## Citations et remerciements |
||||
|
||||
Nous tenons à remercier les auteurs pour leur contribution importante dans le domaine de la détection d'objets en temps réel : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@misc{li2023yolov6, |
||||
title={YOLOv6 v3.0: A Full-Scale Reloading}, |
||||
author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu}, |
||||
year={2023}, |
||||
eprint={2301.05586}, |
||||
archivePrefix={arXiv}, |
||||
primaryClass={cs.CV} |
||||
} |
||||
``` |
||||
|
||||
Le document original de YOLOv6 peut être consulté sur [arXiv](https://arxiv.org/abs/2301.05586). Les auteurs ont rendu leur travail accessible au public, et le code source peut être consulté sur [GitHub](https://github.com/meituan/YOLOv6). Nous apprécions leurs efforts pour faire avancer le domaine et rendre leur travail accessible à la communauté plus large. |
||||
@ -1,66 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Découvrez le YOLOv7, un détecteur d'objets en temps réel. Comprenez sa vitesse supérieure, son impressionnante précision et son accent unique sur l'optimisation bag-of-freebies entraînable. |
||||
keywords: YOLOv7, détecteur d'objets en temps réel, état de l'art, Ultralytics, jeu de données MS COCO, ré-paramétrisation du modèle, affectation des étiquettes dynamiques, mise à l'échelle étendue, mise à l'échelle composée |
||||
--- |
||||
|
||||
# YOLOv7 : Bag-of-Freebies Entraînable |
||||
|
||||
YOLOv7 est un détecteur d'objets en temps réel à la pointe de la technologie qui surpasse tous les détecteurs d'objets connus en termes de vitesse et de précision, dans une plage de 5 FPS à 160 FPS. Il présente la précision la plus élevée (56,8% AP) parmi tous les détecteurs d'objets en temps réel connus avec un FPS de 30 ou plus sur GPU V100. De plus, YOLOv7 surpasse les autres détecteurs d'objets tels que YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 et bien d'autres en termes de vitesse et de précision. Le modèle est entraîné à partir de zéro sur le jeu de données MS COCO, sans utiliser d'autres jeux de données ou de poids pré-entraînés. Le code source de YOLOv7 est disponible sur GitHub. |
||||
|
||||
 |
||||
**Comparaison des détecteurs d'objets de pointe. |
||||
** À partir des résultats du Tableau 2, nous savons que la méthode proposée présente le meilleur compromis vitesse-précision dans l'ensemble. Si nous comparons YOLOv7-tiny-SiLU avec YOLOv5-N (r6.1), notre méthode est 127 FPS plus rapide et plus précise de 10,7% en AP. De plus, YOLOv7 atteint 51,4% d'AP à une fréquence d'images de 161 FPS, tandis que PPYOLOE-L avec la même AP atteint seulement 78 FPS. En termes d'utilisation des paramètres, YOLOv7 consomme 41% de moins que PPYOLOE-L. Si nous comparons YOLOv7-X avec une vitesse d'inférence de 114 FPS à YOLOv5-L (r6.1) avec une vitesse d'inférence de 99 FPS, YOLOv7-X peut améliorer l'AP de 3,9%. Si YOLOv7-X est comparé à YOLOv5-X (r6.1) de taille similaire, la vitesse d'inférence de YOLOv7-X est de 31 FPS plus rapide. De plus, en termes de nombre de paramètres et de calculs, YOLOv7-X réduit de 22% les paramètres et de 8% les calculs par rapport à YOLOv5-X (r6.1), mais améliore l'AP de 2,2% ([Source](https://arxiv.org/pdf/2207.02696.pdf)). |
||||
|
||||
## Aperçu |
||||
|
||||
La détection d'objets en temps réel est un composant important de nombreux systèmes de vision par ordinateur, notamment le suivi multi-objets, la conduite autonome, la robotique et l'analyse d'images médicales. Ces dernières années, le développement de la détection d'objets en temps réel s'est concentré sur la conception d'architectures efficaces et l'amélioration de la vitesse d'inférence des CPU, des GPU et des unités de traitement neuronal (NPU) dans différentes configurations. YOLOv7 prend en charge les GPU mobiles et les appareils GPU, de l'edge au cloud. |
||||
|
||||
Contrairement aux détecteurs d'objets en temps réel traditionnels qui se concentrent sur l'optimisation de l'architecture, YOLOv7 introduit une approche axée sur l'optimisation du processus d'entraînement. Cela comprend des modules et des méthodes d'optimisation conçus pour améliorer la précision de la détection d'objets sans augmenter le coût de l'inférence, un concept connu sous le nom de "bag-of-freebies entraînable". |
||||
|
||||
## Fonctionnalités Principales |
||||
|
||||
YOLOv7 propose plusieurs fonctionnalités principales : |
||||
|
||||
1. **Ré-paramétrisation du Modèle** : YOLOv7 propose un modèle re-paramétré planifié, qui est une stratégie applicable aux couches de différents réseaux avec le concept de propagation des gradients. |
||||
|
||||
2. **Affectation Dynamique des Étiquettes** : La formation du modèle avec des couches de sortie multiples présente un nouveau problème : "Comment attribuer des cibles dynamiques aux sorties des différentes branches ?" Pour résoudre ce problème, YOLOv7 introduit une nouvelle méthode d'affectation des étiquettes appelée affectation des étiquettes guidée en cascade de grossières à fines. |
||||
|
||||
3. **Mise à l'Échelle Étendue et Composée** : YOLOv7 propose des méthodes de "mise à l'échelle étendue" et de "mise à l'échelle composée" pour le détecteur d'objets en temps réel, qui permettent d'utiliser efficacement les paramètres et les calculs. |
||||
|
||||
4. **Efficacité** : La méthode proposée par YOLOv7 permet de réduire efficacement environ 40% des paramètres et 50% des calculs du détecteur d'objets en temps réel de pointe, tout en offrant une vitesse d'inférence plus rapide et une plus grande précision de détection. |
||||
|
||||
## Exemples d'Utilisation |
||||
|
||||
Au moment de la rédaction de cet article, Ultralytics ne prend pas en charge les modèles YOLOv7. Par conséquent, tout utilisateur intéressé par l'utilisation de YOLOv7 devra se référer directement au dépôt GitHub de YOLOv7 pour obtenir les instructions d'installation et d'utilisation. |
||||
|
||||
Voici un bref aperçu des étapes typiques que vous pourriez suivre pour utiliser YOLOv7 : |
||||
|
||||
1. Rendez-vous sur le dépôt GitHub de YOLOv7 : [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7). |
||||
|
||||
2. Suivez les instructions fournies dans le fichier README pour l'installation. Cela implique généralement de cloner le dépôt, d'installer les dépendances nécessaires et de configurer les variables d'environnement nécessaires. |
||||
|
||||
3. Une fois l'installation terminée, vous pouvez entraîner et utiliser le modèle selon les instructions d'utilisation fournies dans le dépôt. Cela implique généralement la préparation de votre ensemble de données, la configuration des paramètres du modèle, l'entraînement du modèle, puis l'utilisation du modèle entraîné pour effectuer la détection d'objets. |
||||
|
||||
Veuillez noter que les étapes spécifiques peuvent varier en fonction de votre cas d'utilisation spécifique et de l'état actuel du dépôt YOLOv7. Par conséquent, il est fortement recommandé de vous reporter directement aux instructions fournies dans le dépôt GitHub de YOLOv7. |
||||
|
||||
Nous nous excusons pour tout inconvénient que cela pourrait causer et nous nous efforcerons de mettre à jour ce document avec des exemples d'utilisation pour Ultralytics une fois la prise en charge de YOLOv7 mise en place. |
||||
|
||||
## Citations et Remerciements |
||||
|
||||
Nous tenons à remercier les auteurs de YOLOv7 pour leurs contributions significatives dans le domaine de la détection d'objets en temps réel : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@article{wang2022yolov7, |
||||
title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors}, |
||||
author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark}, |
||||
journal={arXiv preprint arXiv:2207.02696}, |
||||
year={2022} |
||||
} |
||||
``` |
||||
|
||||
Le document original de YOLOv7 peut être consulté sur [arXiv](https://arxiv.org/pdf/2207.02696.pdf). Les auteurs ont rendu leur travail accessible au public, et le code source peut être consulté sur [GitHub](https://github.com/WongKinYiu/yolov7). Nous apprécions leurs efforts pour faire avancer le domaine et rendre leur travail accessible à la communauté élargie. |
||||
@ -1,162 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Explorez les fonctionnalités passionnantes de YOLOv8, la dernière version de notre détecteur d'objets en temps réel ! Découvrez comment les architectures avancées, les modèles pré-entraînés et un équilibre optimal entre précision et vitesse font de YOLOv8 le choix parfait pour vos tâches de détection d'objets. |
||||
keywords: YOLOv8, Ultralytics, détecteur d'objets en temps réel, modèles pré-entraînés, documentation, détection d'objets, série YOLO, architectures avancées, précision, vitesse |
||||
--- |
||||
|
||||
# YOLOv8 |
||||
|
||||
## Aperçu |
||||
|
||||
YOLOv8 est la dernière itération de la série YOLO de détecteurs d'objets en temps réel, offrant des performances de pointe en termes de précision et de vitesse. S'appuyant sur les avancées des versions précédentes de YOLO, YOLOv8 introduit de nouvelles fonctionnalités et optimisations qui en font un choix idéal pour diverses tâches de détection d'objets dans une large gamme d'applications. |
||||
|
||||
 |
||||
|
||||
## Principales fonctionnalités |
||||
|
||||
- **Architectures avancées pour le tronc et le cou:** YOLOv8 utilise des architectures de tronc et de cou de pointe, ce qui permet une meilleure extraction des caractéristiques et des performances de détection d'objets améliorées. |
||||
- **Tête Ultralytics sans ancre:** YOLOv8 adopte une tête Ultralytics sans ancre, ce qui contribue à une meilleure précision et à un processus de détection plus efficace par rapport aux approches basées sur les ancres. |
||||
- **Équilibre optimal entre précision et vitesse optimisé:** En mettant l'accent sur le maintien d'un équilibre optimal entre précision et vitesse, YOLOv8 convient aux tâches de détection d'objets en temps réel dans divers domaines d'application. |
||||
- **Variété de modèles pré-entraînés:** YOLOv8 propose une gamme de modèles pré-entraînés pour répondre à différentes tâches et exigences de performance, ce qui facilite la recherche du modèle adapté à votre cas d'utilisation spécifique. |
||||
|
||||
## Tâches et modes pris en charge |
||||
|
||||
La série YOLOv8 propose une gamme diversifiée de modèles, chacun spécialisé dans des tâches spécifiques en vision par ordinateur. Ces modèles sont conçus pour répondre à diverses exigences, de la détection d'objets à des tâches plus complexes telles que la segmentation d'instance, la détection de pose/points clés et la classification. |
||||
|
||||
Chaque variante de la série YOLOv8 est optimisée pour sa tâche respective, garantissant des performances et une précision élevées. De plus, ces modèles sont compatibles avec divers modes opérationnels, notamment l'[Inférence](../modes/predict.md), la [Validation](../modes/val.md), l'[Entraînement](../modes/train.md) et l'[Exportation](../modes/export.md), ce qui facilite leur utilisation à différentes étapes du déploiement et du développement. |
||||
|
||||
| Modèle | Noms de fichiers | Tâche | Inférence | Validation | Entraînement | Exportation | |
||||
|-------------|----------------------------------------------------------------------------------------------------------------|------------------------------------------------|-----------|------------|--------------|-------------| |
||||
| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Détection](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Segmentation d'instance](../tasks/segment.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [Pose/Points clés](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ | |
||||
| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Classification](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ | |
||||
|
||||
Ce tableau donne un aperçu des variantes des modèles YOLOv8, mettant en évidence leur applicabilité dans des tâches spécifiques et leur compatibilité avec différents modes opérationnels tels que l'inférence, la validation, l'entraînement et l'exportation. Il met en avant la polyvalence et la robustesse de la série YOLOv8, ce qui les rend adaptés à une variété d'applications en vision par ordinateur. |
||||
|
||||
## Métriques de performance |
||||
|
||||
!!! Performance |
||||
|
||||
=== "Détection (COCO)" |
||||
|
||||
Consultez la [doc de détection](https://docs.ultralytics.com/tasks/detect/) pour des exemples d'utilisation avec ces modèles entraînés sur [COCO](https://docs.ultralytics.com/datasets/detect/coco/), qui comprennent 80 classes pré-entrainées. |
||||
|
||||
| Modèle | taille<br><sup>(pixels) | mAP<sup>val<br>50-95 | Vitesse<br><sup>CPU ONNX<br>(ms) | Vitesse<br><sup>A100 TensorRT<br>(ms) | paramètres<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------- | ------------------------------------ | ------------------ | ----------------- | |
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt) | 640 | 37,3 | 80,4 | 0,99 | 3,2 | 8,7 | |
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44,9 | 128,4 | 1,20 | 11,2 | 28,6 | |
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50,2 | 234,7 | 1,83 | 25,9 | 78,9 | |
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52,9 | 375,2 | 2,39 | 43,7 | 165,2 | |
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x.pt) | 640 | 53,9 | 479,1 | 3,53 | 68,2 | 257,8 | |
||||
|
||||
=== "Détection (Open Images V7)" |
||||
|
||||
Consultez la [doc de détection](https://docs.ultralytics.com/tasks/detect/) pour des exemples d'utilisation avec ces modèles entraînés sur [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), qui comprennent 600 classes pré-entrainées. |
||||
|
||||
| Modèle | taille<br><sup>(pixels) | mAP<sup>val<br>50-95 | Vitesse<br><sup>CPU ONNX<br>(ms) | Vitesse<br><sup>A100 TensorRT<br>(ms) | paramètres<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------- | ------------------------------------ | ------------------ | ----------------- | |
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n-oiv7.pt) | 640 | 18,4 | 142,4 | 1,21 | 3,5 | 10,5 | |
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s-oiv7.pt) | 640 | 27,7 | 183,1 | 1,40 | 11,4 | 29,7 | |
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m-oiv7.pt) | 640 | 33,6 | 408,5 | 2,26 | 26,2 | 80,6 | |
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l-oiv7.pt) | 640 | 34,9 | 596,9 | 2,43 | 44,1 | 167,4 | |
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x-oiv7.pt) | 640 | 36,3 | 860,6 | 3,56 | 68,7 | 260,6 | |
||||
|
||||
=== "Segmentation (COCO)" |
||||
|
||||
Consultez la [doc de segmentation](https://docs.ultralytics.com/tasks/segment/) pour des exemples d'utilisation avec ces modèles entraînés sur [COCO](https://docs.ultralytics.com/datasets/segment/coco/), qui comprennent 80 classes pré-entrainées. |
||||
|
||||
| Modèle | taille<br><sup>(pixels) | mAP<sup>box<br>50-95 | mAP<sup>mask<br>50-95 | Vitesse<br><sup>CPU ONNX<br>(ms) | Vitesse<br><sup>A100 TensorRT<br>(ms) | paramètres<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------- | ------------------------------------ | ------------------ | ----------------- | |
||||
| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53,4 | 43,4 | 712,1 | 4,02 | 71,8 | 344,1 | |
||||
|
||||
=== "Classification (ImageNet)" |
||||
|
||||
Consultez la [doc de classification](https://docs.ultralytics.com/tasks/classify/) pour des exemples d'utilisation avec ces modèles entraînés sur [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), qui comprennent 1000 classes pré-entrainées. |
||||
|
||||
| Modèle | taille<br><sup>(pixels) | acc<br><sup>top1 | acc<br><sup>top5 | Vitesse<br><sup>CPU ONNX<br>(ms) | Vitesse<br><sup>A100 TensorRT<br>(ms) | paramètres<br><sup>(M) | FLOPs<br><sup>(B) at 640 | |
||||
| -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ------------------------------- | ------------------------------------ | ------------------ | ------------------------ | |
||||
| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78,4 | 94,3 | 232,0 | 1,01 | 57,4 | 154,8 | |
||||
|
||||
=== "Pose (COCO)" |
||||
|
||||
Consultez la [doc d'estimation de pose](https://docs.ultralytics.com/tasks/segment/) pour des exemples d'utilisation avec ces modèles entraînés sur [COCO](https://docs.ultralytics.com/datasets/pose/coco/), qui comprennent 1 classe pré-entrainée, 'person'. |
||||
|
||||
| Modèle | taille<br><sup>(pixels) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | Vitesse<br><sup>CPU ONNX<br>(ms) | Vitesse<br><sup>A100 TensorRT<br>(ms) | paramètres<br><sup>(M) | FLOPs<br><sup>(B) | |
||||
| ---------------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ------------------------------- | ------------------------------------ | ------------------ | ----------------- | |
||||
| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71,6 | 91,2 | 4088,7 | 10,04 | 99,1 | 1066,4 | |
||||
|
||||
## Exemples d'utilisation |
||||
|
||||
Cet exemple fournit des exemples simples d'entraînement et d'inférence avec YOLOv8. Pour une documentation complète sur ces exemples et d'autres [modes](../modes/index.md), consultez les pages de documentation [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md). |
||||
|
||||
Veuillez noter que l'exemple ci-dessous concerne les modèles de détection YOLOv8. Pour d'autres tâches prises en charge, consultez la documentation de [Segmentation](../tasks/segment.md), [Classification](../tasks/classify.md) et [Pose/Points clés](../tasks/pose.md). |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
|
||||
Les modèles pré-entraînés PyTorch `*.pt` ainsi que les fichiers de configuration `*.yaml` peuvent être utilisés pour créer une instance de modèle en python en passant aux classes `YOLO()` : |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné sur COCO |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Afficher les informations du modèle (facultatif) |
||||
model.info() |
||||
|
||||
# Entraîner le modèle sur l'exemple de jeu de données COCO8 pendant 100 époques |
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640) |
||||
|
||||
# Effectuer une inférence avec le modèle YOLOv8n sur l'image 'bus.jpg' |
||||
results = model('path/to/bus.jpg') |
||||
``` |
||||
|
||||
=== "CLI" |
||||
|
||||
Des commandes CLI sont disponibles pour exécuter directement les modèles : |
||||
|
||||
```bash |
||||
# Charger un modèle YOLOv8n pré-entraîné sur COCO et l'entraîner sur l'exemple de jeu de données COCO8 pendant 100 époques |
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné sur COCO et effectuer une inférence sur l'image 'bus.jpg' |
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg |
||||
``` |
||||
|
||||
## Citations et remerciements |
||||
|
||||
Si vous utilisez le modèle YOLOv8 ou tout autre logiciel de ce référentiel dans votre travail, veuillez le citer selon le format suivant : |
||||
|
||||
!!! Quote "" |
||||
|
||||
=== "BibTeX" |
||||
|
||||
```bibtex |
||||
@software{yolov8_ultralytics, |
||||
author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu}, |
||||
title = {Ultralytics YOLOv8}, |
||||
version = {8.0.0}, |
||||
year = {2023}, |
||||
url = {https://github.com/ultralytics/ultralytics}, |
||||
orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069}, |
||||
license = {AGPL-3.0} |
||||
} |
||||
``` |
||||
|
||||
Veuillez noter que le DOI est en attente et sera ajouté à la citation dès qu'il sera disponible. Les modèles YOLOv8 sont fournis sous licence [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) et [Enterprise](https://ultralytics.com/license). |
||||
@ -1,94 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Apprenez comment profiler la vitesse et l'exactitude de YOLOv8 à travers divers formats d'exportation ; obtenez des insights sur les métriques mAP50-95, accuracy_top5 et plus. |
||||
keywords: Ultralytics, YOLOv8, benchmarking, profilage de vitesse, profilage de précision, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formats d'exportation YOLO |
||||
--- |
||||
|
||||
# Benchmarking de Modèles avec Ultralytics YOLO |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Écosystème Ultralytics YOLO et intégrations"> |
||||
|
||||
## Introduction |
||||
|
||||
Une fois votre modèle entraîné et validé, l'étape logique suivante est d'évaluer ses performances dans divers scénarios du monde réel. Le mode benchmark dans Ultralytics YOLOv8 répond à cet objectif en fournissant un cadre robuste pour évaluer la vitesse et l'exactitude de votre modèle sur une gamme de formats d'exportation. |
||||
|
||||
## Pourquoi le Benchmarking est-il Crucial ? |
||||
|
||||
- **Décisions Éclairées :** Obtenez des insights sur les arbitrages entre la vitesse et l'exactitude. |
||||
- **Allocation des Ressources :** Comprenez comment les différents formats d'exportation se comportent sur différents matériels. |
||||
- **Optimisation :** Découvrez quel format d'exportation offre la meilleure performance pour votre cas d'utilisation spécifique. |
||||
- **Efficacité des Coûts :** Utilisez les ressources matérielles plus efficacement en vous basant sur les résultats des benchmarks. |
||||
|
||||
### Mesures Clés en Mode Benchmark |
||||
|
||||
- **mAP50-95 :** Pour la détection d'objets, la segmentation et l'estimation de pose. |
||||
- **accuracy_top5 :** Pour la classification d'images. |
||||
- **Temps d'Inférence :** Temps pris pour chaque image en millisecondes. |
||||
|
||||
### Formats d'Exportation Supportés |
||||
|
||||
- **ONNX :** Pour une performance optimale sur CPU. |
||||
- **TensorRT :** Pour une efficacité maximale sur GPU. |
||||
- **OpenVINO :** Pour l'optimisation du matériel Intel. |
||||
- **CoreML, TensorFlow SavedModel, et Plus :** Pour des besoins variés de déploiement. |
||||
|
||||
!!! astuce "Conseil" |
||||
|
||||
* Exportez vers ONNX ou OpenVINO pour un gain de vitesse CPU jusqu'à 3x. |
||||
* Exportez vers TensorRT pour un gain de vitesse GPU jusqu'à 5x. |
||||
|
||||
## Exemples d'Utilisation |
||||
|
||||
Exécutez les benchmarks YOLOv8n sur tous les formats d'exportation supportés, y compris ONNX, TensorRT, etc. Consultez la section Arguments ci-dessous pour une liste complète des arguments d'exportation. |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics.utils.benchmarks import benchmark |
||||
|
||||
# Benchmark sur 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 |
||||
``` |
||||
|
||||
## Arguments |
||||
|
||||
Des arguments tels que `model`, `data`, `imgsz`, `half`, `device` et `verbose` offrent aux utilisateurs la flexibilité d'ajuster précisément les benchmarks à leurs besoins spécifiques et de comparer facilement les performances de différents formats d'exportation. |
||||
|
||||
| Clé | Valeur | Description | |
||||
|-----------|---------|---------------------------------------------------------------------------------------| |
||||
| `model` | `None` | chemin vers le fichier modèle, par ex. yolov8n.pt, yolov8n.yaml | |
||||
| `data` | `None` | chemin vers le YAML référençant le dataset de benchmarking (sous l'étiquette `val`) | |
||||
| `imgsz` | `640` | taille de l'image comme scalaire ou liste (h, w), par ex. (640, 480) | |
||||
| `half` | `False` | quantification FP16 | |
||||
| `int8` | `False` | quantification INT8 | |
||||
| `device` | `None` | appareil sur lequel exécuter, par ex. appareil cuda=0 ou device=0,1,2,3 ou device=cpu | |
||||
| `verbose` | `False` | ne pas continuer en cas d'erreur (bool), ou seuil de plancher val (float) | |
||||
|
||||
## Formats d'Exportation |
||||
|
||||
Les benchmarks tenteront de s'exécuter automatiquement sur tous les formats d'exportation possibles ci-dessous. |
||||
|
||||
| Format | Argument `format` | Modèle | Métadonnées | Arguments | |
||||
|--------------------------------------------------------------------|-------------------|---------------------------|-------------|-----------------------------------------------------| |
||||
| [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` | |
||||
|
||||
Consultez les détails complets sur `export` dans la page [Export](https://docs.ultralytics.com/modes/export/). |
||||
@ -1,108 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Guide étape par étape sur l'exportation de vos modèles YOLOv8 vers divers formats tels que ONNX, TensorRT, CoreML et plus encore pour le déploiement. Explorez maintenant !. |
||||
keywords: YOLO, YOLOv8, Ultralytics, Exportation de modèle, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exporter un modèle |
||||
--- |
||||
|
||||
# Exportation de modèle avec Ultralytics YOLO |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Écosystème et intégrations Ultralytics YOLO"> |
||||
|
||||
## Introduction |
||||
|
||||
L'objectif ultime de l'entraînement d'un modèle est de le déployer pour des applications dans le monde réel. Le mode d'exportation de Ultralytics YOLOv8 offre une large gamme d'options pour exporter votre modèle entraîné dans différents formats, le rendant déployable sur diverses plateformes et appareils. Ce guide complet vise à vous guider à travers les nuances de l'exportation de modèles, en montrant comment atteindre une compatibilité et des performances maximales. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/WbomGeoOT_k?si=aGmuyooWftA0ue9X" |
||||
title="Lecteur de vidéo YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Regardez :</strong> Comment exporter un modèle Ultralytics YOLOv8 entraîné personnalisé et effectuer une inférence en direct sur webcam. |
||||
</p> |
||||
|
||||
## Pourquoi choisir le mode d'exportation YOLOv8 ? |
||||
|
||||
- **Polyvalence :** Exportation vers plusieurs formats, y compris ONNX, TensorRT, CoreML et plus encore. |
||||
- **Performance :** Gagnez jusqu'à 5 fois la vitesse d'une GPU avec TensorRT et 3 fois la vitesse d'une CPU avec ONNX ou OpenVINO. |
||||
- **Compatibilité :** Rendez votre modèle universellement déployable sur de nombreux environnements matériels et logiciels. |
||||
- **Facilité d'utilisation :** Interface en ligne de commande (CLI) et API Python simples pour une exportation rapide et directe du modèle. |
||||
|
||||
### Caractéristiques clés du mode d'exportation |
||||
|
||||
Voici quelques-unes des fonctionnalités remarquables : |
||||
|
||||
- **Exportation en un clic :** Commandes simples pour exporter vers différents formats. |
||||
- **Exportation groupée :** Exportez des modèles capables d'inférence par lot. |
||||
- **Inférence optimisée :** Les modèles exportés sont optimisés pour des temps d'inférence plus rapides. |
||||
- **Vidéos tutorielles :** Guides détaillés et tutoriels pour une expérience d'exportation fluide. |
||||
|
||||
!!! astuce "Conseil" |
||||
|
||||
* Exportez vers ONNX ou OpenVINO pour une accélération de la CPU jusqu'à 3 fois. |
||||
* Exportez vers TensorRT pour une accélération de la GPU jusqu'à 5 fois. |
||||
|
||||
## Exemples d'utilisation |
||||
|
||||
Exportez un modèle YOLOv8n vers un format différent tel que ONNX ou TensorRT. Voir la section Arguments ci-dessous pour une liste complète des arguments d'exportation. |
||||
|
||||
!!! Example "Exemple" |
||||
|
||||
=== "Python" |
||||
|
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle |
||||
model = YOLO('yolov8n.pt') # chargez un modèle officiel |
||||
model = YOLO('path/to/best.pt') # chargez un modèle entraîné personnalisé |
||||
|
||||
# Exporter le modèle |
||||
model.export(format='onnx') |
||||
``` |
||||
=== "CLI" |
||||
|
||||
```bash |
||||
yolo export model=yolov8n.pt format=onnx # exporter modèle officiel |
||||
yolo export model=path/to/best.pt format=onnx # exporter modèle entraîné personnalisé |
||||
``` |
||||
|
||||
## Arguments |
||||
|
||||
Les paramètres d'exportation pour les modèles YOLO se réfèrent aux diverses configurations et options utilisées pour sauvegarder ou exporter le modèle pour utilisation dans d'autres environnements ou plateformes. Ces paramètres peuvent affecter la performance, la taille et la compatibilité du modèle avec différents systèmes. Certains paramètres d'exportation YOLO courants incluent le format du fichier modèle exporté (par exemple, ONNX, TensorFlow SavedModel), le dispositif sur lequel le modèle sera exécuté (par exemple, CPU, GPU), et la présence de fonctionnalités supplémentaires telles que des masques ou des étiquettes multiples par boîte. D'autres facteurs qui peuvent affecter le processus d'exportation incluent la tâche spécifique pour laquelle le modèle est utilisé et les exigences ou contraintes de l'environnement ou de la plateforme cible. Il est important de considérer et de configurer ces paramètres avec soin pour s'assurer que le modèle exporté est optimisé pour le cas d'utilisation visé et peut être utilisé efficacement dans l'environnement cible. |
||||
|
||||
| Clé | Valeur | Description | |
||||
|-------------|-----------------|----------------------------------------------------------------------------------| |
||||
| `format` | `'torchscript'` | format vers lequel exporter | |
||||
| `imgsz` | `640` | taille d'image sous forme scalaire ou liste (h, w), par ex. (640, 480) | |
||||
| `keras` | `False` | utilisez Keras pour l'exportation TensorFlow SavedModel | |
||||
| `optimize` | `False` | TorchScript : optimisation pour mobile | |
||||
| `half` | `False` | quantification FP16 | |
||||
| `int8` | `False` | quantification INT8 | |
||||
| `dynamic` | `False` | ONNX/TensorRT : axes dynamiques | |
||||
| `simplify` | `False` | ONNX/TensorRT : simplifier le modèle | |
||||
| `opset` | `None` | ONNX : version de l'ensemble d'opérations (facultatif, par défaut à la dernière) | |
||||
| `workspace` | `4` | TensorRT : taille de l'espace de travail (GB) | |
||||
| `nms` | `False` | CoreML : ajout de la NMS | |
||||
|
||||
## Formats d'exportation |
||||
|
||||
Les formats d'exportation disponibles pour YOLOv8 sont dans le tableau ci-dessous. Vous pouvez exporter vers n'importe quel format en utilisant l'argument `format`, par ex. `format='onnx'` ou `format='engine'`. |
||||
|
||||
| Format | Argument `format` | Modèle | Métadonnées | Arguments | |
||||
|--------------------------------------------------------------------|-------------------|---------------------------|-------------|-----------------------------------------------------| |
||||
| [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` | |
||||
@ -1,73 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: De l'entraînement au suivi, exploitez au mieux YOLOv8 d'Ultralytics. Obtenez des aperçus et des exemples pour chaque mode pris en charge, y compris la validation, l'exportation et le benchmarking. |
||||
keywords: Ultralytics, YOLOv8, Machine Learning, Détection d'objets, Entraînement, Validation, Prédiction, Exportation, Suivi, Benchmarking |
||||
--- |
||||
|
||||
# Modes Ultralytics YOLOv8 |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Écosystème Ultralytics YOLO et intégrations"> |
||||
|
||||
## Introduction |
||||
|
||||
Ultralytics YOLOv8 n'est pas simplement un autre modèle de détection d'objets ; c'est un cadre polyvalent conçu pour couvrir l'intégralité du cycle de vie des modèles d'apprentissage automatique — de l'ingestion de données et l'entraînement des modèles à la validation, le déploiement et le suivi en conditions réelles. Chaque mode remplit un objectif spécifique et est conçu pour vous offrir la flexibilité et l'efficacité nécessaires pour différentes tâches et cas d'utilisation. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/j8uQc0qB91s?si=dhnGKgqvs7nPgeaM" |
||||
title="Lecteur vidéo YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Regardez :</strong> Tutoriel sur les modes Ultralytics : Entraînement, Validation, Prédiction, Exportation & Benchmark. |
||||
</p> |
||||
|
||||
### Aperçu des Modes |
||||
|
||||
Comprendre les différents **modes** pris en charge par Ultralytics YOLOv8 est crucial pour tirer le maximum de vos modèles : |
||||
|
||||
- **Mode d'entraînement (Train)** : Affinez votre modèle sur des jeux de données personnalisés ou préchargés. |
||||
- **Mode de validation (Val)** : Un contrôle post-entraînement pour évaluer la performance du modèle. |
||||
- **Mode de prédiction (Predict)** : Déployez la puissance prédictive de votre modèle sur des données du monde réel. |
||||
- **Mode d'exportation (Export)** : Préparez votre modèle au déploiement dans différents formats. |
||||
- **Mode de suivi (Track)** : Étendez votre modèle de détection d'objets à des applications de suivi en temps réel. |
||||
- **Mode benchmark (Benchmark)** : Analysez la vitesse et la précision de votre modèle dans divers environnements de déploiement. |
||||
|
||||
Ce guide complet vise à vous donner un aperçu et des informations pratiques sur chaque mode, en vous aidant à exploiter tout le potentiel de YOLOv8. |
||||
|
||||
## [Entraînement (Train)](train.md) |
||||
|
||||
Le mode d'entraînement est utilisé pour entraîner un modèle YOLOv8 sur un jeu de données personnalisé. Dans ce mode, le modèle est entraîné en utilisant le jeu de données et les hyperparamètres spécifiés. Le processus d'entraînement implique l'optimisation des paramètres du modèle afin qu'il puisse prédire avec précision les classes et les emplacements des objets dans une image. |
||||
|
||||
[Exemples d'entraînement](train.md){ .md-button } |
||||
|
||||
## [Validation (Val)](val.md) |
||||
|
||||
Le mode de validation est utilisé pour valider un modèle YOLOv8 après qu'il ait été entraîné. Dans ce mode, le modèle est évalué sur un ensemble de validation pour mesurer sa précision et sa capacité de généralisation. Ce mode peut être utilisé pour ajuster les hyperparamètres du modèle afin d'améliorer ses performances. |
||||
|
||||
[Exemples de validation](val.md){ .md-button } |
||||
|
||||
## [Prédiction (Predict)](predict.md) |
||||
|
||||
Le mode de prédiction est utilisé pour faire des prédictions à l'aide d'un modèle YOLOv8 entraîné sur de nouvelles images ou vidéos. Dans ce mode, le modèle est chargé à partir d'un fichier de checkpoint, et l'utilisateur peut fournir des images ou vidéos pour effectuer l'inférence. Le modèle prédit les classes et les emplacements des objets dans les images ou vidéos fournies. |
||||
|
||||
[Exemples de prédiction](predict.md){ .md-button } |
||||
|
||||
## [Exportation (Export)](export.md) |
||||
|
||||
Le mode d'exportation est utilisé pour exporter un modèle YOLOv8 dans un format pouvant être utilisé pour le déploiement. Dans ce mode, le modèle est converti dans un format pouvant être utilisé par d'autres applications logicielles ou dispositifs matériels. Ce mode est pratique pour déployer le modèle dans des environnements de production. |
||||
|
||||
[Exemples d'exportation](export.md){ .md-button } |
||||
|
||||
## [Suivi (Track)](track.md) |
||||
|
||||
Le mode de suivi est utilisé pour suivre des objets en temps réel à l'aide d'un modèle YOLOv8. Dans ce mode, le modèle est chargé à partir d'un fichier de checkpoint, et l'utilisateur peut fournir un flux vidéo en direct pour effectuer le suivi d'objets en temps réel. Ce mode est utile pour des applications telles que les systèmes de surveillance ou les voitures autonomes. |
||||
|
||||
[Exemples de suivi](track.md){ .md-button } |
||||
|
||||
## [Benchmark (Benchmark)](benchmark.md) |
||||
|
||||
Le mode benchmark est utilisé pour profiler la vitesse et la précision de divers formats d'exportation pour YOLOv8. Les benchmarks fournissent des informations sur la taille du format exporté, ses métriques `mAP50-95` (pour la détection d'objets, la segmentation et la pose) ou `accuracy_top5` (pour la classification), et le temps d'inférence en millisecondes par image pour différents formats d'exportation comme ONNX, OpenVINO, TensorRT et autres. Ces informations peuvent aider les utilisateurs à choisir le format d'export optimal pour leur cas d'utilisation spécifique en fonction de leurs exigences de vitesse et de précision. |
||||
|
||||
[Exemples de benchmark](benchmark.md){ .md-button } |
||||
@ -1,227 +0,0 @@ |
||||
--- |
||||
comments: true |
||||
description: Découvrez comment utiliser le mode de prédiction YOLOv8 pour diverses tâches. Apprenez sur différentes sources d'inférence comme des images, vidéos et formats de données. |
||||
keywords: Ultralytics, YOLOv8, mode de prédiction, sources d'inférence, tâches de prédiction, mode streaming, traitement d'images, traitement vidéo, apprentissage automatique, IA |
||||
--- |
||||
|
||||
# Prédiction de Modèle avec Ultralytics YOLO |
||||
|
||||
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Écosystème et intégrations Ultralytics YOLO"> |
||||
|
||||
## Introduction |
||||
|
||||
Dans l'univers de l'apprentissage automatique et de la vision par ordinateur, le processus de donner du sens aux données visuelles est appelé 'inférence' ou 'prédiction'. Ultralytics YOLOv8 propose une fonctionnalité puissante connue sous le nom de **mode de prédiction** adapté pour l'inférence en temps réel et haute performance sur une large gamme de sources de données. |
||||
|
||||
<p align="center"> |
||||
<br> |
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/QtsI0TnwDZs?si=ljesw75cMO2Eas14" |
||||
title="Lecteur vidéo YouTube" frameborder="0" |
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
||||
allowfullscreen> |
||||
</iframe> |
||||
<br> |
||||
<strong>Regardez :</strong> Comment Extraire les Sorties du Modèle Ultralytics YOLOv8 pour des Projets Personnalisés. |
||||
</p> |
||||
|
||||
## Applications Réelles |
||||
|
||||
| Fabrication | Sports | Sécurité | |
||||
|:---------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------------------:| |
||||
|  |  |  | |
||||
| Détection des Pièces de Véhicules | Détection des Joueurs de Football | Détection de Chutes de Personnes | |
||||
|
||||
## Pourquoi Utiliser Ultralytics YOLO pour l'Inférence ? |
||||
|
||||
Voici pourquoi vous devriez considérer le mode de prédiction YOLOv8 pour vos besoins variés en inférence : |
||||
|
||||
- **Polyvalence :** Capable de faire des inférences sur des images, des vidéos et même des flux en direct. |
||||
- **Performance :** Conçu pour le traitement en temps réel à grande vitesse sans sacrifier la précision. |
||||
- **Facilité d'Utilisation :** Interfaces Python et CLI intuitives pour un déploiement et des tests rapides. |
||||
- **Très Personnalisable :** Divers paramètres et réglages pour ajuster le comportement d'inférence du modèle selon vos besoins spécifiques. |
||||
|
||||
### Caractéristiques Clés du Mode de Prédiction |
||||
|
||||
Le mode de prédiction YOLOv8 est conçu pour être robuste et polyvalent, avec des fonctionnalités telles que : |
||||
|
||||
- **Compatibilité avec Plusieurs Sources de Données :** Que vos données soient sous forme d'images individuelles, d'une collection d'images, de fichiers vidéo ou de flux vidéo en temps réel, le mode de prédiction répond à vos besoins. |
||||
- **Mode Streaming :** Utilisez la fonctionnalité de streaming pour générer un générateur efficace en termes de mémoire d'objets `Results`. Activez-le en réglant `stream=True` dans la méthode d'appel du prédicteur. |
||||
- **Traitement par Lots :** La capacité de traiter plusieurs images ou trames vidéo dans un seul lot, accélérant ainsi le temps d'inférence. |
||||
- **Facile à Intégrer :** S'intègre facilement dans les pipelines de données existants et autres composants logiciels, grâce à son API souple. |
||||
|
||||
Les modèles YOLO d'Ultralytics renvoient soit une liste d'objets `Results` Python, soit un générateur Python efficace en termes de mémoire d'objets `Results` lorsque `stream=True` est passé au modèle pendant l'inférence : |
||||
|
||||
!!! Example "Prédire" |
||||
|
||||
=== "Renvoie une liste avec `stream=False`" |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle |
||||
model = YOLO('yolov8n.pt') # modèle YOLOv8n pré-entraîné |
||||
|
||||
# Exécuter une inférence par lots sur une liste d'images |
||||
results = model(['im1.jpg', 'im2.jpg']) # renvoie une liste d'objets Results |
||||
|
||||
# Traiter la liste des résultats |
||||
for result in results: |
||||
boxes = result.boxes # Objet Boxes pour les sorties bbox |
||||
masks = result.masks # Objet Masks pour les masques de segmentation |
||||
keypoints = result.keypoints # Objet Keypoints pour les sorties de pose |
||||
probs = result.probs # Objet Probs pour les sorties de classification |
||||
``` |
||||
|
||||
=== "Renvoie un générateur avec `stream=True`" |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle |
||||
model = YOLO('yolov8n.pt') # modèle YOLOv8n pré-entraîné |
||||
|
||||
# Exécuter une inférence par lots sur une liste d'images |
||||
results = model(['im1.jpg', 'im2.jpg'], stream=True) # renvoie un générateur d'objets Results |
||||
|
||||
# Traiter le générateur de résultats |
||||
for result in results: |
||||
boxes = result.boxes # Objet Boxes pour les sorties bbox |
||||
masks = result.masks # Objet Masks pour les masques de segmentation |
||||
keypoints = result.keypoints # Objet Keypoints pour les sorties de pose |
||||
probs = result.probs # Objet Probs pour les sorties de classification |
||||
``` |
||||
|
||||
## Sources d'Inférence |
||||
|
||||
YOLOv8 peut traiter différents types de sources d'entrée pour l'inférence, comme illustré dans le tableau ci-dessous. Les sources incluent des images statiques, des flux vidéos et divers formats de données. Le tableau indique également si chaque source peut être utilisée en mode streaming avec l'argument `stream=True` ✅. Le mode streaming est bénéfique pour traiter des vidéos ou des flux en direct car il crée un générateur de résultats au lieu de charger tous les cadres en mémoire. |
||||
|
||||
!!! astuce "Astuce" |
||||
|
||||
Utilisez `stream=True` pour traiter des vidéos longues ou des jeux de données volumineux afin de gérer efficacement la mémoire. Quand `stream=False`, les résultats pour tous les cadres ou points de données sont stockés en mémoire, ce qui peut rapidement s'accumuler et provoquer des erreurs de mémoire insuffisante pour de grandes entrées. En revanche, `stream=True` utilise un générateur, qui ne garde que les résultats du cadre ou point de données actuel en mémoire, réduisant considérablement la consommation de mémoire et prévenant les problèmes de mémoire insuffisante. |
||||
|
||||
| Source | Argument | Type | Notes | |
||||
|-----------------|--------------------------------------------|-----------------|------------------------------------------------------------------------------------------------------------------------------| |
||||
| image | `'image.jpg'` | `str` ou `Path` | Fichier image unique. | |
||||
| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL vers une image. | |
||||
| capture d'écran | `'screen'` | `str` | Prendre une capture d'écran. | |
||||
| PIL | `Image.open('im.jpg')` | `PIL.Image` | Format HWC avec canaux RGB. | |
||||
| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Format HWC avec canaux BGR `uint8 (0-255)`. | |
||||
| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Format HWC avec canaux BGR `uint8 (0-255)`. | |
||||
| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Format BCHW avec canaux RGB `float32 (0.0-1.0)`. | |
||||
| CSV | `'sources.csv'` | `str` ou `Path` | Fichier CSV contenant des chemins vers des images, vidéos ou répertoires. | |
||||
| vidéo ✅ | `'video.mp4'` | `str` ou `Path` | Fichier vidéo dans des formats comme MP4, AVI, etc. | |
||||
| répertoire ✅ | `'chemin/'` | `str` ou `Path` | Chemin vers un répertoire contenant des images ou des vidéos. | |
||||
| motif global ✅ | `'chemin/*.jpg'` | `str` | Motif glob pour faire correspondre plusieurs fichiers. Utilisez le caractère `*` comme joker. | |
||||
| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL vers une vidéo YouTube. | |
||||
| flux ✅ | `'rtsp://exemple.com/media.mp4'` | `str` | URL pour des protocoles de streaming comme RTSP, RTMP, TCP, ou une adresse IP. | |
||||
| multi-flux ✅ | `'liste.streams'` | `str` ou `Path` | Fichier texte `*.streams` avec une URL de flux par ligne, c'est-à-dire que 8 flux s'exécuteront avec une taille de lot de 8. | |
||||
|
||||
Ci-dessous des exemples de code pour utiliser chaque type de source : |
||||
|
||||
!!! Example "Sources de prédiction" |
||||
|
||||
=== "image" |
||||
Exécutez une inférence sur un fichier image. |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Définir le chemin vers le fichier image |
||||
source = 'chemin/vers/image.jpg' |
||||
|
||||
# Exécuter une inférence sur la source |
||||
results = model(source) # liste d'objets Results |
||||
``` |
||||
|
||||
=== "capture d'écran" |
||||
Exécutez une inférence sur le contenu actuel de l'écran sous forme de capture d'écran. |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Définir la capture d'écran actuelle comme source |
||||
source = 'screen' |
||||
|
||||
# Exécuter une inférence sur la source |
||||
results = model(source) # liste d'objets Results |
||||
``` |
||||
|
||||
=== "URL" |
||||
Exécutez une inférence sur une image ou vidéo hébergée à distance via URL. |
||||
```python |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Définir l'URL d'une image ou vidéo distante |
||||
source = 'https://ultralytics.com/images/bus.jpg' |
||||
|
||||
# Exécuter une inférence sur la source |
||||
results = model(source) # liste d'objets Results |
||||
``` |
||||
|
||||
=== "PIL" |
||||
Exécutez une inférence sur une image ouverte avec la bibliothèque Python Imaging Library (PIL). |
||||
```python |
||||
from PIL import Image |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Ouvrir une image avec PIL |
||||
source = Image.open('chemin/vers/image.jpg') |
||||
|
||||
# Exécuter une inférence sur la source |
||||
results = model(source) # liste d'objets Results |
||||
``` |
||||
|
||||
=== "OpenCV" |
||||
Exécutez une inférence sur une image lue avec OpenCV. |
||||
```python |
||||
import cv2 |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Lire une image avec OpenCV |
||||
source = cv2.imread('chemin/vers/image.jpg') |
||||
|
||||
# Exécuter une inférence sur la source |
||||
results = model(source) # liste d'objets Results |
||||
``` |
||||
|
||||
=== "numpy" |
||||
Exécutez une inférence sur une image représentée sous forme de tableau numpy. |
||||
```python |
||||
import numpy as np |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Créer un tableau numpy aléatoire de forme HWC (640, 640, 3) avec des valeurs dans l'intervalle [0, 255] et de type uint8 |
||||
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') |
||||
|
||||
# Exécuter une inférence sur la source |
||||
results = model(source) # liste d'objets Results |
||||
``` |
||||
|
||||
=== "torch" |
||||
Exécutez une inférence sur une image représentée sous forme de tenseur PyTorch. |
||||
```python |
||||
import torch |
||||
from ultralytics import YOLO |
||||
|
||||
# Charger un modèle YOLOv8n pré-entraîné |
||||
model = YOLO('yolov8n.pt') |
||||
|
||||
# Créer un tenseur aléatoire torch de forme BCHW (1, 3, 640, 640) avec des valeurs dans l'intervalle [0, 1] et de type float32 |
||||
source = torch.rand(1, 3, 640, 640, dtype=torch.float32) |
||||
|
||||
# Exécuter une inférence sur la source |
||||
results = model(source) # liste d'objets Results |
||||
``` |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue