Link to this sectionConseils pour obtenir les meilleurs résultats d'entraînement avec YOLOv5#

📚 Ce guide explique comment obtenir les meilleurs mAP et résultats d'entraînement avec YOLOv5 🚀.

La plupart du temps, de bons résultats peuvent être obtenus sans modifier les modèles ou les paramètres d'entraînement, à condition que ton jeu de données soit suffisamment vaste et bien étiqueté. Si tu n'obtiens pas de bons résultats au début, il existe des étapes que tu peux suivre pour t'améliorer, mais nous recommandons toujours aux utilisateurs de commencer par s'entraîner avec tous les paramètres par défaut avant d'envisager des changements. Cela aide à établir une base de référence pour les performances et à identifier les domaines à améliorer.

Si tu as des questions concernant tes résultats d'entraînement, nous te recommandons de fournir le maximum d'informations possible si tu attends une réponse utile, notamment les graphiques de résultats (pertes d'entraînement, pertes de validation, P, R, mAP), la courbe PR, la matrice de confusion, les mosaïques d'entraînement, les résultats de test et les images de statistiques du jeu de données comme labels.png. Tous ces éléments se trouvent dans ton répertoire project/name, généralement yolov5/runs/train/exp.

Nous avons rassemblé un guide complet ci-dessous pour les utilisateurs cherchant à obtenir les meilleurs résultats lors de leurs entraînements YOLOv5.

Link to this sectionJeu de données#

• Images par classe. ≥ 1500 images par classe recommandées
• Instances par classe. ≥ 10000 instances (objets étiquetés) par classe recommandées
• Variété des images. Elle doit être représentative de l'environnement de déploiement. Pour les cas d'utilisation réels, nous recommandons des images provenant de différents moments de la journée, différentes saisons, différentes conditions météorologiques, différents éclairages, différents angles, différentes sources (extraites en ligne, collectées localement, différents appareils photo), etc.
• Cohérence des étiquettes. Toutes les instances de toutes les classes dans toutes les images doivent être étiquetées. Un étiquetage partiel ne fonctionnera pas.
• Précision des étiquettes. Les étiquettes doivent entourer étroitement chaque objet. Aucun espace ne doit exister entre un objet et sa bounding box. Aucun objet ne doit manquer d'étiquette.
• Discipline de répartition train/val. Assure-toi que les images de validation et de test n'apparaissent jamais dans le jeu d'entraînement pour éviter des métriques trop optimistes. Maintiens des distributions de classes similaires entre les répartitions.
• Vérification des étiquettes. Affiche train_batch*.jpg au début de l'entraînement pour vérifier que tes étiquettes semblent correctes, par exemple en consultant la mosaïque exemple.
• Images d'arrière-plan. Les images d'arrière-plan sont des images sans objet ajoutées à un jeu de données pour réduire les faux positifs (FP). Nous recommandons environ 0 à 10 % d'images d'arrière-plan pour aider à réduire les FP (COCO contient 1000 images d'arrière-plan pour référence, soit 1 % du total). Aucune étiquette n'est requise pour les images d'arrière-plan.

Link to this sectionSélection du modèle#

Les modèles plus grands comme YOLOv5x et YOLOv5x6 produiront de meilleurs résultats dans presque tous les cas, mais possèdent plus de paramètres, nécessitent plus de mémoire CUDA pour l'entraînement et sont plus lents à exécuter. Pour les déploiements mobiles, nous recommandons YOLOv5s/m ; pour les déploiements cloud, nous recommandons YOLOv5l/x. Consulte notre tableau README pour une comparaison complète de tous les modèles.

• Commencer avec des poids pré-entraînés. Recommandé pour les jeux de données de petite à moyenne taille (par ex. VOC, VisDrone, GlobalWheat). Passe le nom du modèle à l'argument --weights. Les modèles se téléchargent automatiquement depuis la dernière version de YOLOv5.

  python train.py --data custom.yaml --weights yolov5s.pt
  python train.py --data custom.yaml --weights yolov5m.pt
  python train.py --data custom.yaml --weights yolov5l.pt
  python train.py --data custom.yaml --weights yolov5x.pt
  python train.py --data custom.yaml --weights custom_pretrained.pt

• Commencer à zéro. Recommandé pour les grands jeux de données (par ex. COCO, Objects365, OIv6). Passe l'architecture YAML du modèle qui t'intéresse, avec un argument --weights '' vide :

  python train.py --data custom.yaml --weights '' --cfg yolov5s.yaml
  python train.py --data custom.yaml --weights '' --cfg yolov5m.yaml
  python train.py --data custom.yaml --weights '' --cfg yolov5l.yaml
  python train.py --data custom.yaml --weights '' --cfg yolov5x.yaml

Link to this sectionParamètres d'entraînement#

Avant de modifier quoi que ce soit, commence d'abord par t'entraîner avec les paramètres par défaut pour établir une base de référence. Une liste complète des paramètres de train.py se trouve dans l'argparser de train.py.

• Époques. Commence avec 300 époques. Si cela provoque un surapprentissage précoce, tu peux réduire le nombre d'époques. Si le surapprentissage ne se produit pas après 300 époques, entraîne-toi plus longtemps, par exemple 600, 1200 époques, etc.
• Taille de l'image. COCO s'entraîne à une résolution native de --img 640, bien qu'en raison de la grande quantité de petits objets dans le jeu de données, il puisse bénéficier d'un entraînement à des résolutions plus élevées comme --img 1280. S'il y a beaucoup de petits objets, les jeux de données personnalisés bénéficieront d'un entraînement à une résolution native ou supérieure. Les meilleurs résultats d'inférence sont obtenus avec le même --img que celui utilisé lors de l'entraînement ; par exemple, si tu t'entraînes à --img 1280, tu devrais également tester et détecter à --img 1280.
• Taille de lot. Utilise la plus grande --batch-size que ton matériel permet. Les petites tailles de lot produisent de mauvaises statistiques de normalisation de lot et doivent être évitées. Tu peux utiliser --batch-size -1 pour sélectionner automatiquement la taille de lot optimale pour ton GPU.
• Taux d'apprentissage. Le programme de taux d'apprentissage par défaut fonctionne bien dans la plupart des cas. Pour une convergence plus rapide, tu peux essayer d'utiliser le drapeau --cos-lr pour activer la planification du taux d'apprentissage cosinus, qui réduit progressivement le taux d'apprentissage en suivant une courbe cosinus sur les époques.
• Augmentation de données. YOLOv5 inclut diverses techniques d'augmentation comme la mosaïque, qui combine plusieurs images d'entraînement. Ajuste la force de l'augmentation via l'hyperparamètre mosaic dans ton fichier --hyp pour aider à stabiliser l'entraînement.
• Hyperparamètres. Les hyperparamètres par défaut se trouvent dans hyp.scratch-low.yaml. Nous te recommandons de t'entraîner avec les hyperparamètres par défaut avant de penser à en modifier. En général, augmenter les hyperparamètres d'augmentation réduira et retardera le surapprentissage, permettant des entraînements plus longs et un mAP final plus élevé. La réduction des hyperparamètres de gain de composante de perte comme hyp['obj'] aidera à réduire le surapprentissage dans ces composantes de perte spécifiques. Pour une méthode automatisée d'optimisation de ces hyperparamètres, consulte notre Tutoriel d'évolution des hyperparamètres.
• Entraînement en précision mixte. YOLOv5 active automatiquement la précision mixte automatique (AMP) lorsqu'un GPU pris en charge est détecté, accélérant l'entraînement et réduisant l'utilisation de la mémoire sans sacrifier la précision du modèle.
• Entraînement multi-GPU. Si tu as plusieurs GPU, utilise --device 0,1,2,3 pour distribuer l'entraînement entre eux, ce qui peut réduire considérablement le temps d'entraînement.
• Arrêt précoce. Utilise --patience 50 pour arrêter l'entraînement si les métriques de validation ne s'améliorent pas pendant 50 époques, économisant ainsi du temps et évitant le surapprentissage.

Link to this sectionTechniques d'optimisation avancées#

• Apprentissage par transfert. Pour les jeux de données spécialisés, commence avec des poids pré-entraînés et débloque progressivement les couches pendant l'entraînement pour adapter le modèle à ta tâche spécifique.
• Élagage de modèle. Après l'entraînement, envisage d'élaguer ton modèle pour supprimer les poids redondants et réduire la taille du modèle sans perte de performance significative.
• Ensemble de modèles. Pour les applications critiques, entraîne plusieurs modèles avec des configurations différentes et combine leurs prédictions pour une meilleure précision.
• Augmentation lors du test. Active la TTA pendant l'inférence avec --augment pour améliorer la précision des prédictions en faisant la moyenne des résultats à partir des versions augmentées de l'image d'entrée.

Link to this sectionPour aller plus loin#

Si tu souhaites en savoir plus, un bon point de départ est la 'Recette pour l'entraînement des réseaux de neurones' de Karpathy, qui contient d'excellentes idées pour l'entraînement qui s'appliquent largement à tous les domaines du ML : https://karpathy.github.io/2019/04/25/recipe/

Pour des informations plus détaillées sur les paramètres et configurations d'entraînement, reporte-toi à la documentation des paramètres d'entraînement Ultralytics, qui fournit des explications complètes sur tous les paramètres disponibles.

Bonne chance 🍀 et fais-nous savoir si tu as d'autres questions !

Link to this sectionFAQ#

Link to this sectionComment savoir si mon modèle est en surapprentissage ?#

Ton modèle peut être en surapprentissage si la perte d'entraînement continue de diminuer alors que la perte de validation commence à augmenter. Surveille le mAP de validation - s'il plafonne ou diminue alors que la perte d'entraînement continue de s'améliorer, c'est un signe de surapprentissage. Les solutions incluent l'ajout de plus de données d'entraînement, l'augmentation de l'augmentation des données ou la mise en œuvre de techniques de régularisation.

Link to this sectionQuelle est la taille de lot optimale pour l'entraînement YOLOv5 ?#

La taille de lot optimale dépend de la mémoire de ton GPU. Des tailles de lot plus grandes offrent généralement de meilleures statistiques de normalisation de lot et une meilleure stabilité d'entraînement. Utilise la plus grande taille de lot que ton matériel peut gérer sans manquer de mémoire. Tu peux utiliser --batch-size -1 pour déterminer automatiquement la taille de lot optimale pour ta configuration.

Link to this sectionComment puis-je accélérer l'entraînement de YOLOv5 ?#

Pour accélérer l'entraînement, essaie : d'utiliser plusieurs GPU avec --device 0,1,2,3, de mettre en cache ton jeu de données avec --cache, et d'optimiser ta taille de lot (la précision mixte est activée automatiquement sur les GPU pris en charge). Envisage également d'utiliser une variante de modèle plus petite comme YOLOv5s si la précision absolue n'est pas critique.