Add Docs languages zh, es, ru, pt, fr, de, ja, ko (#6316)
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com> Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
Glenn Jocher
GitHub
parent
e3a538bbde
commit
48e70f0921
144 changed files with 17632 additions and 76 deletions
127
docs/fr/datasets/index.md
Normal file
127
docs/fr/datasets/index.md
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explorez divers ensembles de données de vision par ordinateur pris en charge par Ultralytics pour la détection d'objets, la segmentation, l'estimation de la pose, la classification d'images et le suivi multi-objets.
|
||||
keywords: vision par ordinateur, ensembles de données, Ultralytics, YOLO, détection d'objets, segmentation d'instance, estimation de la pose, classification d'images, suivi multi-objets
|
||||
---
|
||||
|
||||
# Aperçu des ensembles de données
|
||||
|
||||
Ultralytics fournit un soutien pour divers ensembles de données pour faciliter les tâches de vision par ordinateur telles que la détection, la segmentation d'instance, l'estimation de la pose, la classification et le suivi multi-objets. Ci-dessous se trouve une liste des principaux ensembles de données Ultralytics, suivie d'un résumé de chaque tâche de vision par ordinateur et des ensembles de données respectifs.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Notre documentation multilingue est actuellement en cours de construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏
|
||||
|
||||
## [Ensembles de données de détection](../../datasets/detect/index.md)
|
||||
|
||||
La détection d'objets par boîte englobante est une technique de vision par ordinateur qui consiste à détecter et localiser des objets dans une image en dessinant une boîte englobante autour de chaque objet.
|
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md) : Un ensemble de données contenant des données de suivi 3D et de prévision de mouvement dans des environnements urbains avec des annotations détaillées.
|
||||
- [COCO](../../datasets/detect/coco.md) : Un ensemble de données de grande échelle conçu pour la détection d'objets, la segmentation et l'annotation avec plus de 200K images étiquetées.
|
||||
- [COCO8](../../datasets/detect/coco8.md) : Contient les 4 premières images de COCO train et COCO val, adaptées pour des tests rapides.
|
||||
- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md) : Un ensemble de données d'images de têtes de blé recueillies dans le monde entier pour les tâches de détection et de localisation d'objets.
|
||||
- [Objects365](../../datasets/detect/objects365.md) : Un ensemble de données de grande qualité et à grande échelle pour la détection d'objets avec 365 catégories d'objets et plus de 600K images annotées.
|
||||
- [OpenImagesV7](../../datasets/detect/open-images-v7.md) : Un ensemble de données complet de Google avec 1.7M d'images d'entraînement et 42k images de validation.
|
||||
- [SKU-110K](../../datasets/detect/sku-110k.md) : Un ensemble de données mettant en vedette la détection d'objets denses dans les environnements de vente au détail avec plus de 11K images et 1.7 million de boîtes englobantes.
|
||||
- [VisDrone](../../datasets/detect/visdrone.md) : Un ensemble de données contenant des données de détection d'objets et de suivi multi-objets à partir d'images capturées par drone avec plus de 10K images et séquences vidéo.
|
||||
- [VOC](../../datasets/detect/voc.md) : L'ensemble de données de classes d'objets visuels Pascal (VOC) pour la détection d'objets et la segmentation avec 20 classes d'objets et plus de 11K images.
|
||||
- [xView](../../datasets/detect/xview.md) : Un ensemble de données pour la détection d'objets dans l'imagerie aérienne avec 60 catégories d'objets et plus d'un million d'objets annotés.
|
||||
|
||||
## [Ensembles de données de segmentation d'instance](../../datasets/segment/index.md)
|
||||
|
||||
La segmentation d'instance est une technique de vision par ordinateur qui consiste à identifier et localiser des objets dans une image au niveau des pixels.
|
||||
|
||||
- [COCO](../../datasets/segment/coco.md) : Un ensemble de données de grande échelle conçu pour la détection d'objets, la segmentation et les tâches d'annotation avec plus de 200K images étiquetées.
|
||||
- [COCO8-seg](../../datasets/segment/coco8-seg.md) : Un ensemble de données plus petit pour les tâches de segmentation d'instance, contenant un sous-ensemble de 8 images COCO avec des annotations de segmentation.
|
||||
|
||||
## [Estimation de pose](../../datasets/pose/index.md)
|
||||
|
||||
L'estimation de la pose est une technique utilisée pour déterminer la pose de l'objet par rapport à la caméra ou au système de coordonnées mondial.
|
||||
|
||||
- [COCO](../../datasets/pose/coco.md) : Un ensemble de données de grande échelle avec des annotations de poses humaines conçu pour les tâches d'estimation de la pose.
|
||||
- [COCO8-pose](../../datasets/pose/coco8-pose.md) : Un ensemble de données plus petit pour les tâches d'estimation de la pose, contenant un sous-ensemble de 8 images COCO avec des annotations de pose humaine.
|
||||
- [Tiger-pose](../../datasets/pose/tiger-pose.md) : Un ensemble de données compact composé de 263 images centrées sur les tigres, annotées avec 12 points par tigre pour les tâches d'estimation de la pose.
|
||||
|
||||
## [Classification](../../datasets/classify/index.md)
|
||||
|
||||
La classification d'images est une tâche de vision par ordinateur qui implique de catégoriser une image dans une ou plusieurs classes ou catégories prédéfinies en fonction de son contenu visuel.
|
||||
|
||||
- [Caltech 101](../../datasets/classify/caltech101.md) : Un ensemble de données contenant des images de 101 catégories d'objets pour les tâches de classification d'images.
|
||||
- [Caltech 256](../../datasets/classify/caltech256.md) : Une version étendue de Caltech 101 avec 256 catégories d'objets et des images plus complexes.
|
||||
- [CIFAR-10](../../datasets/classify/cifar10.md) : Un ensemble de données de 60K images couleur 32x32 réparties en 10 classes, avec 6K images par classe.
|
||||
- [CIFAR-100](../../datasets/classify/cifar100.md) : Une version étendue de CIFAR-10 avec 100 catégories d'objets et 600 images par classe.
|
||||
- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md) : Un ensemble de données composé de 70 000 images en niveaux de gris de 10 catégories de mode pour les tâches de classification d'images.
|
||||
- [ImageNet](../../datasets/classify/imagenet.md) : Un ensemble de données à grande échelle pour la détection d'objets et la classification d'images avec plus de 14 millions d'images et 20 000 catégories.
|
||||
- [ImageNet-10](../../datasets/classify/imagenet10.md) : Un sous-ensemble plus petit d'ImageNet avec 10 catégories pour des expériences et des tests plus rapides.
|
||||
- [Imagenette](../../datasets/classify/imagenette.md) : Un sous-ensemble plus petit d'ImageNet qui contient 10 classes facilement distinctes pour un entraînement et des tests plus rapides.
|
||||
- [Imagewoof](../../datasets/classify/imagewoof.md) : Un sous-ensemble d'ImageNet plus difficile contenant 10 catégories de races de chiens pour les tâches de classification d'images.
|
||||
- [MNIST](../../datasets/classify/mnist.md) : Un ensemble de données de 70 000 images en niveaux de gris de chiffres manuscrits pour les tâches de classification d'images.
|
||||
|
||||
## [Boîtes Englobantes Orientées (OBB)](../../datasets/obb/index.md)
|
||||
|
||||
Les Boîtes Englobantes Orientées (OBB) sont une méthode en vision par ordinateur pour détecter des objets inclinés dans les images en utilisant des boîtes englobantes rotatives, souvent appliquée à l'imagerie aérienne et satellite.
|
||||
|
||||
- [DOTAv2](../../datasets/obb/dota-v2.md) : Un ensemble de données d'imagerie aérienne populaire avec 1.7 million d'instances et 11 268 images.
|
||||
|
||||
## [Suivi Multi-Objets](../../datasets/track/index.md)
|
||||
|
||||
Le suivi multi-objets est une technique de vision par ordinateur qui consiste à détecter et suivre plusieurs objets dans le temps dans une séquence vidéo.
|
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md) : Un ensemble de données contenant des données de suivi 3D et de prévision de mouvement dans des environnements urbains avec des annotations détaillées pour les tâches de suivi multi-objets.
|
||||
- [VisDrone](../../datasets/detect/visdrone.md) : Un ensemble de données contenant des données de détection d'objets et de suivi multi-objets à partir d'images capturées par drone avec plus de 10K images et séquences vidéo.
|
||||
|
||||
## Contribuer de Nouveaux Ensembles de Données
|
||||
|
||||
Contribuer un nouvel ensemble de données implique plusieurs étapes pour s'assurer qu'il s'aligne bien avec l'infrastructure existante. Voici les étapes nécessaires :
|
||||
|
||||
### Étapes pour Contribuer un Nouvel Ensemble de Données
|
||||
|
||||
1. **Collecter des Images** : Rassemblez les images qui appartiennent à l'ensemble de données. Celles-ci pourraient être collectées à partir de différentes sources, telles que des bases de données publiques ou votre propre collection.
|
||||
|
||||
2. **Annoter des Images** : Annotez ces images avec des boîtes englobantes, des segments ou des points clés, en fonction de la tâche.
|
||||
|
||||
3. **Exporter des Annotations** : Convertissez ces annotations au format de fichier YOLO *.txt pris en charge par Ultralytics.
|
||||
|
||||
4. **Organiser l'Ensemble de Données** : Rangez votre ensemble de données dans la bonne structure de dossiers. Vous devriez avoir des répertoires de niveau supérieur `train/` et `val/`, et à l'intérieur de chacun, un sous-répertoire `images/` et `labels/`.
|
||||
|
||||
```
|
||||
dataset/
|
||||
├── train/
|
||||
│ ├── images/
|
||||
│ └── labels/
|
||||
└── val/
|
||||
├── images/
|
||||
└── labels/
|
||||
```
|
||||
|
||||
5. **Créer un Fichier `data.yaml`** : Dans le répertoire racine de votre ensemble de données, créez un fichier `data.yaml` qui décrit l'ensemble de données, les classes et les autres informations nécessaires.
|
||||
|
||||
6. **Optimiser les Images (Optionnel)** : Si vous souhaitez réduire la taille de l'ensemble de données pour un traitement plus efficace, vous pouvez optimiser les images en utilisant le code ci-dessous. Ceci n'est pas requis, mais recommandé pour des tailles d'ensemble de données plus petites et des vitesses de téléchargement plus rapides.
|
||||
|
||||
7. **Zipper l'Ensemble de Données** : Compressez le dossier complet de l'ensemble de données dans un fichier zip.
|
||||
|
||||
8. **Documenter et PR** : Créez une page de documentation décrivant votre ensemble de données et comment il s'intègre dans le cadre existant. Après cela, soumettez une Pull Request (PR). Référez-vous aux [lignes directrices de contribution Ultralytics](https://docs.ultralytics.com/help/contributing) pour plus de détails sur la manière de soumettre une PR.
|
||||
|
||||
### Exemple de Code pour Optimiser et Zipper un Ensemble de Données
|
||||
|
||||
!!! exemple "Optimiser et Zipper un Ensemble de Données"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from pathlib import Path
|
||||
from ultralytics.data.utils import compress_one_image
|
||||
from ultralytics.utils.downloads import zip_directory
|
||||
|
||||
# Définir le répertoire de l'ensemble de données
|
||||
path = Path('chemin/vers/ensemble-de-données')
|
||||
|
||||
# Optimiser les images dans l'ensemble de données (optionnel)
|
||||
for f in path.rglob('*.jpg'):
|
||||
compress_one_image(f)
|
||||
|
||||
# Zipper l'ensemble de données dans 'chemin/vers/ensemble-de-données.zip'
|
||||
zip_directory(path)
|
||||
```
|
||||
|
||||
En suivant ces étapes, vous pouvez contribuer un nouvel ensemble de données qui s'intègre bien avec la structure existante d'Ultralytics.
|
||||
82
docs/fr/index.md
Normal file
82
docs/fr/index.md
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
---
|
||||
comments: true
|
||||
description: Découvrez un guide complet du modèle Ultralytics YOLOv8, un modèle de détection d'objets et de segmentation d'images à haute vitesse et haute précision. Tutoriels d'installation, de prédiction, d'entraînement et plus encore.
|
||||
keywords: Ultralytics, YOLOv8, détection d'objets, segmentation d'images, apprentissage automatique, apprentissage profond, vision par ordinateur, installation de YOLOv8, prédiction avec YOLOv8, entraînement de YOLOv8, histoire de YOLO, licences de YOLO
|
||||
---
|
||||
|
||||
<div align="center">
|
||||
<p>
|
||||
<a href="https://yolovision.ultralytics.com" target="_blank">
|
||||
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Bannière Ultralytics YOLO"></a>
|
||||
</p>
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="GitHub Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="LinkedIn Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Twitter Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://youtube.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="YouTube Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="TikTok Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Instagram Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Discord Ultralytics"></a>
|
||||
<br>
|
||||
<br>
|
||||
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml/badge.svg" alt="Intégration continue Ultralytics"></a>
|
||||
<a href="https://codecov.io/github/ultralytics/ultralytics"><img src="https://codecov.io/github/ultralytics/ultralytics/branch/main/graph/badge.svg?token=HHW7IIVFVY" alt="Couverture de code Ultralytics"></a>
|
||||
<a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="Citation YOLOv8"></a>
|
||||
<a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Téléchargements Docker"></a>
|
||||
<br>
|
||||
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Exécuter sur Gradient"></a>
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Ouvrir dans Colab"></a>
|
||||
<a href="https://www.kaggle.com/ultralytics/yolov8"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Ouvrir dans Kaggle"></a>
|
||||
</div>
|
||||
|
||||
Présentation d'[Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), la dernière version du modèle réputé de détection d'objets en temps réel et de segmentation d'images. YOLOv8 est construit sur des avancées de pointe en apprentissage profond et vision par ordinateur, offrant des performances inégalées en termes de vitesse et de précision. Sa conception épurée le rend adapté à diverses applications et facilement adaptable à différentes plateformes matérielles, des appareils de bord aux API cloud.
|
||||
|
||||
Explorez les Docs YOLOv8, une ressource complète conçue pour vous aider à comprendre et à utiliser ses fonctionnalités et capacités. Que vous soyez un praticien chevronné de l'apprentissage automatique ou nouveau dans le domaine, ce hub vise à maximiser le potentiel de YOLOv8 dans vos projets.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Notre documentation multilingue est actuellement en construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏
|
||||
|
||||
## Par où commencer
|
||||
|
||||
- **Installer** `ultralytics` avec pip et démarrer en quelques minutes [:material-clock-fast: Commencer](quickstart.md){ .md-button }
|
||||
- **Prédire** de nouvelles images et vidéos avec YOLOv8 [:octicons-image-16: Prédire sur Images](modes/predict.md){ .md-button }
|
||||
- **Entraîner** un nouveau modèle YOLOv8 sur votre propre ensemble de données customisé [:fontawesome-solid-brain: Entraîner un modèle](modes/train.md){ .md-button }
|
||||
- **Explorer** les tâches YOLOv8 comme la segmentation, la classification, l'estimation de pose et le suivi [:material-magnify-expand: Explorer les tâches](tasks/index.md){ .md-button }
|
||||
|
||||
<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>Regarder :</strong> Comment entraîner un modèle YOLOv8 sur votre ensemble de données customisé dans <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb" target="_blank">Google Colab</a>.
|
||||
</p>
|
||||
|
||||
## YOLO : Un bref historique
|
||||
|
||||
[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), un modèle populaire de détection d'objets et de segmentation d'images, a été développé par Joseph Redmon et Ali Farhadi à l'Université de Washington. Lancé en 2015, YOLO a rapidement gagné en popularité pour sa vitesse et sa précision élevées.
|
||||
|
||||
- [YOLOv2](https://arxiv.org/abs/1612.08242), publié en 2016, a amélioré le modèle original en intégrant la normalisation par lots, les boîtes d'ancrage et les clusters de dimensions.
|
||||
- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), lancé en 2018, a davantage amélioré la performance du modèle en utilisant un réseau dorsal plus efficace, des ancres multiples et un pool pyramidal spatial.
|
||||
- [YOLOv4](https://arxiv.org/abs/2004.10934) a été publié en 2020, introduisant des innovations telles que l'augmentation de données Mosaic, une nouvelle tête de détection sans ancre et une nouvelle fonction de perte.
|
||||
- [YOLOv5](https://github.com/ultralytics/yolov5) a encore amélioré la performance du modèle et a ajouté des fonctionnalités nouvelles telles que l'optimisation des hyperparamètres, le suivi intégré des expériences et l'export automatique vers des formats d'exportation populaires.
|
||||
- [YOLOv6](https://github.com/meituan/YOLOv6) a été rendu open-source par [Meituan](https://about.meituan.com/) en 2022 et est utilisé dans de nombreux robots de livraison autonomes de l'entreprise.
|
||||
- [YOLOv7](https://github.com/WongKinYiu/yolov7) a ajouté des tâches supplémentaires telles que l'estimation de pose sur le jeu de données de points clés COCO.
|
||||
- [YOLOv8](https://github.com/ultralytics/ultralytics) est la dernière version de YOLO par Ultralytics. En tant que modèle de pointe et dernier cri (state-of-the-art, SOTA), YOLOv8 s'appuie sur le succès des versions précédentes, introduisant de nouvelles fonctionnalités et améliorations pour des performances, une flexibilité et une efficacité renforcées. YOLOv8 prend en charge une gamme complète de tâches d'intelligence artificielle visuelle, y compris la [détection](tasks/detect.md), la [segmentation](tasks/segment.md), l'[estimation de pose](tasks/pose.md), le [suivi](modes/track.md) et la [classification](tasks/classify.md). Cette polyvalence permet aux utilisateurs de tirer parti des capacités de YOLOv8 dans diverses applications et domaines.
|
||||
|
||||
## Licences YOLO : Comment est licencié Ultralytics YOLO ?
|
||||
|
||||
Ultralytics offre deux options de licence pour répondre aux différents cas d'utilisation :
|
||||
|
||||
- **Licence AGPL-3.0** : Cette licence open source [approuvée par OSI](https://opensource.org/licenses/) est idéale pour les étudiants et les passionnés, favorisant la collaboration ouverte et le partage des connaissances. Voir le fichier [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) pour plus de détails.
|
||||
- **Licence Enterprise** : Conçue pour un usage commercial, cette licence permet l'intégration transparente des logiciels et modèles d'IA Ultralytics dans des biens et services commerciaux, en contournant les exigences open source de l'AGPL-3.0. Si votre scénario implique l'incorporation de nos solutions dans une offre commerciale, n'hésitez pas à contacter [Ultralytics Licensing](https://ultralytics.com/license).
|
||||
|
||||
Notre stratégie de licence est conçue pour garantir que toute amélioration de nos projets open source soit restituée à la communauté. Nous tenons les principes de l'open source à cœur ❤️, et notre mission est de garantir que nos contributions puissent être utilisées et développées de manière bénéfique pour tous.
|
||||
94
docs/fr/models/index.md
Normal file
94
docs/fr/models/index.md
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explorez la diversité des modèles YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS et RT-DETR pris en charge par Ultralytics. Commencez avec des exemples d'utilisation pour CLI et Python.
|
||||
keywords: Ultralytics, documentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modèles, architectures, Python, CLI
|
||||
---
|
||||
|
||||
# Modèles pris en charge par Ultralytics
|
||||
|
||||
Bienvenue dans la documentation des modèles d'Ultralytics ! Nous proposons une prise en charge d'une large gamme de modèles, chacun adapté à des tâches spécifiques comme [la détection d'objets](../tasks/detect.md), [la segmentation d'instances](../tasks/segment.md), [la classification d'images](../tasks/classify.md), [l'estimation de posture](../tasks/pose.md) et [le suivi multi-objets](../modes/track.md). Si vous souhaitez contribuer avec votre architecture de modèle à Ultralytics, consultez notre [Guide de Contribution](../../help/contributing.md).
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Notre documentation multilingue est actuellement en construction et nous travaillons activement à l'améliorer. Merci de votre patience ! 🙏
|
||||
|
||||
## Modèles en vedette
|
||||
|
||||
Voici quelques-uns des modèles clés pris en charge :
|
||||
|
||||
1. **[YOLOv3](../../models/yolov3.md)** : La troisième itération de la famille de modèles YOLO, originellement par Joseph Redmon, reconnue pour ses capacités de détection d'objets en temps réel efficaces.
|
||||
2. **[YOLOv4](../../models/yolov4.md)** : Une mise à jour de YOLOv3 native de darknet, publiée par Alexey Bochkovskiy en 2020.
|
||||
3. **[YOLOv5](../../models/yolov5.md)** : Une version améliorée de l'architecture YOLO par Ultralytics, offrant de meilleurs compromis de performance et de vitesse par rapport aux versions précédentes.
|
||||
4. **[YOLOv6](../../models/yolov6.md)** : Publié par [Meituan](https://about.meituan.com/) en 2022, et utilisé dans de nombreux robots de livraison autonomes de l'entreprise.
|
||||
5. **[YOLOv7](../../models/yolov7.md)** : Modèles YOLO mis à jour et sortis en 2022 par les auteurs de YOLOv4.
|
||||
6. **[YOLOv8](../../models/yolov8.md)** : La dernière version de la famille YOLO, avec des capacités améliorées telles que la segmentation d’instances, l'estimation de pose/points clés, et la classification.
|
||||
7. **[Segment Anything Model (SAM)](../../models/sam.md)** : Le modèle Segment Anything Model (SAM) de Meta.
|
||||
8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)** : MobileSAM pour les applications mobiles, par l'Université de Kyung Hee.
|
||||
9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)** : FastSAM par le groupe d’Analyse Image et Vidéo, Institut d'Automatisation, Académie Chinoise des Sciences.
|
||||
10. **[YOLO-NAS](../../models/yolo-nas.md)** : Modèles YOLO Neural Architecture Search (NAS).
|
||||
11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)** : Modèles de Realtime Detection Transformer (RT-DETR) de Baidu's PaddlePaddle.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/MWq1UxqTClU?si=nHAW-lYDzrz68jR0"
|
||||
title="Lecteur vidéo YouTube" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Regardez :</strong> Exécutez les modèles YOLO d'Ultralytics en seulement quelques lignes de code.
|
||||
</p>
|
||||
|
||||
## Pour commencer : Exemples d'utilisation
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
Les modèles préentrainés `*.pt` ainsi que les fichiers de configuration `*.yaml` peuvent être passés aux classes `YOLO()`, `SAM()`, `NAS()` et `RTDETR()` pour créer une instance du modèle en Python :
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Charger un modèle YOLOv8n préentrainé sur COCO
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Afficher les informations du modèle (optionnel)
|
||||
model.info()
|
||||
|
||||
# Entraîner le modèle sur l'exemple de jeu de données COCO8 pendant 100 époques
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Exécuter l'inférence avec le modèle YOLOv8n sur l'image 'bus.jpg'
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Des commandes CLI sont disponibles pour exécuter directement les modèles :
|
||||
|
||||
```bash
|
||||
# Charger un modèle YOLOv8n préentrainé sur COCO et l'entraîner sur l'exemple de jeu de données COCO8 pendant 100 époques
|
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Charger un modèle YOLOv8n préentrainé sur COCO et exécuter l'inférence sur l'image 'bus.jpg'
|
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Contribuer de nouveaux modèles
|
||||
|
||||
Intéressé à contribuer votre modèle à Ultralytics ? Super ! Nous sommes toujours ouverts à l'expansion de notre portefeuille de modèles.
|
||||
|
||||
1. **Forker le Répertoire** : Commencez par forker le [répertoire GitHub d'Ultralytics](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
2. **Cloner Votre Fork** : Clonez votre fork sur votre machine locale et créez une nouvelle branche pour travailler dessus.
|
||||
|
||||
3. **Implémenter Votre Modèle** : Ajoutez votre modèle en suivant les standards et directives de codage fournis dans notre [Guide de Contribution](../../help/contributing.md).
|
||||
|
||||
4. **Tester Rigoureusement** : Assurez-vous de tester votre modèle de manière rigoureuse, à la fois isolément et en tant que partie du pipeline.
|
||||
|
||||
5. **Créer une Pull Request** : Une fois que vous êtes satisfait de votre modèle, créez une demandе de tirage (pull request) vers le répertoire principal pour examen.
|
||||
|
||||
6. **Revue de Code & Fusion** : Après la revue, si votre modèle répond à nos critères, il sera fusionné dans le répertoire principal.
|
||||
|
||||
Pour des étapes détaillées, consultez notre [Guide de Contribution](../../help/contributing.md).
|
||||
94
docs/fr/modes/benchmark.md
Normal file
94
docs/fr/modes/benchmark.md
Normal 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
108
docs/fr/modes/export.md
Normal 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
73
docs/fr/modes/index.md
Normal 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
226
docs/fr/modes/predict.md
Normal 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 | 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
200
docs/fr/modes/track.md
Normal 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 | 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
206
docs/fr/modes/train.md
Normal 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
86
docs/fr/modes/val.md
Normal 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' |
|
||||
|
|
||||
187
docs/fr/quickstart.md
Normal file
187
docs/fr/quickstart.md
Normal file
|
|
@ -0,0 +1,187 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explorez diverses méthodes pour installer Ultralytics en utilisant pip, conda, git et Docker. Apprenez comment utiliser Ultralytics avec l'interface en ligne de commande ou au sein de vos projets Python.
|
||||
keywords: installation d'Ultralytics, pip install Ultralytics, Docker install Ultralytics, interface en ligne de commande Ultralytics, interface Python Ultralytics
|
||||
---
|
||||
|
||||
## Installer Ultralytics
|
||||
|
||||
Ultralytics propose diverses méthodes d'installation, y compris pip, conda et Docker. Installez YOLOv8 via le package `ultralytics` avec pip pour obtenir la dernière version stable ou en clonant le [répertoire GitHub d'Ultralytics](https://github.com/ultralytics/ultralytics) pour la version la plus récente. Docker peut être utilisé pour exécuter le package dans un conteneur isolé, évitant l'installation locale.
|
||||
|
||||
!!! exemple "Installer"
|
||||
|
||||
=== "Installation avec Pip (recommandé)"
|
||||
Installez le package `ultralytics` en utilisant pip, ou mettez à jour une installation existante en exécutant `pip install -U ultralytics`. Visitez l'Index des Packages Python (PyPI) pour plus de détails sur le package `ultralytics` : [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
|
||||
|
||||
[](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/project/ultralytics)
|
||||
|
||||
```bash
|
||||
# Installer le package ultralytics depuis PyPI
|
||||
pip install ultralytics
|
||||
```
|
||||
|
||||
Vous pouvez également installer le package `ultralytics` directement depuis le [répertoire GitHub](https://github.com/ultralytics/ultralytics). Cela peut être utile si vous voulez la version de développement la plus récente. Assurez-vous d'avoir l'outil en ligne de commande Git installé sur votre système. La commande `@main` installe la branche `main` et peut être modifiée pour une autre branche, p. ex. `@my-branch`, ou supprimée entièrement pour revenir par défaut à la branche `main`.
|
||||
|
||||
```bash
|
||||
# Installer le package ultralytics depuis GitHub
|
||||
pip install git+https://github.com/ultralytics/ultralytics.git@main
|
||||
```
|
||||
|
||||
|
||||
=== "Installation avec Conda"
|
||||
Conda est un gestionnaire de packages alternatif à pip qui peut également être utilisé pour l'installation. Visitez Anaconda pour plus de détails à [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Le répertoire feedstock d'Ultralytics pour la mise à jour du package conda est sur [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
|
||||
|
||||
|
||||
[](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics)
|
||||
|
||||
```bash
|
||||
# Installer le package ultralytics en utilisant conda
|
||||
conda install -c conda-forge ultralytics
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
Si vous installez dans un environnement CUDA, la meilleure pratique est d'installer `ultralytics`, `pytorch` et `pytorch-cuda` dans la même commande pour permettre au gestionnaire de package conda de résoudre les conflits, ou bien d'installer `pytorch-cuda` en dernier pour lui permettre de remplacer le package `pytorch` spécifique aux CPU si nécessaire.
|
||||
```bash
|
||||
# Installer tous les packages ensemble en utilisant conda
|
||||
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
|
||||
```
|
||||
|
||||
### Image Docker Conda
|
||||
|
||||
Les images Docker Conda d'Ultralytics sont également disponibles sur [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Ces images sont basées sur [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) et constituent un moyen simple de commencer à utiliser `ultralytics` dans un environnement Conda.
|
||||
|
||||
```bash
|
||||
# Définir le nom de l'image comme variable
|
||||
t=ultralytics/ultralytics:latest-conda
|
||||
|
||||
# Télécharger la dernière image ultralytics de Docker Hub
|
||||
sudo docker pull $t
|
||||
|
||||
# Exécuter l'image ultralytics dans un conteneur avec support GPU
|
||||
sudo docker run -it --ipc=host --gpus all $t # tous les GPUs
|
||||
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # spécifier les GPUs
|
||||
```
|
||||
|
||||
=== "Clone Git"
|
||||
Clonez le répertoire `ultralytics` si vous êtes intéressé par la contribution au développement ou si vous souhaitez expérimenter avec le dernier code source. Après le clonage, naviguez dans le répertoire et installez le package en mode éditable `-e` en utilisant pip.
|
||||
```bash
|
||||
# Cloner le répertoire ultralytics
|
||||
git clone https://github.com/ultralytics/ultralytics
|
||||
|
||||
# Naviguer vers le répertoire cloné
|
||||
cd ultralytics
|
||||
|
||||
# Installer le package en mode éditable pour le développement
|
||||
pip install -e .
|
||||
```
|
||||
|
||||
Voir le fichier [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) d'`ultralytics` pour une liste des dépendances. Notez que tous les exemples ci-dessus installent toutes les dépendances requises.
|
||||
|
||||
!!! astuce "Conseil"
|
||||
|
||||
Les prérequis de PyTorch varient selon le système d'exploitation et les exigences CUDA, donc il est recommandé d'installer PyTorch en premier en suivant les instructions sur [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
|
||||
|
||||
<a href="https://pytorch.org/get-started/locally/">
|
||||
<img width="800" alt="Instructions d'installation de PyTorch" src="https://user-images.githubusercontent.com/26833433/228650108-ab0ec98a-b328-4f40-a40d-95355e8a84e3.png">
|
||||
</a>
|
||||
|
||||
## Utiliser Ultralytics avec CLI
|
||||
|
||||
L'interface en ligne de commande (CLI) d'Ultralytics permet l'utilisation de commandes simples en une seule ligne sans nécessiter d'environnement Python. La CLI ne requiert pas de personnalisation ou de code Python. Vous pouvez simplement exécuter toutes les tâches depuis le terminal avec la commande `yolo`. Consultez le [Guide CLI](../usage/cli.md) pour en savoir plus sur l'utilisation de YOLOv8 depuis la ligne de commande.
|
||||
|
||||
!!! exemple
|
||||
|
||||
=== "Syntaxe"
|
||||
|
||||
Les commandes `yolo` d'Ultralytics utilisent la syntaxe suivante :
|
||||
```bash
|
||||
yolo TÂCHE MODE ARGS
|
||||
|
||||
Où TÂCHE (facultatif) est l'une de [detect, segment, classify]
|
||||
MODE (obligatoire) est l'un de [train, val, predict, export, track]
|
||||
ARGS (facultatif) sont n'importe quel nombre de paires personnalisées 'arg=valeur' comme 'imgsz=320' qui remplacent les valeurs par défaut.
|
||||
```
|
||||
Voyez tous les ARGS dans le [Guide de Configuration](../usage/cfg.md) complet ou avec `yolo cfg`
|
||||
|
||||
=== "Entraînement"
|
||||
|
||||
Entraînez un modèle de détection pour 10 epochs avec un learning_rate initial de 0.01
|
||||
```bash
|
||||
yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
|
||||
```
|
||||
|
||||
=== "Prédiction"
|
||||
|
||||
Prédisez une vidéo YouTube en utilisant un modèle de segmentation pré-entraîné à une taille d'image de 320 :
|
||||
```bash
|
||||
yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
|
||||
```
|
||||
|
||||
=== "Validation"
|
||||
|
||||
Validez un modèle de détection pré-entraîné avec un batch-size de 1 et une taille d'image de 640 :
|
||||
```bash
|
||||
yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
|
||||
```
|
||||
|
||||
=== "Exportation"
|
||||
|
||||
Exportez un modèle de classification YOLOv8n au format ONNX à une taille d'image de 224 par 128 (pas de TÂCHE requise)
|
||||
```bash
|
||||
yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
|
||||
```
|
||||
|
||||
=== "Spécial"
|
||||
|
||||
Exécutez des commandes spéciales pour voir la version, afficher les paramètres, effectuer des vérifications et plus encore :
|
||||
```bash
|
||||
yolo help
|
||||
yolo checks
|
||||
yolo version
|
||||
yolo settings
|
||||
yolo copy-cfg
|
||||
yolo cfg
|
||||
```
|
||||
|
||||
!!! avertissement "Avertissement"
|
||||
|
||||
Les arguments doivent être passés sous forme de paires `arg=val`, séparés par un signe égal `=` et délimités par des espaces ` ` entre les paires. N'utilisez pas de préfixes d'arguments `--` ou de virgules `,` entre les arguments.
|
||||
|
||||
- `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` ✅
|
||||
- `yolo predict model yolov8n.pt imgsz 640 conf 0.25` ❌
|
||||
- `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` ❌
|
||||
|
||||
[Guide CLI](../usage/cli.md){ .md-button .md-button--primary}
|
||||
|
||||
## Utiliser Ultralytics avec Python
|
||||
|
||||
L'interface Python de YOLOv8 permet une intégration transparente dans vos projets Python, facilitant le chargement, l'exécution et le traitement de la sortie du modèle. Conçue avec simplicité et facilité d'utilisation à l'esprit, l'interface Python permet aux utilisateurs de mettre en œuvre rapidement la détection d'objets, la segmentation et la classification dans leurs projets. Cela fait de l'interface Python de YOLOv8 un outil inestimable pour quiconque cherche à intégrer ces fonctionnalités dans ses projets Python.
|
||||
|
||||
Par exemple, les utilisateurs peuvent charger un modèle, l'entraîner, évaluer ses performances sur un set de validation, et même l'exporter au format ONNX avec seulement quelques lignes de code. Consultez le [Guide Python](../usage/python.md) pour en savoir plus sur l'utilisation de YOLOv8 au sein de vos projets Python.
|
||||
|
||||
!!! exemple
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Créer un nouveau modèle YOLO à partir de zéro
|
||||
model = YOLO('yolov8n.yaml')
|
||||
|
||||
# Charger un modèle YOLO pré-entraîné (recommandé pour l'entraînement)
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Entraîner le modèle en utilisant le jeu de données 'coco128.yaml' pour 3 epochs
|
||||
résultats = model.train(data='coco128.yaml', epochs=3)
|
||||
|
||||
# Évaluer la performance du modèle sur le set de validation
|
||||
résultats = model.val()
|
||||
|
||||
# Effectuer la détection d'objets sur une image en utilisant le modèle
|
||||
résultats = model('https://ultralytics.com/images/bus.jpg')
|
||||
|
||||
# Exporter le modèle au format ONNX
|
||||
succès = model.export(format='onnx')
|
||||
```
|
||||
|
||||
[Guide Python](../usage/python.md){.md-button .md-button--primary}
|
||||
172
docs/fr/tasks/classify.md
Normal file
172
docs/fr/tasks/classify.md
Normal 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
184
docs/fr/tasks/detect.md
Normal 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
55
docs/fr/tasks/index.md
Normal 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
176
docs/fr/tasks/pose.md
Normal 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
|
||||
|
||||
|
||||
|
||||
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.
|
||||
|
||||
|
||||
|
||||
!!! 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
189
docs/fr/tasks/segment.md
Normal 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/).
|
||||
Loading…
Add table
Add a link
Reference in a new issue