Conseils pour obtenir les meilleurs résultats avec YOLOv5#

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

La plupart du temps, tu peux 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 bien annoté. Si les résultats initiaux ne sont pas satisfaisants, tu peux prendre certaines mesures pour les améliorer, mais nous te recommandons toujours de commencer par entraîner le modèle avec tous les paramètres par défaut avant d'envisager des changements. Cela permet d'établir une référence de performance et de repérer les points à améliorer.

Si tu as des questions sur tes résultats d'entraînement, nous te recommandons de fournir le plus d'informations possible pour obtenir une réponse utile, notamment les graphiques de résultats (pertes d'entraînement et de validation, P, R, mAP), la courbe PR, la matrice de confusion, les mosaïques d'entraînement, les résultats des tests 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 préparé ci-dessous un guide complet pour t'aider à obtenir les meilleurs résultats lors de l'entraînement de YOLOv5.

Jeu de données#

• Images par classe. Nous recommandons au moins 1 500 images par classe.
• Instances par classe. Nous recommandons au moins 10 000 instances (objets annotés) par classe.
• Variété des images. Les images doivent représenter l'environnement de déploiement. Pour les cas d'utilisation réels, nous recommandons des images prises à différents moments de la journée, au fil des saisons, dans différentes conditions météorologiques et lumineuses, sous différents angles et provenant de diverses sources (collectées en ligne, recueillies localement, prises avec différents appareils photo), etc.
• Cohérence des annotations. Toutes les instances de toutes les classes présentes dans toutes les images doivent être annotées. Une annotation partielle ne fonctionnera pas.
• Précision des annotations. Les annotations doivent délimiter précisément chaque objet. Il ne doit pas y avoir d'espace entre un objet et sa boîte englobante. Aucun objet ne doit être dépourvu d'étiquette.
• Respect de la séparation entraînement/validation. Veille à ce que les images de validation et de test ne figurent jamais dans le jeu d'entraînement, afin d'éviter des métriques trop optimistes. Maintiens des répartitions de classes similaires entre les sous-ensembles.
• Vérification des annotations. Affiche train_batch*.jpg au démarrage de l'entraînement pour vérifier que tes annotations sont correctes, par exemple en examinant 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 d'inclure environ 0 à 10 % d'images d'arrière-plan pour réduire les FP (COCO en compte 1 000 à titre de référence, soit 1 % du total). Les images d'arrière-plan ne nécessitent aucune annotation.

Choix du modèle#

Les modèles plus grands, comme YOLOv5x et YOLOv5x6, offrent de meilleurs résultats dans presque tous les cas, mais comptent 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 dans le cloud, nous recommandons YOLOv5l/x. Consulte le tableau de notre README pour comparer tous les modèles.

• Commencer avec des poids préentraînés. Cette option est recommandée pour les jeux de données de petite à moyenne taille (par exemple, VOC, VisDrone, GlobalWheat). Indique le nom du modèle avec 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 de zéro. Cette option est recommandée pour les grands jeux de données (par exemple, COCO, Objects365, OIv6). Indique le fichier YAML de l'architecture 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 pour établir une référence de performance. Tu trouveras la liste complète des paramètres de train.py dans l'analyseur d'arguments de train.py.

• Époques. Commence par 300 époques. Si le modèle surapprend trop tôt, tu peux réduire leur nombre. Si le surapprentissage ne se produit pas après 300 époques, prolonge l'entraînement à 600, 1 200 époques, etc.
• Taille des images. COCO est entraîné à sa résolution native --img 640, mais, en raison du grand nombre de petits objets dans le jeu de données, il peut être avantageux de l'entraîner à des résolutions supérieures, comme --img 1280. Si ton jeu de données personnalisé contient de nombreux petits objets, l'entraînement à la résolution native ou à une résolution supérieure peut être bénéfique. Les meilleurs résultats d'inférence sont obtenus à la même --img que celle utilisée pour l'entraînement ; autrement dit, si tu entraînes le modèle à --img 1280, tu dois aussi le tester et effectuer la détection à --img 1280.
• Taille du lot. Utilise la plus grande valeur --batch-size que ton matériel peut prendre en charge. Les petites tailles de lot produisent des statistiques de normalisation par lot médiocres et sont à éviter. Tu peux utiliser --batch-size -1 pour sélectionner automatiquement la taille de lot optimale pour ton GPU.
• Taux d'apprentissage. Le calendrier de taux d'apprentissage par défaut donne de bons résultats dans la plupart des cas. Pour accélérer la convergence, tu peux essayer l'indicateur --cos-lr afin d'activer un calendrier de 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 différentes techniques d'augmentation, comme la mosaïque, qui combine plusieurs images d'entraînement. Ajuste l'intensité de l'augmentation à l'aide de l'hyperparamètre mosaic dans ton fichier --hyp pour stabiliser l'entraînement.
• Hyperparamètres. Les hyperparamètres par défaut se trouvent dans hyp.scratch-low.yaml. Nous te recommandons de commencer par 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 de prolonger l'entraînement et d'obtenir un mAP final plus élevé. Réduire les hyperparamètres de pondération des composantes de perte, comme hyp['obj'], aide à réduire le surapprentissage pour ces composantes spécifiques. Pour optimiser ces hyperparamètres automatiquement, 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 compromettre la précision du modèle.
• Entraînement multi-GPU. Si tu disposes de plusieurs GPU, utilise --device 0,1,2,3 pour répartir l'entraînement entre eux et réduire considérablement sa durée.
• Arrêt anticipé. Utilise --patience 50 pour interrompre l'entraînement si les métriques de validation ne s'améliorent pas pendant 50 époques, afin de gagner du temps et d'éviter le surapprentissage.

Techniques 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, si tu le souhaites, fige des couches à l'aide de --freeze pour adapter le modèle à ta tâche spécifique.
• Élagage du modèle. Après l'entraînement, pense à é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 différentes configurations et combine leurs prédictions pour améliorer la précision.
• Augmentation au moment du test. Active l'augmentation au moment du test (TTA) pendant l'inférence à l'aide de --augment pour améliorer la précision des prédictions en calculant la moyenne des résultats obtenus à partir de versions augmentées de l'image d'entrée.

Pour aller plus loin#

Pour en savoir plus, tu peux commencer par la « Recette pour entraîner des réseaux de neurones » de Karpathy, qui propose d'excellentes idées d'entraînement applicables à de nombreux domaines du ML : https://karpathy.github.io/2019/04/25/recipe/

Bonne chance 🍀 et n'hésite pas à nous faire part de tes autres questions !

FAQ#