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

📚 Ce guide explique comment entraîner votre propre ensemble de données personnalisé à l'aide du logiciel YOLOv5 🚀. La formation 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 générique d'objets.

Avant de commencer

Tout d'abord, assurez-vous que vous disposez de l'environnement nécessaire. Clonez le dépôt YOLOv5 et installez les dépendances nécessaires à partir de requirements.txt. A Python.8.0 environnement avec PyTorch.8 est essentiel. Les modèles et les ensembles de données sont automatiquement téléchargés à partir de la dernière version de YOLOv5 libération 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

Formation sur les 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. Il est essentiel de disposer de données diversifiées et de haute qualité. Voir notre guide sur la collecte et l'annotation des données.
2. Étiqueter les objets: Annotez avec précision les objets intéressants de vos images.
3. Entraîner un modèle: Utilisez les données étiquetées pour former 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: Utiliser le modèle formé pour l'inférence sur de nouvelles données inédites.
5. Recueillir les cas limites: Identifiez les scénarios dans lesquels le modèle donne de mauvais résultats(cas limites) et ajoutez des données similaires à votre ensemble de données afin d'en améliorer la robustesse. Répétez le cycle.

Ultralytics HUB offre une solution rationalisée, sans code, pour l'ensemble du cycle des 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 d'entamer la formation, il est essentiel de préparer le jeu de données.

1. Créer un ensemble de données

Les modèles YOLOv5 nécessitent des données étiquetées pour apprendre les caractéristiques visuelles des classes d'objets. Il est essentiel d'organiser correctement votre ensemble de données.

1.1 Créer dataset.yaml

Le fichier de configuration du jeu de données (par exemple, coco128.yaml) décrit la structure de l'ensemble de données, les noms des classes et les chemins d'accès aux répertoires d'images. COCO128 sert de petit ensemble de données d'exemple, comprenant les 128 premières images de la base de données extensive. COCO . Il est utile pour tester rapidement le pipeline de formation et diagnostiquer des problèmes potentiels tels que surajustement.

Le dataset.yaml comprend la structure du fichier :

• path: Le répertoire racine contenant le jeu de données.
• train, val, test: Chemins relatifs 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 établissant une correspondance entre les indices des classes (à partir de 0) et les noms des classes correspondantes.

Vous trouverez ci-dessous la structure de coco128.yaml (voir sur GitHub) :

# Dataset root directory relative to the yolov5 directory
path: ../datasets/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 automatisé

Bien que l'étiquetage manuel à l'aide d'outils soit une approche courante, le processus peut prendre beaucoup de temps. Les progrès récents des modèles de fondation offrent des possibilités d'automatisation ou de semi-automatisation du processus d'annotation, ce qui peut accélérer considérablement la création d'ensembles de données. Voici quelques exemples de modèles qui peuvent aider à générer des étiquettes :

• Google Gemini: Les grands modèles multimodaux comme Gemini possèdent de puissantes capacités de compréhension des images. Ils peuvent être invités à identifier et à localiser des objets dans des images, en générant des boîtes de délimitation ou des descriptions qui peuvent être converties en étiquettes au format YOLO . Explorez son potentiel dans le carnet de notes 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 qu'ils soient principalement destinés à la segmentation, les masques obtenus peuvent souvent être convertis en annotations de boîtes de délimitation adaptées aux tâches de détection d'objets.
• YOLOWorld: Ce modèle offre des capacités de détection à partir d'un vocabulaire ouvert. Vous pouvez fournir des descriptions textuelles des objets qui vous intéressent, et YOLOWorld peut les localiser dans les images sans formation 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 constituer une étape de "pré-étiquetage", réduisant l'effort manuel nécessaire. Cependant, il est essentiel de revoir et d'affiner les étiquettes générées automatiquement afin d'en 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 éventuellement affiné) vos étiquettes, assurez-vous qu'elles respectent la norme YOLO format: un *.txt par image, chaque ligne représentant un objet en tant que class_index x_center y_center width height (coordonnées normalisées, classe zéro). Si une image ne contient pas d'objets intéressants, aucun objet correspondant n'a été identifié. *.txt est nécessaire.

Le format YOLO *.txt les spécifications des fichiers sont précises :

