Entraîner YOLOv5 sur des données personnalisées
📚 Ce guide explique comment entraîner votre propre ensemble de données personnalisé en utilisant le modèle YOLOv5 🚀. L'entraînement de modèles personnalisés est une étape fondamentale pour adapter les solutions de vision par ordinateur à des applications spécifiques du monde réel au-delà de la détection d'objets générique.
Avant de commencer
Tout d'abord, assurez-vous que votre environnement est correctement configuré. Clonez le dépôt YOLOv5 et installez les dépendances requises à partir de requirements.txt
. UN Python>=3.8.0 environnement avec PyTorch>=1.8 est essentiel. Les modèles et les jeux de données sont automatiquement téléchargés à partir du dernier YOLOv5 version s'ils ne sont pas trouvés localement.
git clone https://github.com/ultralytics/yolov5 # Clone the repository
cd yolov5
pip install -r requirements.txt # Install dependencies
Entraîner sur des données personnalisées
Le développement d'un modèle de détection d'objets personnalisé est un processus itératif :
- Collecter et organiser les images : Rassemblez des images pertinentes pour votre tâche spécifique. Des données diversifiées et de haute qualité sont essentielles. Consultez notre guide sur la collecte et l’annotation des données.
- Étiqueter les objets : Annotez avec précision les objets d'intérêt dans vos images.
- Entraîner un modèle : Utilisez les données étiquetées pour entraîner votre modèle YOLOv5. Tirez parti de l’apprentissage par transfert en commençant par des poids pré-entraînés.
- Déployer et prédire : Utilisez le modèle entraîné pour l'inférence sur de nouvelles données non visualisées.
- Collecter les cas limites : Identifiez les scénarios où le modèle fonctionne mal (cas limites) et ajoutez des données similaires à votre ensemble de données pour améliorer la robustesse. Répétez le cycle.
Ultralytics HUB offre une solution simplifiée et sans code pour l'ensemble de ce cycle d'opérations d'apprentissage automatique (MLOps), y compris la gestion des ensembles de données, l'entraînement des modèles et le déploiement.
Licences
Ultralytics propose deux options de licence pour s'adapter à divers scénarios d'utilisation :
- Licence AGPL-3.0 : Cette licence open source approuvée par l’OSI est idéale pour les étudiants, les chercheurs et les passionnés de collaboration ouverte et de partage des connaissances. Elle exige que les œuvres dérivées soient partagées sous la même licence. Consultez le fichier LICENSE pour tous les détails.
- Licence Entreprise : Conçue pour les applications commerciales, cette licence permet l'intégration transparente des logiciels et des modèles d'IA Ultralytics dans les produits et services commerciaux sans les stipulations open source d'AGPL-3.0. Si votre projet nécessite un déploiement commercial, demandez une licence Entreprise.
Explorez plus en détail nos options de licence sur la page Licences Ultralytics.
Avant de lancer l'entraînement, la préparation du jeu de données est essentielle.
1. Créer un jeu de données
Les modèles YOLOv5 nécessitent des données étiquetées pour apprendre les caractéristiques visuelles des classes d'objets. L'organisation correcte de votre jeu de données est essentielle.
1.1 Créer dataset.yaml
Le fichier de configuration de l'ensemble de données (par exemple, coco128.yaml
) décrit la structure du jeu de données, les noms de classes et les chemins d'accès aux répertoires d'images. COCO128 sert d'exemple de petit ensemble de données, comprenant les 128 premières images de l'ensemble COCO dataset. Il est utile pour tester rapidement le pipeline d'entraînement et diagnostiquer les problèmes potentiels tels que surapprentissage.
L'argument dataset.yaml
La structure du fichier comprend :
path
: Le répertoire racine contenant l'ensemble de données.train
,val
,test
: Chemins relatifs à partir depath
vers des répertoires contenant des images ou des fichiers texte répertoriant les chemins d'accès aux images pour les ensembles d'apprentissage, de validation et de test.names
: Un dictionnaire mappant les indices de classe (à partir de 0) à leurs noms de classe correspondants.
Vous trouverez ci-dessous la structure pour coco128.yaml
(voir sur GitHub) :
# Dataset root directory relative to the yolov5 directory
path: coco128
# Train/val/test sets: specify directories, *.txt files, or lists
train: images/train2017 # 128 images for training
val: images/train2017 # 128 images for validation
test: # Optional path to test images
# Classes (example using 80 COCO classes)
names:
0: person
1: bicycle
2: car
# ... (remaining COCO classes)
77: teddy bear
78: hair drier
79: toothbrush
1.2 Tirer parti des modèles pour l'étiquetage automatisé
Bien que l'étiquetage manuel à l'aide d'outils soit une approche courante, le processus peut prendre beaucoup de temps. Les récentes avancées dans les modèles de fondation offrent des possibilités d'automatisation ou de semi-automatisation du processus d'annotation, ce qui pourrait accélérer considérablement la création de l'ensemble de données. Voici quelques exemples de modèles qui peuvent aider à générer des étiquettes :
- Google Gemini : Les grands modèles multimodaux tels que Gemini possèdent de puissantes capacités de compréhension d'image. Ils peuvent être invités à identifier et à localiser des objets dans des images, en générant des boîtes englobantes ou des descriptions qui peuvent être converties en étiquettes au format YOLO. Explorez son potentiel dans le notebook de tutoriel fourni.
- SAM2 (Segment Anything Model 2) : Les modèles de fondation axés sur la segmentation, comme SAM2, peuvent identifier et délimiter les objets avec une grande précision. Bien que principalement destinées à la segmentation, les masques résultants peuvent souvent être convertis en annotations de boîtes englobantes adaptées aux tâches de détection d'objets.
- YOLOWorld : Ce modèle offre des capacités de détection à vocabulaire ouvert. Vous pouvez fournir des descriptions textuelles des objets qui vous intéressent, et YOLOWorld peut les localiser dans les images sans entraînement préalable sur ces classes spécifiques. Cela peut être utilisé comme point de départ pour générer des étiquettes initiales, qui peuvent ensuite être affinées.
L'utilisation de ces modèles peut fournir une étape de « pré-étiquetage », réduisant ainsi l'effort manuel requis. Cependant, il est essentiel de revoir et d'affiner les étiquettes générées automatiquement pour garantir l'exactitude et la cohérence, car la qualité a un impact direct sur les performances de votre modèle YOLOv5 entraîné. Après avoir généré (et potentiellement affiné) vos étiquettes, assurez-vous qu'elles respectent les Format YOLO: un *.txt
fichier par image, chaque ligne représentant un objet comme class_index x_center y_center width height
(coordonnées normalisées, classe indexée à zéro). Si une image ne contient aucun objet d'intérêt, pas de *.txt
fichier est nécessaire.
Le format YOLO *.txt
Les spécifications du fichier sont précises :
- Une ligne par boîte englobante d'objet.
- Chaque ligne doit contenir :
class_index x_center y_center width height
. - Les coordonnées doivent être normalisé à une plage comprise entre 0 et 1. Pour ce faire, divisez les valeurs de pixel de
x_center
etwidth
par la largeur totale de l'image, et divisery_center
etheight
par la hauteur totale de l'image. - Les indices de classe sont indexés à zéro (c'est-à-dire que la première classe est représentée par
0
, le second par1
, et ainsi de suite).
Le fichier d'étiquettes correspondant à l'image ci-dessus, contenant deux objets 'personne' (index de classe 0
) et un objet 'tie' (index de classe 27
), ressemblerait à ceci :
1.3 Organiser les répertoires
Structurez votre jeux de données répertoire, comme illustré ci-dessous. Par défaut, YOLOv5 anticipe le répertoire de l'ensemble de données (par exemple, /coco128
) à résider dans un /datasets
dossier situé adjacent à le /yolov5
répertoire du référentiel.
YOLOv5 localise automatiquement les étiquettes de chaque image en substituant la dernière instance de /images/
dans le chemin d'image avec /labels/
. Par exemple :
../datasets/coco128/images/im0.jpg # Path to the image file
../datasets/coco128/labels/im0.txt # Path to the corresponding label file
La structure de répertoire recommandée est la suivante :
/datasets/
└── coco128/ # Dataset root
├── images/
│ ├── train2017/ # Training images
│ │ ├── 000000000009.jpg
│ │ └── ...
│ └── val2017/ # Validation images (optional if using same set for train/val)
│ └── ...
└── labels/
├── train2017/ # Training labels
│ ├── 000000000009.txt
│ └── ...
└── val2017/ # Validation labels (optional if using same set for train/val)
└── ...
2. Sélectionner un modèle
Choisissez un modèle pré-entraîné pour lancer le processus d’entraînement. Le fait de commencer avec des poids pré-entraînés accélère considérablement l’apprentissage et améliore les performances par rapport à un entraînement à partir de zéro. YOLOv5 offre différentes tailles de modèles, chacune équilibrant différemment la vitesse et la précision. Par exemple, YOLOv5s est le deuxième plus petit et le plus rapide des modèles, adapté aux environnements où les ressources sont limitées. Consultez le tableau README pour une comparaison détaillée de tous les modèles disponibles.
3. Entraîner
Commencez le formation du modèle en utilisant le train.py
script. Les arguments essentiels incluent :
--img
: Définit l'entrée taille de l'image (par exemple,--img 640
). Les tailles plus grandes offrent généralement une meilleure précision, mais nécessitent plus de mémoire GPU.--batch
: Détermine le taille de lot (par exemple,--batch 16
). Choisissez la plus grande taille que votre GPU peut gérer.--epochs
: Spécifie le nombre total d'entraînements epochs (par exemple,--epochs 100
). Une epoch représente un passage complet sur l'ensemble des données d'entraînement.--data
: Chemin d'accès à votredataset.yaml
fichier (par exemple,--data coco128.yaml
).--weights
: Chemin d'accès au fichier de poids initial. Utilisation de poids pré-entraînés (par exemple,--weights yolov5s.pt
) est fortement recommandé pour une convergence plus rapide et de meilleurs résultats. Pour effectuer un entraînement à partir de zéro (déconseillé sauf si vous disposez d'un très grand jeu de données et de besoins spécifiques), utilisez--weights '' --cfg yolov5s.yaml
.
Les poids pré-entraînés sont automatiquement téléchargés depuis la dernière version de YOLOv5 s'ils ne sont pas trouvés localement.
# Example: Train YOLOv5s on the COCO128 dataset for 3 epochs
python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt
Optimiser la vitesse d'entraînement
💡 Employer --cache ram
ou --cache disk
pour mettre en cache les images de l'ensemble de données dans RAM ou le disque local, respectivement. Cela accélère considérablement l’entraînement, en particulier lorsque les opérations d’E/S (entrée/sortie) de l’ensemble de données constituent un goulot d’étranglement. Notez que cela nécessite une quantité importante de RAM ou d’espace disque.
Stockage local des données
💡 Entraînez toujours en utilisant des ensembles de données stockés localement. L'accès aux données à partir de lecteurs réseau (comme Google Drive) ou de stockage distant peut être considérablement plus lent et nuire aux performances de l'entraînement. La copie de votre ensemble de données sur un SSD local est souvent la meilleure pratique.
Tous les résultats de l'entraînement, y compris les poids et les logs, sont enregistrés dans le runs/train/
répertoire. Chaque session de formation crée un nouveau sous-répertoire (par exemple, runs/train/exp
, runs/train/exp2
, etc.). Pour une expérience interactive et pratique, explorez la section de formation dans nos notebooks de tutoriel officiels :
4. Visualiser
YOLOv5 s'intègre de manière transparente à divers outils pour visualiser la progression de l'entraînement, évaluer les résultats et surveiller les performances en temps réel.
Journalisation et visualisation Comet 🌟 NOUVEAU
Comet est entièrement intégré pour un suivi complet des expériences. Visualisez les métriques en direct, enregistrez les hyperparamètres, gérez les ensembles de données et les points de contrôle des modèles, et analysez les prédictions des modèles à l'aide des panneaux personnalisés Comet interactifs.
La mise en route est simple :
pip install comet_ml # 1. Install Comet library
export COMET_API_KEY=YOUR_API_KEY_HERE # 2. Set your Comet API key (create a free account at Comet.ml)
python train.py --img 640 --epochs 3 --data coco128.yaml --weights yolov5s.pt # 3. Train your model - Comet automatically logs everything!
Explorez plus en détail les fonctionnalités prises en charge dans notre Guide d'intégration Comet. Apprenez-en davantage sur les capacités de Comet sur leur site officiel documentation. Essayez le notebook Comet Colab pour une démonstration en direct :
Journalisation et automatisation ClearML 🌟 NOUVEAU
L'intégration de ClearML permet un suivi détaillé des expériences, la gestion des versions des ensembles de données et même l'exécution à distance des entraînements. Activez ClearML en suivant ces étapes simples :
- Installer le paquet :
pip install clearml
- Initialiser ClearML : Exécuter
clearml-init
une fois pour vous connecter à votre serveur ClearML (auto-hébergé ou le niveau gratuit).
ClearML capture automatiquement les détails de l'expérience, les téléchargements de modèles, les comparaisons, les modifications de code non validées et les packages installés, garantissant une reproductibilité totale. Vous pouvez facilement planifier des tâches d'entraînement sur des agents distants et gérer les versions de datasets à l'aide de ClearML Data. Consultez le Guide d'intégration ClearML pour obtenir des informations complètes.
Journalisation locale
Les résultats de l'entraînement sont automatiquement enregistrés en utilisant TensorBoard et enregistré sous le nom de CSV fichiers dans le répertoire d'expérience spécifique (par exemple, runs/train/exp
). Les données enregistrées comprennent :
- Perte d'entraînement et de validation et métriques de performance.
- Exemples d'images montrant les augmentations appliquées (comme les mosaïques).
- Étiquettes de vérité terrain à côté des prédictions du modèle pour une inspection visuelle.
- Mesures d'évaluation clés telles que les courbes Précision-Rappel (PR).
- Matrices de confusion pour une analyse détaillée des performances par classe.
L'argument results.csv
fichier est mis à jour après chaque epoch et est tracé comme results.png
une fois l'entraînement terminé. Vous pouvez également tracer n'importe quel results.csv
fichier manuellement en utilisant la fonction utilitaire fournie :
from utils.plots import plot_results
# Plot results from a specific training run directory
plot_results("runs/train/exp/results.csv") # This will generate 'results.png' in the same directory
5. Prochaines étapes
Une fois l'entraînement terminé avec succès, le point de contrôle du modèle le plus performant (best.pt
) est enregistré et prêt pour le déploiement ou un affinement supplémentaire. Les prochaines étapes potentielles incluent :
- Exécutez l'inférence sur de nouvelles images ou vidéos à l'aide du modèle entraîné via la CLI ou Python.
- Effectuer une validation pour évaluer la précision et les capacités de généralisation du modèle sur différents ensembles de données (par exemple, un ensemble de test mis de côté).
- Exportez le modèle vers différents formats de déploiement tels que ONNX, TensorFlow SavedModel ou TensorRT pour une inférence optimisée sur diverses plateformes.
- Utilisez des techniques de réglage des hyperparamètres pour potentiellement obtenir des gains de performance supplémentaires.
- Continuez à améliorer votre modèle en suivant nos Conseils pour obtenir les meilleurs résultats d'entraînement et en ajoutant itérativement des données plus diverses et plus difficiles en fonction de l'analyse des performances.
Environnements pris en charge
Ultralytics fournit des environnements prêts à l'emploi, équipés des dépendances essentielles telles que CUDA, cuDNN, Python et PyTorch, facilitant ainsi un démarrage en douceur.
- Notebooks GPU Gratuits:
- Plateformes Cloud:
- Google Cloud : Guide de démarrage rapide GCP
- Amazon AWS : Guide de démarrage rapide AWS
- Microsoft Azure : Guide de démarrage rapide AzureML
- Configuration locale:
- Docker: Guide de démarrage rapide Docker
- Docker: Guide de démarrage rapide Docker
État du projet
Ce badge indique que tous les tests d'Actions GitHub Intégration Continue (CI) de YOLOv5 réussissent. Ces tests CI rigoureux couvrent les fonctionnalités de base, notamment l'entraînement, la validation, l'inférence, l'exportation et les benchmarks, sur les systèmes d'exploitation macOS, Windows et Ubuntu. Les tests sont exécutés automatiquement toutes les 24 heures et à chaque commit de code, garantissant une stabilité constante et des performances optimales.
FAQ
Foire aux questions
Comment entraîner YOLOv5 sur mon propre jeu de données ?
L'entraînement de YOLOv5 sur un jeu de données personnalisé implique plusieurs étapes clés :
- Préparer votre jeu de données: Collectez des images et annotez-les. Assurez-vous que les annotations sont dans le format requis Format YOLO. Organisez les images et les étiquettes dans
train/
etval/
(et éventuellementtest/
) répertoires. Pensez à utiliser des modèles comme Google Gemini, SAM2, ou YOLOWorld pour aider ou automatiser le processus d'étiquetage (voir Section 1.2). - Configurez votre environnement: Clonez le dépôt YOLOv5 et installez les dépendances en utilisant
pip install -r requirements.txt
.git clone https://github.com/ultralytics/yolov5 cd yolov5 pip install -r requirements.txt
- Créer une configuration d'ensemble de données: Définissez les chemins d'accès aux ensembles de données, le nombre de classes et les noms de classes dans un
dataset.yaml
. - Démarrer l'entraînement: Exécuter la méthode
train.py
script, en fournissant les chemins d'accès à vosdataset.yaml
, les poids pré-entraînés souhaités (par exemple,yolov5s.pt
), la taille de l'image, la taille du lot et le nombre d'epochs.python train.py --img 640 --batch 16 --epochs 100 --data path/to/your/dataset.yaml --weights yolov5s.pt
Pourquoi devrais-je utiliser Ultralytics HUB pour entraîner mes modèles YOLO ?
Ultralytics HUB est une plateforme complète conçue pour rationaliser l'ensemble du cycle de vie du développement de modèles YOLO, souvent sans avoir à écrire de code. Les principaux avantages sont les suivants :
- Entraînement simplifié : Entraînez facilement des modèles à l'aide d'environnements préconfigurés et d'une interface utilisateur intuitive.
- Gestion intégrée des données : Téléchargez, contrôlez les versions et gérez efficacement vos ensembles de données au sein de la plateforme.
- Surveillance en temps réel : Suivez la progression de l’entraînement et visualisez les mesures de performance à l’aide d’outils intégrés tels que Comet ou TensorBoard.
- Fonctionnalités de collaboration : Facilite le travail d’équipe grâce à des ressources partagées, des outils de gestion de projet et un partage facile des modèles.
- Déploiement sans code : Déployez les modèles entraînés directement vers différentes cibles.
Pour une présentation pratique, consultez notre article de blog : Comment entraîner vos modèles personnalisés avec Ultralytics HUB.
Comment puis-je convertir mes données annotées au format YOLOv5 ?
Que vous annotiez manuellement ou que vous utilisiez des outils automatisés (comme ceux mentionnés dans la section 1.2), les étiquettes finales doivent être dans le format YOLO spécifique requis par YOLOv5 :
- En créer un
.txt
fichier pour chaque image. Le nom de fichier doit correspondre au nom de fichier de l'image (par exemple,image1.jpg
correspond àimage1.txt
). Placez ces fichiers dans unlabels/
répertoire parallèle à votreimages/
répertoire (par exemple,../datasets/mydataset/labels/train/
). - Chaque ligne d'un
.txt
fichier représente une annotation d'objet et suit le format :class_index center_x center_y width height
. - Coordonnées (
center_x
,center_y
,width
,height
) doit être normalisé (valeurs comprises entre 0,0 et 1,0) par rapport aux dimensions de l'image. - Les indices de classe sont base zéro (la première classe est
0
, le second est1
, etc.).
De nombreux outils d'annotation manuelle offrent une exportation directe au format YOLO. Si vous utilisez des modèles automatisés, vous aurez besoin de scripts ou de processus pour convertir leur sortie (par exemple, les coordonnées des boîtes englobantes, les masques de segmentation) dans ce format de texte normalisé spécifique. Assurez-vous que la structure de votre ensemble de données final respecte l'exemple fourni dans le guide. Pour plus de détails, consultez notre Guide de collecte et d'annotation de données.
Quelles sont les options de licence pour l'utilisation de YOLOv5 dans des applications commerciales ?
Ultralytics propose des licences flexibles adaptées à différents besoins :
- Licence AGPL-3.0 : Cette licence open source convient à la recherche universitaire, aux projets personnels et aux situations où la conformité à l’open source est acceptable. Elle exige que les modifications et les œuvres dérivées soient également open source sous AGPL-3.0. Consultez les détails de la licence AGPL-3.0.
- Licence Entreprise : Une licence commerciale conçue pour les entreprises intégrant YOLOv5 dans des produits ou services propriétaires. Cette licence supprime les obligations open source d'AGPL-3.0, permettant une distribution en source fermée. Visitez notre page de licence pour plus de détails ou pour demander une licence Entreprise.
Sélectionnez la licence qui correspond le mieux aux exigences de votre projet et à votre modèle de distribution.