Entraîne YOLOv5 sur des données personnalisées

📚 Ce guide t'explique comment entraîner ton propre dataset personnalisé en utilisant le modèle YOLOv5 🚀. L'entraînement de modèles personnalisés est une étape fondamentale pour adapter les solutions de computer vision à des applications réelles spécifiques, au-delà de la simple object detection.

Avant de commencer

Tout d'abord, assure-toi d'avoir configuré l'environnement nécessaire. Clone le dépôt YOLOv5 et installe les dépendances requises à partir de requirements.txt. Un environnement Python>=3.8.0 avec PyTorch>=1.8 est essentiel. Les modèles et les datasets sont téléchargés automatiquement depuis la dernière release de YOLOv5 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 d' object detection personnalisé est un processus itératif :

1. Collecter & Organiser les images : Rassemble des images pertinentes pour ta tâche spécifique. Des données diverses et de haute qualité sont cruciales. Consulte notre guide sur la collecte et l'annotation de données.
2. Étiqueter les objets : Annote avec précision les objets qui t'intéressent dans tes images.
3. Entraîner un modèle : Utilise les données étiquetées pour entraîner ton modèle YOLOv5. Tire parti du transfer learning en commençant avec des poids pré-entraînés.
4. Déployer & Prédire : Utilise le modèle entraîné pour l' inference sur de nouvelles données inédites.
5. Collecter les cas limites : Identifie les scénarios où le modèle obtient de mauvais résultats (edge cases) et ajoute des données similaires à ton dataset pour améliorer la robustesse. Répète le cycle.

La plateforme Ultralytics offre une solution simplifiée et sans code pour tout ce cycle de machine learning operations (MLOps), incluant la gestion des datasets, l'entraînement des modèles et le déploiement.

Avant de lancer l'entraînement, la préparation du dataset est essentielle.

Créer un dataset

Les modèles YOLOv5 nécessitent des données étiquetées pour apprendre les caractéristiques visuelles des classes d'objets. Organiser correctement ton dataset est la clé.

1.1 Créer dataset.yaml

Le fichier de configuration du dataset (par exemple coco128.yaml) définit la structure du dataset, les noms des classes et les chemins vers les répertoires d'images. COCO128 sert de petit dataset d'exemple, comprenant les 128 premières images du vaste dataset COCO. Il est utile pour tester rapidement le pipeline d'entraînement et diagnostiquer des problèmes potentiels comme l' overfitting.

La structure du fichier dataset.yaml comprend :

• path : Le répertoire racine contenant le dataset.
• train, val, test : Chemins relatifs depuis path vers les répertoires contenant les images ou des fichiers texte listant les chemins d'images pour les ensembles d'entraînement, de validation et de test.
• names : Un dictionnaire mappant les indices de classe (en commençant par 0) à leurs noms de classe correspondants.

Tu peux définir path soit sur un répertoire absolu (par exemple /home/user/datasets/coco128), soit sur un chemin relatif comme ../datasets/coco128 lors du lancement de l'entraînement depuis la racine du dépôt YOLOv5.

Voici 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 Utiliser des modèles pour l'étiquetage automatisé

L'étiquetage manuel est l'approche courante mais il prend du temps. Les modèles de fondation peuvent automatiser ou semi-automatiser l'annotation et accélérer la création de datasets. Exemples de modèles pouvant aider à générer des étiquettes :

• Google Gemini : Les grands modèles multimodaux comme Gemini possèdent de puissantes capacités de compréhension d'image. Ils peuvent être incité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. Explore 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 des objets avec une grande précision. Bien que principalement destinés à la segmentation, les masques résultants peuvent souvent être convertis en annotations de boîte englobante adaptées aux tâches d'object detection.
• YOLOWorld : Ce modèle offre des capacités de détection à vocabulaire ouvert. Tu peux fournir des descriptions textuelles des objets qui t'intéressent, et YOLOWorld peut les localiser dans des images sans entraînement préalable sur ces classes spécifiques. Cela peut servir de point de départ pour générer des étiquettes initiales, qui pourront ensuite être affinées.

L'utilisation de ces modèles peut fournir une étape de "pré-étiquetage", réduisant l'effort manuel requis. Cependant, il est crucial de réviser et d'affiner les étiquettes générées automatiquement pour garantir l'exactitude et la cohérence, car la qualité impacte directement les performances de ton modèle YOLOv5 entraîné. Après avoir généré (et potentiellement affiné) tes étiquettes, assure-toi qu'elles respectent le format YOLO : un fichier *.txt 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, aucun fichier *.txt correspondant n'est nécessaire.

Les spécifications du fichier *.txt au format YOLO sont précises :

• Une ligne par objet bounding box.
• Chaque ligne doit contenir : class_index x_center y_center width height.
• Les coordonnées doivent être normalisées sur une plage comprise entre 0 et 1. Pour y parvenir, divise les valeurs en pixels de x_center et width par la largeur totale de l'image, et divise y_center et height 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, la deuxième par 1, et ainsi de suite).

Le fichier d'étiquette correspondant à l'image ci-dessus, contenant deux objets 'person' (indice de classe 0) et un objet 'tie' (indice de classe 27), ressemblerait à ceci :

