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 :

1. 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.
2. Étiqueter les objets : Annotez avec précision les objets d'intérêt dans vos images.
3. 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.
4. Déployer et prédire : Utilisez le modèle entraîné pour l'inférence sur de nouvelles données non visualisées.
5. 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.

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 de path 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 et width par la largeur totale de l'image, et diviser 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, le second par 1, 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 à votre dataset.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

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

É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 :

1. 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/ et val/ (et éventuellement test/) 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).
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
   

3. 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 .
4. Démarrer l'entraînement: Exécuter la méthode train.py script, en fournissant les chemins d'accès à vos dataset.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 un labels/ répertoire parallèle à votre images/ 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 est 1, 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.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 2 mois

Commentaires