Conseils pour obtenir les meilleurs résultats d'entraînement avec YOLOv5#

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

La plupart du temps, il est possible d'obtenir de bons résultats sans modifier les modèles ni les paramètres d'entraînement, à condition que ton jeu de données soit suffisamment volumineux et correctement annoté. Si tu n'obtiens pas de bons résultats au premier essai, tu peux prendre certaines mesures pour les améliorer, mais nous recommandons toujours aux utilisateurs de commencer par entraîner le modèle avec tous les paramètres par défaut avant d'envisager la moindre modification. Cela permet d'établir une référence de performance et d'identifier les points à améliorer.

Si tu as des questions sur tes résultats d'entraînement, nous te recommandons de fournir le maximum d'informations possible si tu espères obtenir 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, telles que labels.png. Tous ces éléments se trouvent dans ton répertoire project/name, généralement yolov5/runs/train/exp.

Nous avons préparé ci-dessous un guide complet pour les utilisateurs qui souhaitent obtenir les meilleurs résultats lors de leurs entraînements avec YOLOv5.

Jeu de données#

• Images par classe. Au moins 1500 images par classe sont recommandées
• Instances par classe. Au moins 10000 instances (objets annotés) par classe sont 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 prises à différents moments de la journée, pendant différentes saisons, par différentes conditions météorologiques et avec différents éclairages et angles, ainsi que provenant de différentes sources (récupérées en ligne, collectées localement ou prises avec différents appareils photo), etc.
• Cohérence des annotations. Toutes les instances de toutes les classes dans toutes les images doivent être annotées. Une annotation partielle ne fonctionnera pas.
• Précision des annotations. Les annotations doivent entourer étroitement chaque objet. Aucun espace ne doit exister entre un objet et sa boîte englobante. Aucun objet ne doit être dépourvu d'annotation.
• Rigueur dans la séparation entraînement/validation. Assure-toi que les images de validation et de test n'apparaissent jamais dans le jeu d'entraînement afin d'éviter des métriques trop optimistes. Maintiens des distributions de classes similaires entre les différents sous-ensembles.
• Vérification des annotations. Affiche train_batch*.jpg au début de l'entraînement pour vérifier que tes annotations sont correctes, c'est-à-dire en consultant la mosaïque d'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 contribuer à réduire les FP (COCO en compte 1000 à titre de référence, soit 1 % du total). Aucune annotation n'est requise pour les images d'arrière-plan.

Sélection du modèle#

Les modèles plus grands comme YOLOv5x et YOLOv5x6 produiront de meilleurs résultats dans presque tous les cas, mais ils comportent davantage 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 du 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 exemple VOC, VisDrone, GlobalWheat). Transmets le nom du modèle à l'argument --weights. Les modèles sont téléchargés 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 depuis zéro. Recommandé pour les grands jeux de données (par exemple COCO, Objects365, OIv6). Transmets l'architecture YAML du modèle qui t'intéresse, ainsi qu'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

Paramètres d'entraînement#

Avant de modifier quoi que ce soit, commence par entraîner le modèle avec les paramètres par défaut afin d'établir une référence de performance. Tu trouveras la liste complète des paramètres de train.py dans l'argparser de train.py.

• Époques. Commence avec 300 époques. Si le modèle commence rapidement à surapprendre, tu peux réduire le nombre d'époques. Si le surapprentissage ne se produit pas après 300 époques, entraîne le modèle plus longtemps, par exemple pendant 600, 1200 époques, etc.
• Taille des images. COCO est entraîné à la résolution native de --img 640, mais, en raison du grand nombre de petits objets présents dans le jeu de données, il peut bénéficier d'un entraînement à des résolutions plus élevées, comme --img 1280. Si les petits objets sont nombreux, les jeux de données personnalisés bénéficieront d'un entraînement à la résolution native ou à une résolution supérieure. Les meilleurs résultats d'inférence sont obtenus avec la même --img que celle utilisée pour l'entraînement, c'est-à-dire que si tu entraînes le modèle avec --img 1280, tu dois également effectuer les tests et la détection avec --img 1280.
• Taille des lots. Utilise la plus grande valeur de --batch-size que ton matériel peut gérer. Les petites tailles de lot produisent de mauvaises statistiques de normalisation par lots 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 calendrier du taux d'apprentissage par défaut fonctionne bien dans la plupart des cas. Pour accélérer la convergence, tu peux essayer d'utiliser l'option --cos-lr afin d'activer un calendrier du taux d'apprentissage cosinus, qui réduit progressivement le taux d'apprentissage en suivant une courbe cosinus au fil des époques.
• Augmentation des données. YOLOv5 inclut diverses techniques d'augmentation, comme la mosaïque, qui combine plusieurs images d'entraînement. Ajuste l'intensité de l'augmentation via l'hyperparamètre mosaic dans ton fichier --hyp afin de contribuer à stabiliser l'entraînement.
• Hyperparamètres. Les hyperparamètres par défaut se trouvent dans hyp.scratch-low.yaml. Nous te recommandons d'abord d'entraîner le modèle avec les hyperparamètres par défaut avant d'envisager de les modifier. En général, augmenter les hyperparamètres d'augmentation réduit et retarde le surapprentissage, ce qui permet des entraînements plus longs et une mAP finale plus élevée. Réduire les hyperparamètres de gain des composantes de perte, comme hyp['obj'], contribuera à réduire le surapprentissage pour ces composantes de perte spécifiques. Pour une méthode automatisée d'optimisation de ces hyperparamètres, consulte notre tutoriel sur l'évolution des hyperparamètres.
• Entraînement en précision mixte. YOLOv5 active automatiquement la précision mixte automatique (AMP) lorsqu'un GPU compatible est détecté, ce qui accélère l'entraînement et réduit l'utilisation de la mémoire sans sacrifier la précision du modèle.
• Entraînement avec plusieurs GPU. Si tu disposes de plusieurs GPU, utilise --device 0,1,2,3 pour répartir l'entraînement entre eux, ce qui peut réduire considérablement sa durée.
• Arrêt anticipé. Utilise --patience 50 pour arrêter l'entraînement si les métriques de validation ne s'améliorent pas pendant 50 époques, ce qui permet de gagner du temps et d'éviter le surapprentissage.

Techniques avancées d'optimisation#

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

Pour aller plus loin#

Si tu souhaites en savoir plus, un bon point de départ est la « Recipe for Training Neural Networks » de Karpathy, qui propose d'excellentes idées d'entraînement applicables à tous les domaines du ML : https://karpathy.github.io/2019/04/25/recipe/

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

Bonne chance 🍀 et n'hésite pas à nous faire savoir si tu as d'autres questions !

FAQ#