1.3 Organiser les répertoires

Structure ton répertoire de datasets comme illustré ci-dessous. Par défaut, YOLOv5 s'attend à ce que le répertoire du dataset (par exemple /coco128) réside dans un dossier /datasets situé à côté de celui du répertoire du dépôt /yolov5.

YOLOv5 localise automatiquement les étiquettes pour chaque image en remplaçant la dernière occurrence de /images/ dans le chemin de l'image par /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 :

/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)
            └── ...

Sélectionner un modèle

Choisis un modèle pré-entraîné pour initier le processus d'entraînement. 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 propose différentes tailles de modèles, chacune équilibrant la vitesse et la précision différemment. Par exemple, YOLOv5s est le modèle le plus petit et le plus rapide, adapté aux environnements aux ressources limitées. Consulte le tableau README pour une comparaison détaillée de tous les modèles disponibles.

Entraîner

Commence l' entraînement du modèle en utilisant le script train.py. Les arguments essentiels incluent :

• --img : Définit la taille de l'image d'entrée (par exemple --img 640). Des tailles plus grandes donnent généralement une meilleure précision mais nécessitent plus de mémoire GPU.
• --batch : Détermine la taille du batch (par exemple --batch 16). Choisis la plus grande taille que ton GPU peut gérer.
• --epochs: Specifies the total number of training epochs (e.g., --epochs 100). One epoch represents a full pass over the entire training dataset.
• --data : Chemin vers ton fichier dataset.yaml (par exemple --data coco128.yaml).
• --weights : Chemin vers le fichier de poids initial. L'utilisation de poids pré-entraînés (par exemple --weights yolov5s.pt) est fortement recommandée pour une convergence plus rapide et des résultats supérieurs. Pour entraîner à partir de zéro (non conseillé sauf si tu as un très grand dataset et des besoins spécifiques), utilise --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

Tous les résultats d'entraînement, y compris les poids et les journaux, sont enregistrés dans le répertoire runs/train/. Chaque session d'entraînement crée un nouveau sous-répertoire (par exemple runs/train/exp, runs/train/exp-2, etc.). Pour une expérience interactive et pratique, explore la section entraînement dans nos notebooks de tutoriel officiels :

Visualiser

YOLOv5 s'intègre parfaitement avec 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 avec Comet

Comet est entièrement intégré pour un suivi complet des expériences. Visualise les métriques en direct, enregistre les hyperparamètres, gère les datasets et les checkpoints de modèles, et analyse les prédictions du modèle en utilisant des panneaux personnalisés Comet interactifs.

Commencer 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!

Plonge plus profondément dans les fonctionnalités prises en charge dans notre guide d'intégration Comet. Apprends-en davantage sur les capacités de Comet à partir de leur documentation officielle. Essaie le notebook Comet Colab pour une démo en direct :

Journalisation et automatisation avec ClearML

L'intégration de ClearML permet un suivi détaillé des expériences, la gestion des versions de datasets et même l'exécution distante des entraînements. Active ClearML avec ces étapes simples :

• Installe le package : pip install clearml
• Initialise ClearML : Exécute clearml-init une fois pour te connecter à ton serveur ClearML (qu'il soit auto-hébergé ou via 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. Tu peux facilement planifier des tâches d'entraînement sur des agents distants et gérer les versions de datasets en utilisant ClearML Data. Explore le guide d'intégration ClearML pour des détails complets.

Journalisation locale

Les résultats d'entraînement sont automatiquement journalisés en utilisant TensorBoard et enregistrés sous forme de fichiers CSV dans le répertoire d'expérience spécifique (par exemple runs/train/exp). Les données journalisées incluent :

• La perte d'entraînement et de validation ainsi que les métriques de performance.
• Des exemples d'images montrant les augmentations appliquées (comme les mosaïques).
• Les étiquettes de vérité terrain aux côtés des prédictions du modèle pour une inspection visuelle.
• Des métriques d'évaluation clés telles que les courbes Precision-Recall (PR).
• Des matrices de confusion pour une analyse détaillée des performances par classe.

Le fichier results.csv est mis à jour après chaque époque et est tracé en tant que results.png une fois l'entraînement terminé. Tu peux également tracer manuellement n'importe quel fichier results.csv 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

Étapes suivantes

Une fois l'entraînement terminé avec succès, le meilleur checkpoint de modèle (best.pt) est enregistré et prêt pour le déploiement ou un affinement ultérieur. Les étapes suivantes possibles incluent :

• Exécuter l' inference sur de nouvelles images ou vidéos en utilisant le modèle entraîné via le CLI ou Python.
• Effectuer la 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é).
• Exporter le modèle vers divers formats de déploiement comme ONNX, TensorFlow SavedModel ou TensorRT pour une inférence optimisée sur diverses plateformes.
• Employer des techniques d' hyperparameter tuning pour potentiellement obtenir des gains de performance supplémentaires.
• Continuer à améliorer ton modèle en suivant nos Conseils pour de meilleurs résultats d'entraînement et en ajoutant de manière itérative des données plus diverses et stimulantes basées sur l'analyse des performances.