• Une ligne par boîte de délimitation de l'objet.
• Chaque ligne doit contenir class_index x_center y_center width height.
• Les coordonnées doivent être normalisé à une valeur comprise entre 0 et 1. Pour ce faire, divisez les valeurs des pixels 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 par zéro (c'est-à-dire que la première classe est représentée par 0, le second par 1et ainsi de suite).

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

1.3 Organiser les répertoires

Structurez votre ensembles de données comme illustré ci-dessous. Par défaut, YOLOv5 anticipe le répertoire du jeu de données (par exemple, /coco128) de résider à l'intérieur d'un /datasets dossier situé adjacente à les /yolov5 dans le répertoire du dépôt.

YOLOv5 localise automatiquement les étiquettes pour chaque image en substituant la dernière instance de /images/ dans le chemin de l'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 de formation. 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èle, chacune équilibrant différemment la vitesse et la précision. Par exemple, YOLOv5s est le deuxième modèle le plus petit et le plus rapide, adapté aux environnements à ressources limitées. Consultez le tableau README pour une comparaison détaillée de tous les modèles disponibles.

3. Train

Commencer le formation au modèle en utilisant le train.py scénario. Les arguments essentiels sont les suivants :

• --img: Définit l'entrée taille de l'image (par exemple, --img 640). Des tailles plus importantes permettent généralement d'obtenir une meilleure précision, mais nécessitent davantage de mémoire du GPU .
• --batch: Détermine le taille du lot (par exemple, --batch 16). Choisissez la taille la plus grande que votre GPU peut supporter.
• --epochs: Spécifie le nombre total de formations époques (par exemple, --epochs 100). Une époque représente un passage complet sur l'ensemble des données d'apprentissage.
• --data: Chemin d'accès à votre dataset.yaml (par exemple, --data coco128.yaml).
• --weights: Chemin d'accès au fichier des poids initiaux. L'utilisation de poids pré-entraînés (par exemple, --weights yolov5s.pt) est fortement recommandé pour une convergence plus rapide et des résultats supérieurs. Pour s'entraîner à partir de zéro (ce qui n'est pas conseillé à moins d'avoir un très grand ensemble de données et des besoins spécifiques), utilisez --weights '' --cfg yolov5s.yaml.

Les poids pré-entraînés sont automatiquement téléchargés à partir de 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'apprentissage, y compris les poids et les journaux, sont enregistrés dans le fichier runs/train/ répertoire. Chaque session de formation crée un nouveau sous-répertoire (par exemple, runs/train/exp, runs/train/exp2etc.) Pour une expérience interactive et pratique, explorez la section de formation de nos cahiers d'exercices officiels :

4. Visualiser

YOLOv5 s'intègre de manière transparente à divers outils permettant de visualiser la progression de l'entraînement, d'évaluer les résultats et de suivre les performances en temps réel.

Comet Journalisation et visualisation 🌟 NOUVEAU

Comet est entièrement intégré pour un suivi complet des expériences. Visualisez les mesures en direct, enregistrez les hyperparamètres, gérez les ensembles de données et les points de contrôle du modèle, et analysez les prédictions du modèle à l'aide des panneaux personnalisés interactifs deComet .

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!

Pour en savoir plus sur les fonctionnalités prises en charge, consultez notre Guide d'intégration de Comet. Pour en savoir plus sur les capacités de Comet, consultez le site officiel de la société. la documentation. Essayez le carnet de notes Comet Colab pour une démonstration en direct :

ClearML Enregistrement et automatisation 🌟 NOUVEAU

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 cycles d'entraînement. 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 (qu'il soit auto-hébergé ou qu'il s'agisse de l'application volet gratuit).

ClearML capture automatiquement les détails de l'expérience, les téléchargements de modèles, les comparaisons, les changements de code non validés et les paquets installés, garantissant ainsi une reproductibilité totale. Vous pouvez facilement programmer des tâches de formation sur des agents distants et gérer les versions des jeux de données à l'aide de ClearML Data. Pour plus de détails, consultez le Guide d'intégrationClearML .

Enregistrement local

Les résultats de l'entraînement sont automatiquement enregistrés à l'aide de TensorBoard et sauvegardé en tant que CSV dans le répertoire spécifique de l'expérience (par ex, runs/train/exp). Les données enregistrées comprennent :

• Perte de formation et de validation et mesures de performance.
• Exemples d'images montrant des augmentations appliquées (comme des mosaïques).
• Étiquettes de la vérité de terrain accompagnant les prédictions du modèle pour l'inspection visuelle.
• Des mesures d'évaluation clés telles que les courbes de précision et derappel (PR).
• Matrices de confusion pour une analyse détaillée des performances par classe.

Le results.csv est mis à jour après chaque époque et est représenté sous la forme de results.png une fois la formation terminée. Vous pouvez également tracer toute 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

5. Prochaines étapes

Une fois la formation terminée avec succès, le point de contrôle du modèle le plus performant (best.pt) est sauvegardé et prêt à être déployé ou affiné. Les prochaines étapes potentielles sont les suivantes

• Exécutez l'inférence sur de nouvelles images ou vidéos à l'aide du modèle entraîné via l'interface CLI ou Python.
• Effectuer une validation afin d'évaluer la précision du modèle et ses capacités de généralisation sur différents ensembles de données (par exemple, un ensemble de tests retenus).
• Exporter le modèle vers différents formats de déploiement tels que ONNX, TensorFlow SavedModelou TensorRT pour une inférence optimisée sur diverses plateformes.
• Utiliser des techniques d'ajustement des hyperparamètres pour 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 de manière itérative des données plus variées et plus 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 CUDAcuDNN, Pythonet PyTorchfacilitant ainsi un démarrage en douceur.

• Carnets de notes gratuits GPU:
  • 
  • 
  • 
• Plates-formes en nuage:
  • 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 de Docker

État d'avancement du projet

Ce badge indique que tous les tests d'intégration continue (CI) de YOLOv5 GitHub Actions ont été passés avec succès. Ces tests rigoureux d'intégration continue couvrent les fonctionnalités de base, notamment l'entraînement, la validation, l'inférence, l'exportation et les tests de référence, sur les systèmes d'exploitation macOS, Windows et Ubuntu. Les tests sont exécutés automatiquement toutes les 24 heures et à chaque validation de code, ce qui garantit une stabilité constante et des performances optimales.

FAQ

Questions fréquemment posées

Comment entraîner YOLOv5 sur mon ensemble de données personnalisé ?

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

1. Préparer votre jeu de données: Collecter des images et les annoter. S'assurer que les annotations sont dans les YOLO format. Organiser les images et les étiquettes en train/ et val/ (et éventuellement test/). Envisagez d'utiliser des modèles tels que Google Gemini, SAM2ou YOLOWorld pour faciliter ou automatiser le processus d'étiquetage (voir section 1.2).
2. Configurer votre environnement: Cloner le dépôt YOLOv5 et installer 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 la configuration de l'ensemble de données: Définir les chemins d'accès aux ensembles de données, le nombre de classes et les noms des classes dans un fichier de données. dataset.yaml fichier.
4. Commencer la formation: Exécuter le train.py en fournissant les chemins d'accès à votre dataset.yamlles poids pré-entraînés souhaités (par ex, yolov5s.pt), la taille de l'image, la taille du lot 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 HUB pour former mes modèles YOLO ?

Ultralytics HUB est une plateforme complète conçue pour rationaliser l'ensemble du cycle de développement des modèles YOLO , souvent sans avoir besoin d'écrire le moindre code. Les principaux avantages sont les suivants :

• Formation simplifiée: Entraînez facilement les 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.
• Suivi en temps réel: Suivez les progrès de la formation 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éploiement de modèles formés directement sur diverses cibles.

Pour une démonstration pratique, consultez notre article de blog : Comment former vos modèles personnalisés avec Ultralytics HUB.

Comment 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 formatYOLO spécifique requis par YOLOv5:

• Créer un .txt pour chaque image. Le nom du fichier doit correspondre au nom du fichier de l'image (par exemple, image1.jpg correspond à image1.txt). Placez ces fichiers dans un dossier labels/ parallèlement à votre images/ (par exemple, ../datasets/mydataset/labels/train/).
• Chaque ligne d'un .txt 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 0le second est 1etc.)

De nombreux outils d'annotation manuelle proposent une exportation directe au format YOLO . Si vous utilisez des modèles automatisés, vous aurez besoin de scripts ou de processus pour convertir leurs résultats (par exemple, les coordonnées de la boîte englobante, les masques de segmentation) dans ce format de texte normalisé spécifique. Veillez à ce que la structure de votre jeu de données final soit conforme à l'exemple fourni dans le guide. Pour plus de détails, consultez notre Guide de collecte et d'annotation des données.

Quelles sont les options de licence pour l'utilisation de YOLOv5 dans des applications commerciales ?

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

• LicenceAGPL-3.0 : Cette licence de source ouverte convient à la recherche universitaire, aux projets personnels et aux situations où la conformité à la licence de source ouverte est acceptable. Elle impose que les modifications et les travaux dérivés soient également mis à disposition sous la licence AGPL-3.0. Consulter les détails de la licenceAGPL-3.0
• Licence d'entreprise: Une licence commerciale conçue pour les entreprises qui intègrent YOLOv5 dans des produits ou services propriétaires. Cette licence supprime les obligations d'open-source de l'AGPL-3.0, ce qui permet une distribution en circuit fermé. Visitez notre page sur les licences pour plus de détails ou pour demander une licence d'entreprise.

Sélectionnez la licence qui correspond le mieux aux exigences de votre projet et à votre modèle de distribution.

📅C réé il y a 1 an ✏️ Mis à jour il y a 1 mois

Commentaires