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

94
docs/fr/modes/benchmark.md Normal file
View file

@ -0,0 +1,94 @@
---
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.
!!! 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/).

108
docs/fr/modes/export.md Normal file
View file

@ -0,0 +1,108 @@
---
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.
!!! 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` |

73
docs/fr/modes/index.md Normal file
View file

@ -0,0 +1,73 @@
---
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 .md-button--primary}
## [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 .md-button--primary}
## [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 .md-button--primary}
## [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 .md-button--primary}
## [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 .md-button--primary}
## [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 .md-button--primary}

226
docs/fr/modes/predict.md Normal file
View file

@ -0,0 +1,226 @@
---
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](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Détection des Joueurs de Football](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Détection de Chutes de Personnes](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) |
| 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 :
!!! exemple "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 :
!!! exemple "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

200
docs/fr/modes/track.md Normal file
View file

@ -0,0 +1,200 @@
---
comments: true
description: Apprenez à utiliser Ultralytics YOLO pour le suivi d'objets dans les flux vidéo. Guides pour utiliser différents traceurs et personnaliser les configurations de traceurs.
keywords: Ultralytics, YOLO, suivi d'objets, flux vidéo, BoT-SORT, ByteTrack, guide Python, guide CLI
---
# Suivi Multi-Objets avec Ultralytics YOLO
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418637-1d6250fd-1515-4c10-a844-a32818ae6d46.png" alt="Exemples de suivi multi-objets">
Le suivi d'objets dans le domaine de l'analyse vidéo est une tâche essentielle qui non seulement identifie l'emplacement et la classe des objets à l'intérieur de l'image, mais maintient également un identifiant unique pour chaque objet détecté au fur et à mesure que la vidéo progresse. Les applications sont illimitées, allant de la surveillance et de la sécurité à l'analytique sportive en temps réel.
## Pourquoi Choisir Ultralytics YOLO pour le Suivi d'Objet ?
La sortie des traceurs Ultralytics est cohérente avec la détection standard d'objets mais apporte la valeur ajoutée des identifiants d'objets. Cela facilite le suivi des objets dans les flux vidéo et effectue des analyses subséquentes. Voici pourquoi vous devriez envisager d'utiliser Ultralytics YOLO pour vos besoins de suivi d'objet :
- **Efficacité :** Traitez les flux vidéo en temps réel sans compromettre la précision.
- **Flexibilité :** Prend en charge de multiples algorithmes de suivi et configurations.
- **Facilité d'Utilisation :** API Python simple et options CLI pour une intégration et un déploiement rapides.
- **Personnalisabilité :** Facile à utiliser avec des modèles YOLO entraînés sur mesure, permettant une intégration dans des applications spécifiques au domaine.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/hHyHmOtmEgs?si=VNZtXmm45Nb9s-N-"
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 et suivi d'objets avec Ultralytics YOLOv8.
</p>
## Applications dans le Monde Réel
| Transport | Distribution | Aquaculture |
|:------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------:|
| ![Suivi de véhicules](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Suivi de personnes](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Suivi de poissons](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) |
| Suivi de Véhicules | Suivi de Personnes | Suivi de Poissons |
## Caractéristiques en Bref
Ultralytics YOLO étend ses fonctionnalités de détection d'objets pour fournir un suivi d'objets robuste et polyvalent :
- **Suivi en Temps Réel :** Suivi fluide d'objets dans des vidéos à fréquence d'images élevée.
- **Prise en Charge de Multiples Traceurs :** Choisissez parmi une variété d'algorithmes de suivi éprouvés.
- **Configurations de Traceurs Personnalisables :** Adaptez l'algorithme de suivi pour répondre à des exigences spécifiques en réglant divers paramètres.
## Traceurs Disponibles
Ultralytics YOLO prend en charge les algorithmes de suivi suivants. Ils peuvent être activés en passant le fichier de configuration YAML correspondant tel que `tracker=tracker_type.yaml` :
* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Utilisez `botsort.yaml` pour activer ce traceur.
* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Utilisez `bytetrack.yaml` pour activer ce traceur.
Le traceur par défaut est BoT-SORT.
## Suivi
Pour exécuter le traceur sur des flux vidéo, utilisez un modèle Detect, Segment ou Pose formé tel que YOLOv8n, YOLOv8n-seg et YOLOv8n-pose.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle officiel ou personnalisé
model = YOLO('yolov8n.pt') # Charger un modèle Detect officiel
model = YOLO('yolov8n-seg.pt') # Charger un modèle Segment officiel
model = YOLO('yolov8n-pose.pt') # Charger un modèle Pose officiel
model = YOLO('chemin/vers/best.pt') # Charger un modèle entraîné personnalisé
# Effectuer le suivi avec le modèle
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Suivi avec le traceur par défaut
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Suivi avec le traceur ByteTrack
```
=== "CLI"
```bash
# Effectuer le suivi avec divers modèles en utilisant l'interface en ligne de commande
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Detect officiel
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Segment officiel
yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Pose officiel
yolo track model=chemin/vers/best.pt source="https://youtu.be/LNwODJXcvt4" # Modèle entraîné personnalisé
# Suivi en utilisant le traceur ByteTrack
yolo track model=chemin/vers/best.pt tracker="bytetrack.yaml"
```
Comme on peut le voir dans l'utilisation ci-dessus, le suivi est disponible pour tous les modèles Detect, Segment et Pose exécutés sur des vidéos ou des sources de diffusion.
## Configuration
### Arguments de Suivi
La configuration du suivi partage des propriétés avec le mode Prédiction, telles que `conf`, `iou`, et `show`. Pour des configurations supplémentaires, référez-vous à la page [Predict](https://docs.ultralytics.com/modes/predict/) du modèle.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Configurer les paramètres de suivi et exécuter le traceur
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
```
=== "CLI"
```bash
# Configurer les paramètres de suivi et exécuter le traceur en utilisant l'interface en ligne de commande
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
```
### Sélection du Traceur
Ultralytics vous permet également d'utiliser un fichier de configuration de traceur modifié. Pour cela, faites simplement une copie d'un fichier de configuration de traceur (par exemple, `custom_tracker.yaml`) à partir de [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) et modifiez toute configuration (à l'exception du `tracker_type`) selon vos besoins.
!!! exemple ""
=== "Python"
```python
from ultralytics import YOLO
# Charger le modèle et exécuter le traceur avec un fichier de configuration personnalisé
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
```
=== "CLI"
```bash
# Charger le modèle et exécuter le traceur avec un fichier de configuration personnalisé en utilisant l'interface en ligne de commande
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
```
Pour une liste complète des arguments de suivi, référez-vous à la page [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers).
## Exemples Python
### Boucle de Persistance des Pistes
Voici un script Python utilisant OpenCV (`cv2`) et YOLOv8 pour exécuter le suivi d'objet sur des images vidéo. Ce script suppose toujours que vous avez déjà installé les packages nécessaires (`opencv-python` et `ultralytics`). L'argument `persist=True` indique au traceur que l'image ou la trame actuelle est la suivante dans une séquence et s'attend à ce que les pistes de l'image précédente soient présentes dans l'image actuelle.
!!! exemple "Boucle for streaming avec suivi"
```python
import cv2
from ultralytics import YOLO
# Charger le modèle YOLOv8
model = YOLO('yolov8n.pt')
# Ouvrir le fichier vidéo
video_path = "chemin/vers/video.mp4"
cap = cv2.VideoCapture(video_path)
# Parcourir les images vidéo
while cap.isOpened():
# Lire une image de la vidéo
success, frame = cap.read()
if success:
# Exécuter le suivi YOLOv8 sur l'image, en persistant les pistes entre les images
results = model.track(frame, persist=True)
# Visualiser les résultats sur l'image
annotated_frame = results[0].plot()
# Afficher l'image annotée
cv2.imshow("Suivi YOLOv8", annotated_frame)
# Interrompre la boucle si 'q' est pressée
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Interrompre la boucle si la fin de la vidéo est atteinte
break
# Relâcher l'objet de capture vidéo et fermer la fenêtre d'affichage
cap.release()
cv2.destroyAllWindows()
```
Veuillez noter le changement de `model(frame)` à `model.track(frame)`, qui active le suivi d'objet à la place de la simple détection. Ce script modifié exécutera le traceur sur chaque image de la vidéo, visualisera les résultats et les affichera dans une fenêtre. La boucle peut être quittée en appuyant sur 'q'.
## Contribuer de Nouveaux Traceurs
Êtes-vous compétent en suivi multi-objets et avez-vous réussi à implémenter ou adapter un algorithme de suivi avec Ultralytics YOLO ? Nous vous invitons à contribuer à notre section Traceurs sur [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) ! Vos applications et solutions dans le monde réel pourraient être inestimables pour les utilisateurs travaillant sur des tâches de suivi.
En contribuant à cette section, vous aidez à élargir l'éventail des solutions de suivi disponibles au sein du cadre Ultralytics YOLO, ajoutant une autre couche de fonctionnalité et d'utilité pour la communauté.
Pour initier votre contribution, veuillez vous référer à notre [Guide de Contribution](https://docs.ultralytics.com/help/contributing) pour des instructions complètes sur la soumission d'une Pull Request (PR) 🛠️. Nous sommes impatients de voir ce que vous apportez à la table !
Ensemble, améliorons les capacités de suivi de l'écosystème Ultralytics YOLO 🙏 !

206
docs/fr/modes/train.md Normal file
View file

@ -0,0 +1,206 @@
---
comments: true
description: Guide étape par étape pour entraîner des modèles YOLOv8 avec Ultralytics YOLO incluant des exemples d'entraînement mono-GPU et multi-GPU
keywords: Ultralytics, YOLOv8, YOLO, détection d'objet, mode entraînement, jeu de données personnalisé, entraînement GPU, multi-GPU, hyperparamètres, exemples CLI, exemples Python
---
# Entraînement de modèles avec Ultralytics YOLO
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO écosystème et intégrations">
## Introduction
L'entraînement d'un modèle d'apprentissage profond implique de lui fournir des données et d'ajuster ses paramètres afin qu'il puisse faire des prédictions précises. Le mode Entraînement de Ultralytics YOLOv8 est conçu pour un entraînement efficace et performant de modèles de détection d'objets, en utilisant pleinement les capacités du matériel moderne. Ce guide vise à couvrir tous les détails nécessaires pour commencer à entraîner vos propres modèles en utilisant l'ensemble robuste de fonctionnalités de YOLOv8.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
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 entraîner un modèle YOLOv8 sur votre jeu de données personnalisé dans Google Colab.
</p>
## Pourquoi choisir Ultralytics YOLO pour l'entraînement ?
Voici quelques raisons convaincantes de choisir le mode Entraînement de YOLOv8 :
- **Efficacité :** Optimisez l'utilisation de votre matériel, que vous soyez sur une configuration mono-GPU ou que vous échelonnier sur plusieurs GPUs.
- **Polyvalence :** Entraînez sur des jeux de données personnalisés en plus de ceux déjà disponibles comme COCO, VOC et ImageNet.
- **Convivialité :** Interfaces CLI et Python simples mais puissantes pour une expérience d'entraînement directe.
- **Flexibilité des hyperparamètres :** Un large éventail d'hyperparamètres personnalisables pour peaufiner les performances du modèle.
### Principales caractéristiques du mode Entraînement
Voici quelques caractéristiques remarquables du mode Entraînement de YOLOv8 :
- **Téléchargement automatique de jeux de données :** Les jeux de données standards comme COCO, VOC et ImageNet sont téléchargés automatiquement lors de la première utilisation.
- **Support multi-GPU :** Échelonnez vos efforts de formation de manière fluide sur plusieurs GPUs pour accélérer le processus.
- **Configuration des hyperparamètres :** La possibilité de modifier les hyperparamètres via des fichiers de configuration YAML ou des arguments CLI.
- **Visualisation et suivi :** Suivi en temps réel des métriques d'entraînement et visualisation du processus d'apprentissage pour de meilleures perspectives.
!!! tip "Astuce"
* Les jeux de données YOLOv8 comme COCO, VOC, ImageNet et bien d'autres se téléchargent automatiquement lors de la première utilisation, par exemple `yolo train data=coco.yaml`
## Exemples d'utilisation
Entraînez YOLOv8n sur le jeu de données COCO128 pendant 100 époques avec une taille d'image de 640. Le dispositif d'entraînement peut être spécifié à l'aide de l'argument `device`. Si aucun argument n'est passé, le GPU `device=0` sera utilisé s'il est disponible, sinon `device=cpu` sera utilisé. Consultez la section Arguments ci-dessous pour obtenir une liste complète des arguments d'entraînement.
!!! example "Exemple d'entraînement mono-GPU et CPU"
Le dispositif est déterminé automatiquement. Si un GPU est disponible, il sera utilisé, sinon l'entraînement commencera sur CPU.
=== "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 préentraîné *.pt
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
```
### Entraînement multi-GPU
L'entraînement multi-GPU permet une utilisation plus efficace des ressources matérielles disponibles en répartissant la charge d'entraînement sur plusieurs GPUs. Cette fonctionnalité est disponible via l'API Python et l'interface de ligne de commande. Pour activer l'entraînement multi-GPU, spécifiez les ID des dispositifs GPU que vous souhaitez utiliser.
!!! example "Exemple d'entraînement multi-GPU"
Pour s'entraîner avec 2 GPUs, les dispositifs CUDA 0 et 1, utilisez les commandes suivantes. Développez à des GPUs supplémentaires selon le besoin.
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n.pt') # charger un modèle préentraîné (recommandé pour l'entraînement)
# Entraîner le modèle avec 2 GPUs
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
```
=== "CLI"
```bash
# Commencer l'entraînement à partir d'un modèle préentraîné *.pt en utilisant les GPUs 0 et 1
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
```
### Entraînement MPS avec Apple M1 et M2
Avec le support pour les puces Apple M1 et M2 intégré dans les modèles Ultralytics YOLO, il est maintenant possible d'entraîner vos modèles sur des dispositifs utilisant le puissant framework Metal Performance Shaders (MPS). Le MPS offre un moyen performant d'exécuter des tâches de calcul et de traitement d'image sur le silicium personnalisé d'Apple.
Pour activer l'entraînement sur les puces Apple M1 et M2, vous devez spécifier 'mps' comme votre dispositif lors du lancement du processus d'entraînement. Voici un exemple de la manière dont vous pourriez le faire en Python et via la ligne de commande :
!!! example "Exemple d'entraînement MPS"
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n.pt') # charger un modèle préentraîné (recommandé pour l'entraînement)
# Entraîner le modèle avec MPS
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
```
=== "CLI"
```bash
# Commencer l'entraînement à partir d'un modèle préentraîné *.pt avec MPS
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
```
Tout en exploitant la puissance de calcul des puces M1/M2, cela permet un traitement plus efficace des tâches d'entraînement. Pour des conseils plus détaillés et des options de configuration avancée, veuillez consulter la [documentation MPS de PyTorch](https://pytorch.org/docs/stable/notes/mps.html).
## Journalisation
Lors de l'entraînement d'un modèle YOLOv8, il peut être précieux de suivre la performance du modèle au fil du temps. C'est là que la journalisation entre en jeu. YOLO d'Ultralytics prend en charge trois types de journaux - Comet, ClearML et TensorBoard.
Pour utiliser un journal, sélectionnez-le dans le menu déroulant ci-dessus et exécutez-le. Le journal choisi sera installé et initialisé.
### Comet
[Comet](https://www.comet.ml/site/) est une plateforme qui permet aux scientifiques de données et aux développeurs de suivre, comparer, expliquer et optimiser les expériences et les modèles. Elle offre des fonctionnalités telles que le suivi en temps réel des mesures, les différences de code et le suivi des hyperparamètres.
Pour utiliser Comet :
!!! example ""
=== "Python"
```python
# pip install comet_ml
import comet_ml
comet_ml.init()
```
N'oubliez pas de vous connecter à votre compte Comet sur leur site web et d'obtenir votre clé API. Vous devrez ajouter cela à vos variables d'environnement ou à votre script pour enregistrer vos expériences.
### ClearML
[ClearML](https://www.clear.ml/) est une plateforme open source qui automatise le suivi des expériences et aide à partager efficacement les ressources. Elle est conçue pour aider les équipes à gérer, exécuter et reproduire leur travail en ML plus efficacement.
Pour utiliser ClearML :
!!! example ""
=== "Python"
```python
# pip install clearml
import clearml
clearml.browser_login()
```
Après avoir exécuté ce script, vous devrez vous connecter à votre compte ClearML sur le navigateur et authentifier votre session.
### TensorBoard
[TensorBoard](https://www.tensorflow.org/tensorboard) est un ensemble d'outils de visualisation pour TensorFlow. Il vous permet de visualiser votre graphique TensorFlow, de tracer des mesures quantitatives sur l'exécution de votre graphique et de montrer des données supplémentaires comme des images qui le traversent.
Pour utiliser TensorBoard dans [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb) :
!!! example ""
=== "CLI"
```bash
load_ext tensorboard
tensorboard --logdir ultralytics/runs # remplacer par le répertoire 'runs'
```
Pour utiliser TensorBoard localement, exécutez la commande ci-dessous et consultez les résultats à l'adresse http://localhost:6006/.
!!! example ""
=== "CLI"
```bash
tensorboard --logdir ultralytics/runs # remplacer par le répertoire 'runs'
```
Cela chargera TensorBoard et le dirigera vers le répertoire où vos journaux d'entraînement sont sauvegardés.
Après avoir configuré votre journal, vous pouvez ensuite poursuivre l'entraînement de votre modèle. Toutes les métriques d'entraînement seront automatiquement enregistrées sur votre plateforme choisie, et vous pourrez accéder à ces journaux pour surveiller les performances de votre modèle au fil du temps, comparer différents modèles et identifier les domaines d'amélioration.

86
docs/fr/modes/val.md Normal file
View file

@ -0,0 +1,86 @@
---
comments: true
description: Guide de validation des modèles YOLOv8. Apprenez à évaluer la performance de vos modèles YOLO en utilisant les paramètres de validation et les métriques avec des exemples en Python et en CLI.
keywords: Ultralytics, YOLO Docs, YOLOv8, validation, évaluation de modèle, hyperparamètres, précision, métriques, Python, CLI
---
# Validation des 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
La validation est une étape cruciale dans le pipeline d'apprentissage automatique, vous permettant d'évaluer la qualité de vos modèles entraînés. Le mode Val dans Ultralytics YOLOv8 offre une gamme robuste d'outils et de métriques pour évaluer la performance de vos modèles de détection d'objets. Ce guide sert de ressource complète pour comprendre comment utiliser efficacement le mode Val pour assurer que vos modèles sont à la fois précis et fiables.
## Pourquoi valider avec Ultralytics YOLO ?
Voici pourquoi l'utilisation du mode Val de YOLOv8 est avantageuse :
- **Précision :** Obtenez des métriques précises telles que mAP50, mAP75 et mAP50-95 pour évaluer de manière exhaustive votre modèle.
- **Convenance :** Utilisez des fonctionnalités intégrées qui se souviennent des paramètres d'entraînement, simplifiant ainsi le processus de validation.
- **Flexibilité :** Validez votre modèle avec les mêmes jeux de données ou des jeux différents et des tailles d'image variées.
- **Réglage des hyperparamètres :** Utilisez les métriques de validation pour peaufiner votre modèle pour de meilleures performances.
### Caractéristiques clés du mode Val
Voici les fonctionnalités notables offertes par le mode Val de YOLOv8 :
- **Paramètres Automatisés :** Les modèles se souviennent de leurs configurations d'entraînement pour une validation simple.
- **Support Multi-métrique :** Évaluez votre modèle en fonction d'une gamme de métriques de précision.
- **CLI et API Python :** Choisissez entre l'interface en ligne de commande ou l'API Python en fonction de vos préférences pour la validation.
- **Compatibilité des Données :** Fonctionne de manière transparente avec les jeux de données utilisés pendant la phase d'entraînement ainsi qu'avec les jeux personnalisés.
!!! tip "Conseil"
* Les modèles YOLOv8 se souviennent automatiquement de leurs paramètres d'entraînement, vous pouvez donc facilement valider un modèle à la même taille d'image et sur le jeu de données original avec juste `yolo val model=yolov8n.pt` ou `model('yolov8n.pt').val()`
## Exemples d'utilisation
Validez la précision du modèle YOLOv8n entraîné sur le jeu de données COCO128. Aucun argument n'a besoin d'être passé car le `modèle` conserve ses `données` d'entraînement et arguments comme attributs du modèle. Consultez la section des arguments ci-dessous pour une liste complète des arguments d'exportation.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Charger un modèle
model = YOLO('yolov8n.pt') # charger un modèle officiel
model = YOLO('chemin/vers/meilleur.pt') # charger un modèle personnalisé
# Valider le modèle
metrics = model.val() # pas besoin d'arguments, jeu de données et paramètres mémorisé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 # val modèle officiel
yolo detect val model=chemin/vers/meilleur.pt # val modèle personnalisé
```
## Arguments
Les paramètres de validation pour les modèles YOLO font référence aux divers hyperparamètres et configurations utilisés pour évaluer la performance du modèle sur un jeu de données de validation. Ces paramètres peuvent affecter la performance, la vitesse et la précision du modèle. Certains paramètres de validation YOLO courants incluent la taille du lot, la fréquence à laquelle la validation est effectuée pendant l'entraînement et les métriques utilisées pour évaluer la performance du modèle. D'autres facteurs pouvant affecter le processus de validation incluent la taille et la composition du jeu de données de validation et la tâche spécifique pour laquelle le modèle est utilisé. Il est important de régler et d'expérimenter soigneusement ces paramètres pour s'assurer que le modèle fonctionne bien sur le jeu de données de validation et pour détecter et prévenir le surajustement.
| Clé | Valeur | Description |
|---------------|---------|------------------------------------------------------------------------------------------------|
| `data` | `None` | chemin vers le fichier de données, par exemple coco128.yaml |
| `imgsz` | `640` | taille des images d'entrée en tant qu'entier |
| `batch` | `16` | nombre d'images par lot (-1 pour AutoBatch) |
| `save_json` | `False` | sauvegarder les résultats dans un fichier JSON |
| `save_hybrid` | `False` | sauvegarder la version hybride des étiquettes (étiquettes + prédictions supplémentaires) |
| `conf` | `0.001` | seuil de confiance de l'objet pour la détection |
| `iou` | `0.6` | seuil d'intersection sur union (IoU) pour la NMS |
| `max_det` | `300` | nombre maximum de détections par image |
| `half` | `True` | utiliser la précision moitié (FP16) |
| `device` | `None` | appareil sur lequel exécuter, par exemple cuda device=0/1/2/3 ou device=cpu |
| `dnn` | `False` | utiliser OpenCV DNN pour l'inférence ONNX |
| `plots` | `False` | afficher les graphiques lors de la formation |
| `rect` | `False` | val rectangulaire avec chaque lot regroupé pour un minimum de rembourrage |
| `split` | `val` | fraction du jeu de données à utiliser pour la validation, par exemple 'val', 'test' ou 'train' |
|