HongChuang/ultralytics-ascend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

Add Docs languages zh, es, ru, pt, fr, de, ja, ko (#6316)

Browse source 
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
Glenn Jocher 2023-11-13 18:18:31 +01:00 • committed by GitHub
parent e3a538bbde
commit 48e70f0921
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
144 changed files with 17632 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

172
docs/fr/tasks/classify.md Normal file
View file

@ -0,0 +1,172 @@
---
comments: true
description: Apprenez-en davantage sur les modèles de classification d'images YOLOv8 Classify. Obtenez des informations détaillées sur la liste des modèles pré-entraînés et comment entraîner, valider, prédire et exporter des modèles.
keywords: Ultralytics, YOLOv8, Classification d'images, Modèles pré-entraînés, YOLOv8n-cls, Entraînement, Validation, Prédiction, Exportation de modèles
---
# Classification d'images
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418606-adf35c62-2e11-405d-84c6-b84e7d013804.png" alt="Exemples de classification d'images">
La classification d'images est la tâche la plus simple des trois et consiste à classer une image entière dans l'une d'un ensemble de classes prédéfinies.
Le résultat d'un classificateur d'images est une étiquette de classe unique et un score de confiance. La classification d'images est utile lorsque vous avez besoin de savoir seulement à quelle classe appartient une image et que vous n'avez pas besoin de connaître l'emplacement des objets de cette classe ou leur forme exacte.
!!! tip "Astuce"
Les modèles YOLOv8 Classify utilisent le suffixe `-cls`, par exemple `yolov8n-cls.pt` et sont pré-entraînés sur [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
Les modèles Classify pré-entraînés YOLOv8 sont présentés ici. Les modèles Detect, Segment et Pose sont pré-entraînés sur le dataset [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le dataset [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
Les [modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement depuis la dernière version Ultralytics [release](https://github.com/ultralytics/assets/releases) lors de la première utilisation.
| 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) | params<br><sup>(M) | FLOPs<br><sup>(B) à 640 |
|----------------------------------------------------------------------------------------------|-------------------------|------------------|------------------|----------------------------------|---------------------------------------|--------------------|-------------------------|
| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
- Les valeurs **acc** sont les précisions des modèles sur le jeu de données de validation d'[ImageNet](https://www.image-net.org/).
<br>Pour reproduire : `yolo val classify data=path/to/ImageNet device=0`
- Les **vitesses** sont calculées sur les images de validation d'ImageNet à l'aide d'une instance [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
<br>Pour reproduire : `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
## Entraînement
Entraînez le modèle YOLOv8n-cls sur le dataset MNIST160 pendant 100 époques avec une taille d'image de 64. Pour une liste complète des arguments disponibles, consultez la page [Configuration](../../usage/cfg.md).
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-cls.yaml') # construire un nouveau modèle à partir du YAML
model = YOLO('yolov8n-cls.pt') # charger un modèle pré-entraîné (recommandé pour l'entraînement)
model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construire à partir du YAML et transférer les poids
# Entraîner le modèle
results = model.train(data='mnist160', epochs=100, imgsz=64)
```
=== "CLI"
```bash
# Construire un nouveau modèle à partir du YAML et commencer l'entraînement à partir de zéro
yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
# Commencer l'entraînement à partir d'un modèle *.pt pré-entraîné
yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
# Construire un nouveau modèle à partir du YAML, transférer les poids pré-entraînés et commencer l'entraînement
yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
```
### Format du dataset
Le format du dataset de classification YOLO peut être trouvé en détails dans le [Guide des Datasets](../../datasets/classify/index.md).
## Validation
Validez la précision du modèle YOLOv8n-cls entraîné sur le dataset MNIST160. Aucun argument n'est nécessaire car le `modèle` conserve ses données d'entraînement et arguments en tant qu'attributs du modèle.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-cls.pt') # charger un modèle officiel
model = YOLO('path/to/best.pt') # charger un modèle personnalisé
# Valider le modèle
metrics = model.val() # aucun argument nécessaire, les données et les paramètres sont mémorisés
metrics.top1 # précision top 1
metrics.top5 # précision top 5
```
=== "CLI"
```bash
yolo classify val model=yolov8n-cls.pt # valider le modèle officiel
yolo classify val model=path/to/best.pt # valider le modèle personnalisé
```
## Prédiction
Utilisez un modèle YOLOv8n-cls entraîné pour exécuter des prédictions sur des images.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-cls.pt') # charger un modèle officiel
model = YOLO('path/to/best.pt') # charger un modèle personnalisé
# Prédire avec le modèle
results = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image
```
=== "CLI"
```bash
yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # prédiction avec le modèle officiel
yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # prédiction avec le modèle personnalisé
```
Voir les détails complets du mode `predict` sur la page [Prédire](https://docs.ultralytics.com/modes/predict/).
## Exportation
Exportez un modèle YOLOv8n-cls dans un format différent comme ONNX, CoreML, etc.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-cls.pt') # charger un modèle officiel
model = YOLO('path/to/best.pt') # charger un modèle entraîné personnalisé
# Exporter le modèle
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n-cls.pt format=onnx # exporter le modèle officiel
yolo export model=path/to/best.pt format=onnx # exporter le modèle entraîné personnalisé
```
Les formats d'exportation disponibles pour YOLOv8-cls sont présentés dans le tableau ci-dessous. Vous pouvez prédire ou valider directement sur les modèles exportés, par exemple `yolo predict model=yolov8n-cls.onnx`. Des exemples d'utilisation sont présentés pour votre modèle une fois l'exportation terminée.
| Format | Argument `format` | Modèle | Métadonnées | Arguments |
|--------------------------------------------------------------------|-------------------|-------------------------------|-------------|-----------------------------------------------------|
| [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-into/) | `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` |
Voir les détails complets de l'`exportation` sur la page [Export](https://docs.ultralytics.com/modes/export/).

184
docs/fr/tasks/detect.md Normal file
View file

@ -0,0 +1,184 @@
---
comments: true
description: Documentation officielle pour YOLOv8 par Ultralytics. Apprenez comment entraîner, valider, prédire et exporter des modèles dans différents formats. Incluant des statistiques de performances détaillées.
keywords: YOLOv8, Ultralytics, détection d'objets, modèles pré-entraînés, entraînement, validation, prédiction, exportation de modèles, COCO, ImageNet, PyTorch, ONNX, CoreML
---
# Détection d'Objets
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418624-5785cb93-74c9-4541-9179-d5c6782d491a.png" alt="Exemples de détection d'objets">
La détection d'objets est une tâche qui implique l'identification de l'emplacement et de la classe des objets dans une image ou un flux vidéo.
La sortie d'un détecteur d'objets est un ensemble de boîtes englobantes qui entourent les objets de l'image, accompagnées de libellés de classe et de scores de confiance pour chaque boîte. La détection d'objets est un bon choix lorsque vous avez besoin d'identifier des objets d'intérêt dans une scène, mais que vous n'avez pas besoin de connaître exactement où se trouve l'objet ou sa forme exacte.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/5ku7npMrW40?si=6HQO1dDXunV8gekh"
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> Détection d'Objets avec le Modèle Pré-entraîné Ultralytics YOLOv8.
</p>
!!! tip "Conseil"
Les modèles Detect YOLOv8 sont les modèles YOLOv8 par défaut, c.-à-d. `yolov8n.pt` et sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
Les modèles pré-entraînés Detect YOLOv8 sont présentés ici. Les modèles Detect, Segment, et Pose sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le jeu de données [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
[Les modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement à partir de la dernière [version](https://github.com/ultralytics/assets/releases) d'Ultralytics lors de la première utilisation.
| 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/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
- Les valeurs de **mAP<sup>val</sup>** sont pour un seul modèle à une seule échelle sur le jeu de données [COCO val2017](http://cocodataset.org).
<br>Reproductible avec `yolo val detect data=coco.yaml device=0`
- La **Vitesse** est moyennée sur les images COCO val en utilisant une instance [Amazon EC2 P4d](https://aws.amazon.com/fr/ec2/instance-types/p4/).
<br>Reproductible avec `yolo val detect data=coco128.yaml batch=1 device=0|cpu`
## Entraînement
Entraînez le modèle YOLOv8n sur le jeu de données COCO128 pendant 100 époques à la taille d'image de 640. Pour une liste complète des arguments disponibles, consultez la page [Configuration](../../usage/cfg.md).
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n.yaml') # construire un nouveau modèle à partir de YAML
model = YOLO('yolov8n.pt') # charger un modèle pré-entraîné (recommandé pour l'entraînement)
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construire à partir de YAML et transférer les poids
# Entraîner le modèle
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
```
=== "CLI"
```bash
# Construire un nouveau modèle à partir de YAML et commencer l'entraînement à partir de zéro
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
# Commencer l'entraînement à partir d'un modèle *.pt pré-entraîné
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
# Construire un nouveau modèle à partir de YAML, transférer les poids pré-entraînés et commencer l'entraînement
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
```
### Format des données
Le format des jeux de données de détection YOLO est détaillé dans le [Guide des Jeux de Données](../../datasets/detect/index.md). Pour convertir votre jeu de données existant depuis d'autres formats (comme COCO, etc.) vers le format YOLO, veuillez utiliser l'outil [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) par Ultralytics.
## Validation
Validez la précision du modèle YOLOv8n entraîné sur le jeu de données COCO128. Aucun argument n'est nécessaire puisque le `modèle` conserve ses `données` d'entraînement et arguments en tant qu'attributs du modèle.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n.pt') # charger un modèle officiel
model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé
# Valider le modèle
metrics = model.val() # pas d'arguments nécessaires, jeu de données et paramètres enregistrés
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # une liste contenant map50-95 de chaque catégorie
```
=== "CLI"
```bash
yolo detect val model=yolov8n.pt # valider le modèle officiel
yolo detect val model=chemin/vers/best.pt # valider le modèle personnalisé
```
## Prédiction
Utilisez un modèle YOLOv8n entraîné pour exécuter des prédictions sur des images.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n.pt') # charger un modèle officiel
model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé
# Prédire avec le modèle
results = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image
```
=== "CLI"
```bash
yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec le modèle officiel
yolo detect predict model=chemin/vers/best.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec le modèle personnalisé
```
Consultez les détails complets du mode `predict` sur la page [Prédire](https://docs.ultralytics.com/modes/predict/).
## Exportation
Exportez un modèle YOLOv8n dans un format différent tel que ONNX, CoreML, etc.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n.pt') # charger un modèle officiel
model = YOLO('chemin/vers/best.pt') # charger un modèle entraîné personnalisé
# Exporter le modèle
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n.pt format=onnx # exporter le modèle officiel
yolo export model=chemin/vers/best.pt format=onnx # exporter le modèle entraîné personnalisé
```
Les formats d'exportation YOLOv8 disponibles sont présentés dans le tableau ci-dessous. Vous pouvez directement prédire ou valider sur des modèles exportés, c'est-à-dire `yolo predict model=yolov8n.onnx`. Des exemples d'utilisation sont présentés pour votre modèle après l'exportation complète.
| 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` |
| [Modèle TF Enregistré](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
| [GraphDef TF](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` |
| [TPU Edge TF](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 tous les détails `export` sur la page [Exporter](https://docs.ultralytics.com/modes/export/).

55
docs/fr/tasks/index.md Normal file
View file

@ -0,0 +1,55 @@
---
comments: true
description: Découvrez les tâches fondamentales de vision par ordinateur que YOLOv8 peut effectuer, y compris la détection, la segmentation, la classification et l'estimation de la pose. Comprenez leur utilité dans vos projets d'IA.
keywords: Ultralytics, YOLOv8, Détection, Segmentation, Classification, Estimation de la Pose, Cadre IA, Tâches de Vision par Ordinateur
---
# Tâches d'Ultralytics YOLOv8
<br>
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png" alt="Tâches prises en charge par Ultralytics YOLO">
YOLOv8 est un cadre d'intelligence artificielle qui prend en charge de multiples tâches de **vision par ordinateur**. Le cadre peut être utilisé pour effectuer de la [détection](detect.md), de la [segmentation](segment.md), de la [classification](classify.md) et de l'estimation de la [pose](pose.md). Chacune de ces tâches a un objectif et un cas d'utilisation différents.
!!! note
🚧 Notre documentation multilingue est actuellement en construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/NAs-cfq9BDw"
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> Explorez les Tâches YOLO Ultralytics : Détection d'Objets, Segmentation, Suivi et Estimation de la Pose.
</p>
## [Détection](detect.md)
La détection est la tâche principale prise en charge par YOLOv8. Elle implique de détecter des objets dans une image ou une trame vidéo et de dessiner des boîtes englobantes autour d'eux. Les objets détectés sont classés dans différentes catégories en fonction de leurs caractéristiques. YOLOv8 peut détecter plusieurs objets dans une seule image ou trame vidéo avec une grande précision et rapidité.
[Exemples de Détection](detect.md){ .md-button .md-button--primary}
## [Segmentation](segment.md)
La segmentation est une tâche qui implique de segmenter une image en différentes régions en fonction du contenu de l'image. Chaque région se voit attribuer une étiquette en fonction de son contenu. Cette tâche est utile dans des applications telles que la segmentation d'image et l'imagerie médicale. YOLOv8 utilise une variante de l'architecture U-Net pour effectuer la segmentation.
[Exemples de Segmentation](segment.md){ .md-button .md-button--primary}
## [Classification](classify.md)
La classification est une tâche qui implique de classer une image dans différentes catégories. YOLOv8 peut être utilisé pour classifier des images en fonction de leur contenu. Il utilise une variante de l'architecture EfficientNet pour effectuer la classification.
[Exemples de Classification](classify.md){ .md-button .md-button--primary}
## [Pose](pose.md)
La détection de pose/points clés est une tâche qui implique de détecter des points spécifiques dans une image ou une trame vidéo. Ces points sont appelés points clés et sont utilisés pour suivre le mouvement ou pour l'estimation de la pose. YOLOv8 peut détecter des points clés dans une image ou une trame vidéo avec une grande précision et rapidité.
[Exemples de Pose](pose.md){ .md-button .md-button--primary}
## Conclusion
YOLOv8 prend en charge de multiples tâches, y compris la détection, la segmentation, la classification et la détection de points clés. Chacune de ces tâches a des objectifs et des cas d'utilisation différents. En comprenant les différences entre ces tâches, vous pouvez choisir la tâche appropriée pour votre application de vision par ordinateur.

176
docs/fr/tasks/pose.md Normal file
View file

@ -0,0 +1,176 @@
---
comments: true
description: Apprenez à utiliser Ultralytics YOLOv8 pour des tâches d'estimation de pose. Trouvez des modèles pré-entraînés, apprenez à entraîner, valider, prédire et exporter vos propres modèles.
keywords: Ultralytics, YOLO, YOLOv8, estimation de pose, détection de points clés, détection d'objet, modèles pré-entraînés, apprentissage automatique, intelligence artificielle
---
# Estimation de Pose
![Estimation de pose exemples](https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png)
L'estimation de pose est une tâche qui consiste à identifier l'emplacement de points spécifiques dans une image, souvent appelés points clés. Ces points clés peuvent représenter différentes parties de l'objet telles que les articulations, les repères ou d'autres caractéristiques distinctives. L'emplacement des points clés est généralement représenté par un ensemble de coordonnées 2D `[x, y]` ou 3D `[x, y, visible]`.
La sortie d'un modèle d'estimation de pose est un ensemble de points représentant les points clés sur un objet dans l'image, généralement accompagnés des scores de confiance pour chaque point. L'estimation de pose est un bon choix lorsque vous avez besoin d'identifier des parties spécifiques d'un objet dans une scène, et leur emplacement les uns par rapport aux autres.
![Regardez : Estimation de Pose avec Ultralytics YOLOv8](https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ)
!!! astuce "Conseil"
Les modèles YOLOv8 _pose_ utilisent le suffixe `-pose`, c'est-à-dire `yolov8n-pose.pt`. Ces modèles sont entraînés sur le jeu de données [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) et conviennent à une variété de tâches d'estimation de pose.
## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
Les modèles Pose pré-entraînés YOLOv8 sont montrés ici. Les modèles Detect, Segment et Pose sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le jeu de données [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
Les [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement à partir de la dernière version d'Ultralytics [release](https://github.com/ultralytics/assets/releases) lors de la première utilisation.
| 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) | params<br><sup>(M) | FLOPs<br><sup>(B) |
|------------------------------------------------------------------------------------------------------|-------------------------|-----------------------|--------------------|----------------------------------|---------------------------------------|--------------------|-------------------|
| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
- Les valeurs de **mAP<sup>val</sup>** sont pour un seul modèle à une seule échelle sur le jeu de données [COCO Keypoints val2017](http://cocodataset.org).
<br>Reproduire avec `yolo val pose data=coco-pose.yaml device=0`
- La **vitesse** moyenne sur les images de validation COCO en utilisant une instance [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
<br>Reproduire avec `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`
## Entraînement
Entraînez un modèle YOLOv8-pose sur le jeu de données COCO128-pose.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-pose.yaml') # construire un nouveau modèle à partir du YAML
model = YOLO('yolov8n-pose.pt') # charger un modèle pré-entraîné (recommandé pour l'entraînement)
model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # construire à partir du YAML et transférer les poids
# Entraîner le modèle
résultats = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
```
=== "CLI"
```bash
# Construire un nouveau modèle à partir du YAML et commencer l'entraînement à partir de zéro
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
# Commencer l'entraînement à partir d'un modèle *.pt pré-entraîné
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
# Construire un nouveau modèle à partir du YAML, transférer les poids pré-entraînés et commencer l'entraînement
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
```
### Format du jeu de données
Le format du jeu de données YOLO pose peut être trouvé en détail dans le [Guide des jeux de données](../../datasets/pose/index.md). Pour convertir votre jeu de données existant à partir d'autres formats (comme COCO, etc.) vers le format YOLO, veuillez utiliser l'outil [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) d'Ultralytics.
## Val
Validez la précision du modèle YOLOv8n-pose entraîné sur le jeu de données COCO128-pose. Aucun argument n'est nécessaire car le `modèle` conserve ses données d'entraînement et arguments en tant qu'attributs du modèle.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-pose.pt') # charger un modèle officiel
model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé
# Valider le modèle
métriques = model.val() # aucun argument nécessaire, jeu de données et paramètres mémorisés
métriques.box.map # map50-95
métriques.box.map50 # map50
métriques.box.map75 # map75
métriques.box.maps # une liste contenant map50-95 de chaque catégorie
```
=== "CLI"
```bash
yolo pose val model=yolov8n-pose.pt # val modèle officiel
yolo pose val model=chemin/vers/best.pt # val modèle personnalisé
```
## Prédiction
Utilisez un modèle YOLOv8n-pose entraîné pour exécuter des prédictions sur des images.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-pose.pt') # charger un modèle officiel
model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé
# Prédire avec le modèle
résultats = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image
```
=== "CLI"
```bash
yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec modèle officiel
yolo pose predict model=chemin/vers/best.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec modèle personnalisé
```
Consultez les détails complets du mode `predict` sur la page [Prédire](https://docs.ultralytics.com/modes/predict/).
## Exportation
Exportez un modèle YOLOv8n Pose dans un autre format tel que ONNX, CoreML, etc.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-pose.pt') # charger un modèle officiel
model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé entraîné
# Exporter le modèle
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n-pose.pt format=onnx # exporter modèle officiel
yolo export model=chemin/vers/best.pt format=onnx # exporter modèle personnalisé entraîné
```
Les formats d'exportation YOLOv8-pose disponibles sont dans le tableau ci-dessous. Vous pouvez prédire ou valider directement sur des modèles exportés, par exemple `yolo predict model=yolov8n-pose.onnx`. Des exemples d'utilisation sont montrés pour votre modèle après la fin de l'exportation.
| Format | Argument `format` | Modèle | Métadonnées | Arguments |
|--------------------------------------------------------------------|-------------------|--------------------------------|-------------|-----------------------------------------------------|
| [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`, `dynamic`, `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`, `dynamic`, `simplify`, `workspace` |
| [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` |
Consultez les détails complets de `export` sur la page [Exporter](https://docs.ultralytics.com/modes/export/).

189
docs/fr/tasks/segment.md Normal file
View file

@ -0,0 +1,189 @@
---
comments: true
description: Apprenez à utiliser les modèles de segmentation d'instance avec Ultralytics YOLO. Instructions pour la formation, la validation, la prédiction d'image et l'exportation de modèle.
keywords: yolov8, segmentation d'instance, Ultralytics, jeu de données COCO, segmentation d'image, détection d'objet, formation de modèle, validation de modèle, prédiction d'image, exportation de modèle
---
# Segmentation d'Instance
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418644-7df320b8-098d-47f1-85c5-26604d761286.png" alt="Exemples de segmentation d'instance">
La segmentation d'instance va plus loin que la détection d'objet et implique d'identifier des objets individuels dans une image et de les segmenter du reste de l'image.
Le résultat d'un modèle de segmentation d'instance est un ensemble de masques ou de contours qui délimitent chaque objet dans l'image, accompagnés d'étiquettes de classe et de scores de confiance pour chaque objet. La segmentation d'instance est utile lorsque vous avez besoin de savoir non seulement où se trouvent les objets dans une image, mais aussi quelle est leur forme exacte.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/o4Zd-IeMlSY?si=37nusCzDTd74Obsp"
title="Lecteur vidéo YouTube" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>Regarder :</strong> Exécutez la Segmentation avec le Modèle Ultralytics YOLOv8 Pré-Entraîné en Python.
</p>
!!! astuce "Astuce"
Les modèles YOLOv8 Segment utilisent le suffixe `-seg`, par exemple `yolov8n-seg.pt` et sont pré-entraînés sur [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
Les modèles Segment pré-entraînés YOLOv8 sont indiqués ici. Les modèles Detect, Segment et Pose sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le jeu de données [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
Les [modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement depuis la dernière [version](https://github.com/ultralytics/assets/releases) Ultralytics lors de la première utilisation.
| Modèle | Taille<br><sup>(pixels) | mAP<sup>boîte<br>50-95 | mAP<sup>masque<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/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
- Les valeurs **mAP<sup>val</sup>** sont pour un seul modèle à une seule échelle sur le jeu de données [COCO val2017](http://cocodataset.org).
<br>Pour reproduire, utilisez `yolo val segment data=coco.yaml device=0`
- **Vitesse** moyennée sur les images COCO val en utilisant une instance [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
<br>Pour reproduire, utilisez `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu`
## Formation
Entraînez YOLOv8n-seg sur le jeu de données COCO128-seg pendant 100 époques à la taille d'image 640. Pour une liste complète des arguments disponibles, consultez la page [Configuration](../../usage/cfg.md).
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-seg.yaml') # construire un nouveau modèle à partir du YAML
model = YOLO('yolov8n-seg.pt') # charger un modèle pré-entraîné (recommandé pour la formation)
model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # construire à partir du YAML et transférer les poids
# Entraîner le modèle
résultats = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
```
=== "CLI"
```bash
# Construire un nouveau modèle à partir du YAML et commencer la formation à partir de zéro
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
# Commencer la formation à partir d'un modèle *.pt pré-entraîné
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
# Construire un nouveau modèle à partir du YAML, transférer les poids pré-entraînés et commencer la formation
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
```
### Format des données
Le format des données de segmentation YOLO peut être trouvé en détail dans le [Guide du Jeu de Données](../../datasets/segment/index.md). Pour convertir votre jeu de données existant à partir d'autres formats (comme COCO, etc.) au format YOLO, veuillez utiliser l'outil [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) par Ultralytics.
## Validation
Validez la précision du modèle YOLOv8n-seg entraîné sur le jeu de données COCO128-seg. Aucun argument n'est nécessaire car le `modèle`
conserve ses données de formation et ses arguments comme attributs du modèle.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-seg.pt') # charger un modèle officiel
model = YOLO('chemin/vers/le/meilleur.pt') # charger un modèle personnalisé
# Valider le modèle
métriques = model.val() # aucun argument nécessaire, jeu de données et paramètres mémorisés
métriques.box.map # map50-95(B)
métriques.box.map50 # map50(B)
métriques.box.map75 # map75(B)
métriques.box.maps # une liste contient map50-95(B) de chaque catégorie
métriques.seg.map # map50-95(M)
métriques.seg.map50 # map50(M)
métriques.seg.map75 # map75(M)
métriques.seg.maps # une liste contient map50-95(M) de chaque catégorie
```
=== "CLI"
```bash
yolo segment val model=yolov8n-seg.pt # valider le modèle officiel
yolo segment val model=chemin/vers/le/meilleur.pt # valider le modèle personnalisé
```
## Prédiction
Utilisez un modèle YOLOv8n-seg entraîné pour effectuer des prédictions sur des images.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-seg.pt') # charger un modèle officiel
model = YOLO('chemin/vers/le/meilleur.pt') # charger un modèle personnalisé
# Prédire avec le modèle
résultats = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image
```
=== "CLI"
```bash
yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec le modèle officiel
yolo segment predict model=chemin/vers/le/meilleur.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec le modèle personnalisé
```
Voir les détails complets du mode `predict` sur la page [Predict](https://docs.ultralytics.com/modes/predict/).
## Exportation
Exportez un modèle YOLOv8n-seg vers un format différent comme ONNX, CoreML, etc.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n-seg.pt') # charger un modèle officiel
model = YOLO('chemin/vers/le/meilleur.pt') # charger un modèle entraîné personnalisé
# Exporter le modèle
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n-seg.pt format=onnx # exporter le modèle officiel
yolo export model=chemin/vers/le/meilleur.pt format=onnx # exporter le modèle entraîné personnalisé
```
Les formats d'exportation YOLOv8-seg disponibles sont dans le tableau ci-dessous. Vous pouvez prédire ou valider directement sur les modèles exportés, par exemple `yolo predict model=yolov8n-seg.onnx`. Des exemples d'utilisation sont présentés pour votre modèle après l'exportation.
| Format | Argument `format` | Modèle | Métadonnées | Arguments |
|--------------------------------------------------------------------|-------------------|-------------------------------|-------------|-----------------------------------------------------|
| [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` |
Voir les détails complets d'`export` sur la page [Export](https://docs.ultralytics.com/modes/export/).