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

📚 Ce guide explique comment entraîner ton propre dataset 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 détection d'objets générique.

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 indispensable. Les modèles et datasets sont téléchargés automatiquement depuis la dernière version 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înement sur des données personnalisées#

Le développement d'un modèle de détection d'objets personnalisé est un processus itératif :

1. Collecter et organiser les images : Rends-toi sur les images pertinentes pour ta tâche spécifique. Des données diversifiées et de haute qualité sont cruciales. Consulte notre guide sur la collecte et l'annotation de données.
2. Étiqueter les objets : Annote précisément 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 de l'apprentissage par transfert en commençant par des poids pré-entraînés.
4. Déployer et prédire : Utilise le modèle entraîné pour l'inférence sur de nouvelles données invisibles.
5. Collecter les cas limites : Identifie les scénarios où le modèle donne de mauvais résultats (cas limites) et ajoute des données similaires à ton dataset pour améliorer la robustesse. Répète le cycle.

Ultralytics Platform offre une solution rationalisée et sans code pour l'ensemble de ce cycle de MLOps (opérations de machine learning), 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 jeu de données est essentielle.

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. L'organisation correcte de ton jeu de données est clé.

1.1 Créer dataset.yaml#

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

La structure du fichier dataset.yaml comprend :

• path : Le répertoire racine contenant le dataset.
• train, val, test : Chemins relatifs de 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 (en commençant par 0) à leurs noms de classe correspondants.

Tu peux définir path sur un répertoire absolu (par exemple, /home/user/datasets/coco128) ou sur un chemin relatif tel que ../datasets/coco128 lors du lancement de 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 Tirer parti des modèles pour l'étiquetage automatisé#

L'étiquetage manuel est l'approche courante mais prend du temps. Les modèles de fondation peuvent automatiser ou semi-automatiser l'annotation et accélérer la création du jeu de données. Exemples de modèles pouvant 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 recevoir des instructions pour identifier et localiser des objets dans des images, 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 haute précision. Bien qu'ils soient principalement destinés à 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. Tu peux fournir des descriptions textuelles des objets qui t'intéressent, et YOLOWorld peut les localiser dans les 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 d'examiner 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 ton modèle YOLOv5 entraîné. Après avoir généré (et éventuellement affiné) tes étiquettes, assure-toi 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 à 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 au format YOLO *.txt 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ées dans une plage comprise entre 0 et 1. Pour y parvenir, divise les valeurs de 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'étiquettes 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 prévoit que le répertoire du dataset (par exemple, /coco128) réside dans un dossier /datasets situé de manière adjacente au 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 lancer 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 deuxième plus petit et le plus rapide des modèles, adapté aux environnements aux ressources limitées. Consulte le tableau du README pour une comparaison détaillée de tous les modèles disponibles.

Entraîner#

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

• --img : Définit la taille d'image d'entrée (par exemple, --img 640). Des tailles plus grandes génèrent généralement une meilleure précision mais nécessitent plus de mémoire GPU.
• --batch : Détermine la taille du lot (par exemple, --batch 16). Choisis la taille maximale que ton GPU peut gérer.
• --epochs : Spécifie le nombre total d'époques d'entraînement (par exemple, --epochs 100). Une époque représente un passage complet sur l'ensemble du dataset d'entraînement.
• --data : Chemin d'accès à ton fichier dataset.yaml (par exemple, --data coco128.yaml).
• --weights : Chemin d'accès au fichier de poids initiaux. 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 t'entraîner à partir de zéro (déconseillé sauf si tu disposes d'un dataset très volumineux et de 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/exp2, etc.). Pour une expérience interactive et pratique, explore la section dédiée à l'entraînement dans nos notebooks de tutoriels 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 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 points de contrôle du modèle, et analyse les prédictions du modèle à l'aide 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 plus sur les capacités de Comet dans leur documentation officielle. Essaie le notebook Colab de Comet pour une démo en direct :

Journalisation et automatisation ClearML#

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

• Installe le paquet : pip install clearml
• Initialise ClearML : Exécute clearml-init une fois pour te connecter à ton serveur ClearML (qu'il soit auto-hébergé ou sur l'offre gratuite).

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, garantissant une reproductibilité totale. Tu peux facilement planifier des tâches d'entraînement sur des agents distants et gérer les versions des datasets à l'aide de ClearML Data. Explore le guide d'intégration ClearML pour des détails complets.

Journalisation locale#

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

• Les pertes et métriques de performance d'entraînement et de validation.
• 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.
• Les métriques d'évaluation clés telles que les courbes Précision-Rappel (PR).
• Les 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 tracé sous la forme results.png une fois l'entraînement terminé. Tu peux également tracer n'importe quel fichier results.csv manuellement à 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

Prochaines étapes#

À la fin de l'entraînement, le point de contrôle du modèle le plus performant (best.pt) est sauvegardé et prêt pour le déploiement ou un affinement supplémentaire. Les prochaines étapes potentielles incluent :

• Exécuter l'inférence sur de nouvelles images ou vidéos à l'aide du modèle entraîné via la CLI ou Python.
• Effectuer la validation pour évaluer la précision du modèle et ses capacités de généralisation sur différents sous-ensembles de données (par exemple, un ensemble de test mis de côté).
• Exporter le modèle vers divers formats de déploiement tels que ONNX, TensorFlow SavedModel ou TensorRT pour une inférence optimisée sur diverses plateformes.
• Employer des techniques d'optimisation des hyperparamètres pour potentiellement extraire 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 diversifiées et stimulantes basées sur l'analyse des performances.

Environnements pris en charge#

Ultralytics fournit des environnements prêts à l'emploi équipés de dépendances essentielles telles que 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#

Ce badge indique que tous les tests Continuous Integration (CI) GitHub Actions 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 à chaque commit de code, garantissant une stabilité constante et des performances optimales.

FAQ#