Link to this sectionEntraîne YOLOv5 sur des données personnalisées#

📚 Ce guide t'explique comment entraîner ton propre jeu 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 réelles spécifiques, au-delà de la simple détection d'objets.

Link to this sectionAvant de commencer#

D'abord, assure-toi d'avoir configuré l'environnement nécessaire. 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 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

Link to this sectionEntraînement sur des données personnalisées#

Développer un modèle de détection d'objets personnalisé 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 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 avec 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 inédites.
5. Collecter les cas limites : Identifie les scénarios où le modèle obtient de mauvais résultats (cas limites) et ajoute des données similaires à ton jeu de données pour améliorer la robustesse. Répète le cycle.

La plateforme Ultralytics propose une solution simplifiée et sans code pour tout ce cycle MLOps, incluant la gestion des jeux de données, l'entraînement du modèle et le déploiement.

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

Link to this sectionCré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é.

Link to this section1.1 Créer dataset.yaml#

Le fichier de configuration du jeu de données (par ex., coco128.yaml) décrit la structure du jeu de données, les noms des classes et les chemins vers les répertoires d'images. COCO128 sert de petit exemple de jeu de données, comprenant les 128 premières images du vaste jeu de données COCO. Il est utile pour tester rapidement le pipeline d'entraînement et diagnostiquer des problèmes potentiels 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 listant 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) à leurs noms de classe correspondants.

Tu peux définir path soit sur un répertoire absolu (par ex., /home/user/datasets/coco128), soit 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

Link to this section1.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 comme Gemini possèdent de puissantes capacités de compréhension d'images. Ils peuvent être invités à 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 grande précision. Bien que 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 peuvent 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 leur précision et leur 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 potentiellement 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 *.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 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 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'étiquette correspondant à l'image ci-dessus, contenant deux objets 'personne' (indice de classe 0) et un objet 'cravate' (indice de classe 27), ressemblerait à ceci :

Link to this section1.3 Organiser les répertoires#

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

YOLOv5 localise automatiquement les étiquettes pour chaque image en remplaçant la dernière instance 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)
            └── ...

Link to this sectionSélectionner un modèle#

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

Link to this sectionEntraî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 ex., --img 640). Des tailles plus grandes offrent généralement une meilleure précision mais nécessitent plus de mémoire GPU.
• --batch : détermine la taille de lot (par exemple, --batch 16). Choisis la taille la plus grande 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 jeu de données d'entraînement.
• --data : Chemin vers ton fichier dataset.yaml (par ex., --data coco128.yaml).
• --weights : Chemin vers le fichier de poids initiaux. L'utilisation de poids pré-entraînés (par ex., --weights yolov5s.pt) est fortement recommandée pour une convergence plus rapide et de meilleurs résultats. Pour entraîner à partir de zéro (non conseillé sauf si tu as un très grand jeu de données 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, incluant les poids et les logs, sont enregistrés dans le répertoire runs/train/. Chaque session d'entraînement crée un nouveau sous-répertoire (par ex., runs/train/exp, runs/train/exp2, etc.). Pour une expérience interactive et pratique, explore la section d'entraînement dans nos notebooks officiels de tutoriels :

Link to this sectionVisualiser#

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.

Link to this sectionJournalisation 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 jeux de données et les points de contrôle des modèles, et analyse les prédictions des modèles en utilisant les 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 en profondeur 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 :

Link to this sectionJournalisation et automatisation 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 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 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 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 de tes jeux de données en utilisant ClearML Data. Explore le Guide d'intégration ClearML pour des détails complets.

Link to this sectionJournalisation locale#

Les résultats d'entraînement sont automatiquement enregistrés en utilisant TensorBoard et sauvegardés sous forme de fichiers CSV dans le répertoire d'expérience spécifique (par ex., 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).
• 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 tracé sous forme de 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

Link to this sectionProchaines é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 :

• Lancer l'inférence sur de nouvelles images ou vidéos en utilisant 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érents ensembles de données (par ex., un ensemble de test retenu).
• 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 de réglage des hyperparamètres 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.

Link to this sectionEnvironnements pris en charge#

Ultralytics propose 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

Link to this sectionStatut du projet#

Ce badge indique que tous les tests d'intégration continue (CI) des GitHub Actions Continuous Integration (CI) de YOLOv5 réussissent. Ces tests CI rigoureux couvrent les fonctionnalités principales, y compris 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.

Link to this sectionFAQ#

Link to this sectionComment 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épare ton jeu de données : Collecte des images et annote-les. Assure-toi que les annotations sont au 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 dans le processus de labellisation ou pour l'automatiser (voir section 1.2).
2. Configure ton environnement : Clone le dépôt YOLOv5 et installe 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ée la configuration du jeu de données : Définit les chemins du 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 lot et le nombre d'époques.

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

Link to this sectionPourquoi 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 développement des modèles YOLO, souvent sans avoir besoin d'écrire de code. Les avantages clés incluent :

• Entraînement simplifié : Entraîne facilement des modèles en utilisant des environnements préconfigurés et une interface utilisateur intuitive.
• Gestion intégrée des données : Télécharge, versionne et gère 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 d'équipe grâce aux ressources partagées, aux outils de gestion de projet et au partage facile de modèles.
• Déploiement sans code : Déploie des 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.

Link to this sectionComment 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 à celui 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 l'annotation d'un 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 comprises 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 deuxième est 1, etc.).

De nombreux outils d'annotation manuelle proposent un export direct 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 BBox, masques de segmentation) vers 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, consulte notre Guide de collecte et d'annotation de données.

Link to this sectionQuelles sont les options de licence pour utiliser YOLOv5 dans des applications commerciales ?#

Ultralytics propose des licences flexibles adaptées à 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 AGPL-3.0. Consulte 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 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 entreprise.

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