Environnements pris en charge

Ultralytics fournit des environnements prêts à l'emploi équipés des dépendances essentielles comme CUDA, cuDNN, Python et PyTorch, facilitant 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

Statut du projet

This badge indicates that all YOLOv5 GitHub Actions Continuous Integration (CI) tests are passing successfully. These rigorous CI tests cover the core functionalities, including training, validation, inference, export, and benchmarks, across macOS, Windows, and Ubuntu operating systems. Tests are executed automatically every 24 hours and upon each code commit, ensuring consistent stability and optimal performance.

FAQ

Comment puis-je entraîner YOLOv5 sur mon dataset personnalisé ?

L'entraînement de YOLOv5 sur un jeu de données personnalisé implique plusieurs étapes clés :

1. Prépare ton jeu de données : Collecte des images et annote-les. Assure-toi que les annotations respectent le format YOLO requis. Organise les images et les étiquettes dans des répertoires train/ et val/ (et éventuellement test/). Envisage d'utiliser des modèles comme Google Gemini, SAM2 ou YOLOWorld pour t'aider ou automatiser le processus d'étiquetage (voir la section 1.2).
2. Configure ton environnement : Clone le dépôt YOLOv5 et installe les dépendances via pip install -r requirements.txt.

   git clone https://github.com/ultralytics/yolov5
   cd yolov5
   pip install -r requirements.txt

3. Crée la configuration du jeu de données : Définit les chemins d'accès au jeu de données, le nombre de classes et les noms des classes dans un fichier dataset.yaml.
4. Lance l'entraînement : Exécute le script train.py en fournissant les chemins vers ton dataset.yaml, les poids pré-entraînés souhaités (par ex. yolov5s.pt), la taille de l'image, la taille du batch et le nombre d'époques.

   python train.py --img 640 --batch 16 --epochs 100 --data path/to/your/dataset.yaml --weights yolov5s.pt

Pourquoi devrais-je utiliser Ultralytics Platform pour entraîner mes modèles YOLO ?

Ultralytics Platform est une plateforme complète conçue pour rationaliser l'ensemble du cycle de vie de développement des modèles YOLO, souvent sans avoir à écrire de code. Les principaux avantages incluent :

• Entraînement simplifié : Entraîne facilement tes modèles en utilisant des environnements pré-configurés et une interface utilisateur intuitive.
• Gestion intégrée des données : Télécharge, gère le versionnage et pilote tes jeux de données efficacement au sein de la plateforme.
• Surveillance en temps réel : Suis la progression de l'entraînement et visualise les métriques de performance à l'aide d'outils intégrés comme Comet ou TensorBoard.
• Fonctionnalités de collaboration : Facilite le travail en équipe grâce au partage de ressources, aux outils de gestion de projet et au partage simplifié de modèles.
• Déploiement sans code : Déploie les modèles entraînés directement vers diverses cibles.

Pour une démonstration pratique, consulte notre article de blog : Comment entraîner tes modèles personnalisés avec Ultralytics Platform.

Comment convertir mes données annotées au format YOLOv5 ?

Que tu annoteras manuellement ou que tu utilises des outils automatisés (comme ceux mentionnés dans la section 1.2), les étiquettes finales doivent être au format YOLO spécifique requis par YOLOv5 :

• Crée un fichier .txt pour chaque image. Le nom du fichier doit correspondre au nom de l'image (par ex. image1.jpg correspond à image1.txt). Place ces fichiers dans un répertoire labels/ parallèle à ton répertoire images/ (par ex. ../datasets/mydataset/labels/train/).
• Chaque ligne dans un fichier .txt représente une annotation d'objet et suit le format : class_index center_x center_y width height.
• Les coordonnées (center_x, center_y, width, height) doivent être normalisées (valeurs entre 0.0 et 1.0) par rapport aux dimensions de l'image.
• Les indices de classe sont basés sur zéro (la première classe est 0, la seconde est 1, etc.).

De nombreux outils d'annotation manuelle offrent une exportation directe au format YOLO. Si tu utilises des modèles automatisés, tu auras besoin de scripts ou de processus pour convertir leur sortie (par ex. coordonnées de la bbox, masques de segmentation) dans ce format texte normalisé spécifique. Assure-toi que la structure finale de ton jeu de données respecte l'exemple fourni dans le guide. Pour plus de détails, voir notre Guide de collecte et d'annotation de données.

Quelles sont les options de licence pour utiliser YOLOv5 dans des applications commerciales ?

Ultralytics propose des licences flexibles adaptées aux différents besoins :

• Licence AGPL-3.0 : Cette licence open-source est adaptée à la recherche universitaire, aux projets personnels et aux situations où la conformité open-source est acceptable. Elle impose que les modifications et les œuvres dérivées soient également open-source sous licence AGPL-3.0. Consulte les détails de la licence AGPL-3.0.
• Licence Enterprise : 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 de l'AGPL-3.0, permettant une distribution en code fermé. Visite notre page de licence pour plus de détails ou pour demander une licence Enterprise.

Sélectionne la licence qui correspond le mieux aux exigences et au modèle de distribution de ton projet.