Entraîner YOLOv5 sur des données personnalisées#

📚 Ce guide explique comment entraîner ton propre jeu de données personnalisé à l’aide du 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 concrètes spécifiques, au-delà de la simple détection d’objets.

Avant de commencer#

Commence par vérifier que ton environnement est correctement configuré. Clone le dépôt YOLOv5 et installe les dépendances requises depuis requirements.txt. Un environnement Python>=3.8.0 avec PyTorch>=1.8 est indispensable. Les modèles et les jeux de données sont automatiquement téléchargés depuis la version la plus récente 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 personnalisé de détection d’objets est un processus itératif :

1. Collecter et organiser les images : rassemble des images pertinentes pour ta tâche spécifique. Des données diversifiées et de haute qualité sont essentielles. Consulte notre guide sur la collecte et l’annotation des données.
2. Étiqueter les objets : annote précisément les objets d’intérêt présents dans tes images.
3. Entraîner un modèle : utilise les données étiquetées pour entraîner ton modèle YOLOv5. Tire parti de l’apprentissage par transfert en commençant avec des poids préentraînés.
4. Déployer et prédire : utilise le modèle entraîné pour effectuer des inférences sur de nouvelles données inédites.
5. Collecter les cas limites : identifie les scénarios dans lesquels le modèle est peu performant (les cas limites) et ajoute des données similaires à ton jeu de données afin d’améliorer sa robustesse. Répète le cycle.

La plateforme Ultralytics offre une solution simplifiée sans code pour l’ensemble de ce cycle d’opérations de machine learning (MLOps), notamment la gestion des jeux de données, l’entraînement des modèles et le déploiement.

Avant de commencer l’entraînement, il est essentiel de préparer le jeu de données.

1. Créer un jeu de données#

Les modèles YOLOv5 ont besoin de données étiquetées pour apprendre les caractéristiques visuelles des classes d’objets. Il est essentiel d’organiser correctement ton jeu de données.

1.1 Créer dataset.yaml#

Le fichier de configuration du jeu de données (par exemple, coco128.yaml) décrit sa structure, les noms des classes et les chemins vers les répertoires d’images. COCO128 est un petit exemple de jeu de données composé des 128 premières images du vaste jeu de données COCO. Il est utile pour tester rapidement le pipeline d’entraînement et diagnostiquer d’éventuels problèmes comme le surapprentissage.

La structure du fichier dataset.yaml comprend :

• path : le répertoire racine contenant le jeu de données.
• train, val, test : chemins relatifs depuis path vers les répertoires contenant les images ou les fichiers texte répertoriant les chemins des images pour les ensembles d’entraînement, de validation et de test.
• names : un dictionnaire associant les indices de classe (à partir de 0) aux noms de classe correspondants.

Tu peux définir path comme un répertoire absolu (par exemple, /home/user/datasets/coco128) ou comme un chemin relatif tel que ../datasets/coco128 lorsque tu lances l’entraînement depuis la racine du dépôt YOLOv5.

Voici la structure de 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 Exploiter les modèles pour l’étiquetage automatique#

L’étiquetage manuel est l’approche courante, mais il prend beaucoup de temps. Les modèles fondamentaux peuvent automatiser ou semi-automatiser l’annotation et accélérer la création des jeux de données. Voici quelques exemples de modèles pouvant aider à générer des étiquettes :

• Google Gemini : les grands modèles multimodaux comme Gemini disposent de puissantes capacités de compréhension des images. Tu peux les inviter à identifier et localiser des objets dans les images afin de générer des boîtes englobantes ou des descriptions convertibles en étiquettes au format YOLO. Découvre son potentiel dans le notebook de tutoriel fourni.
• SAM2 (Segment Anything Model 2) : les modèles fondamentaux axés sur la segmentation, comme SAM2, peuvent identifier et délimiter les objets avec une grande précision. Bien qu’elles soient principalement destinées à la segmentation, les masques obtenus 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. Tu peux fournir des descriptions textuelles des objets qui t’intéressent, et YOLOWorld peut les localiser dans les images sans avoir été préalablement entraîné 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 constituer une étape de « pré-étiquetage » et réduire le travail manuel nécessaire. Il est toutefois essentiel de vérifier et d’affiner les étiquettes générées automatiquement afin de garantir leur exactitude et leur cohérence, car leur qualité influe directement sur les performances de ton modèle YOLOv5 entraîné. Après avoir généré (et éventuellement affiné) tes étiquettes, vérifie qu’elles respectent le format YOLO : un fichier *.txt par image, chaque ligne représentant un objet sous la forme class_index x_center y_center width height (coordonnées normalisées, classe indexée à partir de 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 boîte englobante.
• Chaque ligne doit contenir : class_index x_center y_center width height.
• Les coordonnées doivent être normalisées dans une plage comprise entre 0 et 1. Pour cela, divise les valeurs en pixels de x_center et width par la largeur totale de l’image, puis divise y_center et height par la hauteur totale de l’image.
• Les indices de classe commencent à 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’étiquettes correspondant à l’image ci-dessus, contenant deux objets « person » (indice de classe 0) et un objet « tie » (indice de classe 27), se présenterait ainsi :

1.3 Organiser les répertoires#

Structure ton répertoire de jeux de données comme illustré ci-dessous. Par défaut, YOLOv5 s’attend à trouver le répertoire du jeu de données (par exemple, /coco128) dans un dossier /datasets situé à côté du répertoire du dépôt /yolov5.

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

Choisis un modèle préentraîné pour commencer 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 offrant un compromis différent entre vitesse et précision. Par exemple, YOLOv5s est le deuxième plus petit modèle et le plus rapide, adapté aux environnements disposant de ressources limitées. Consulte le tableau du README pour une comparaison détaillée de tous les modèles disponibles.

3. Entraîner#

Commence l’entraînement du modèle à l’aide du script train.py. Les arguments essentiels sont les suivants :

• --img : définit la taille de l’image d’entrée (par exemple, --img 640). Les grandes tailles offrent généralement une meilleure précision, mais nécessitent davantage 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 : indique le nombre total d’époques d’entraînement (par exemple, --epochs 100). Une époque correspond à un passage complet sur l’ensemble du jeu de données d’entraînement.
• --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 vivement recommandée pour une convergence plus rapide et de meilleurs résultats. Pour entraîner le modèle à partir de zéro (ce qui est déconseillé, sauf si tu disposes d’un très grand jeu de données et de besoins spécifiques), utilise --weights '' --cfg yolov5s.yaml.

Les poids préentraînés sont automatiquement téléchargés depuis la version la plus récente 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 de l’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/exp2, etc.). Pour une expérience interactive et pratique, consulte la section consacrée à l’entraînement dans nos notebooks de tutoriels officiels :

4. Visualiser#

YOLOv5 s’intègre parfaitement à différents 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 assurer un suivi complet des expériences. Visualise les métriques en direct, enregistre les hyperparamètres, gère les jeux de données et les points de contrôle des modèles, et analyse les prédictions des modèles à l’aide des panneaux personnalisés Comet interactifs.

La prise en main 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!

Approfondis les fonctionnalités prises en charge dans notre guide d’intégration de Comet. Découvre les capacités de Comet dans leur documentation officielle. Essaie le notebook Colab de Comet pour une démonstration en direct :

Journalisation et automatisation avec ClearML#

L’intégration de ClearML permet un suivi détaillé des expériences, la gestion des versions des jeux de données et même l’exécution à distance des entraînements. Active ClearML en suivant ces quelques étapes :

• Installe le paquet : pip install clearml
• Initialise ClearML : exécute clearml-init une fois pour te connecter à ton serveur ClearML (auto-hébergé ou utilisant le niveau gratuit).

ClearML capture automatiquement les détails des expériences, les téléchargements de modèles, les comparaisons, les modifications de code non validées et les paquets installés, afin de garantir une reproductibilité complète. Tu peux facilement planifier des tâches d’entraînement sur des agents distants et gérer les versions des jeux de données avec ClearML Data. Consulte le guide d’intégration de ClearML pour plus de détails.

Journalisation locale#

Les résultats de l’entraînement sont automatiquement journalisés avec TensorBoard et enregistrés sous forme de fichiers CSV dans le répertoire de l’expérience concernée (par exemple, runs/train/exp). Les données journalisées comprennent :

• Les pertes et les métriques de performance de l’entraînement et de la validation.
• Des exemples d’images montrant les augmentations appliquées (comme les mosaïques).
• Les étiquettes de vérité terrain accompagnées des prédictions du modèle pour une inspection visuelle.
• Des métriques d’évaluation clés telles que les courbes Précision-Rappel (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 représenté sous forme de results.png une fois l’entraînement terminé. Tu peux également tracer manuellement n’importe quel fichier results.csv à l’aide de 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. Étapes suivantes#

Une fois l’entraînement terminé avec succès, le meilleur point de contrôle du modèle (best.pt) est enregistré et prêt à être déployé ou affiné. Les prochaines étapes possibles comprennent :

• Effectuer une inférence sur de nouvelles images ou vidéos avec le 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érentes partitions de données (par exemple, un ensemble de test mis de côté).
• Exporter le modèle vers différents formats de déploiement, tels que ONNX, TensorFlow SavedModel ou TensorRT, pour optimiser l’inférence sur diverses plateformes.
• Utiliser des techniques d’optimisation des hyperparamètres pour obtenir éventuellement des gains de performance supplémentaires.
• Continue d’améliorer ton modèle en suivant nos conseils pour obtenir les meilleurs résultats d’entraînement et en ajoutant progressivement des données plus diversifiées et plus difficiles selon 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, afin de te permettre de démarrer facilement.

• Notebooks GPU gratuits :
  • 
  • 
  • 
• Plateformes cloud :
  • Google Cloud : Guide de démarrage rapide de 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 de Docker

État du projet#

Ce badge indique que tous les tests GitHub Actions d’intégration continue (CI) de YOLOv5 réussissent. Ces tests CI rigoureux couvrent les fonctionnalités principales, 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 après chaque commit de code, afin de garantir une stabilité constante et des performances optimales.

FAQ#