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

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

La plupart du temps, de bons résultats peuvent être obtenus sans aucune modification des modèles ou des 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 du premier coup, il existe des étapes que tu pourrais 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 tout changement. Cela aide à établir une base de performance et à repérer les domaines à 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 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 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 rassemblé ci-dessous un guide complet pour les utilisateurs cherchant à obtenir les meilleurs résultats lors de leurs entraînements YOLOv5.

Dataset

• 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'usage 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, et différentes sources (images récupérées en ligne, collectées localement, différentes caméras), 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. Il ne doit y avoir aucun espace entre un objet et sa bounding box. Aucun objet ne doit manquer d'étiquette.
• Discipline de répartition entraînement/validation. 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. Garde des distributions de classes similaires entre les différents ensembles.
• Vérification des étiquettes. Visualise train_batch*.jpg au démarrage de l'entraînement pour vérifier que tes étiquettes semblent correctes, c'est-à-dire en consultant l'exemple de mosaïque.
• Images de fond. Les images de fond sont des images sans objets ajoutées à un jeu de données pour réduire les faux positifs (FP). Nous recommandons environ 0 à 10 % d'images de fond pour aider à réduire les FP (COCO contient 1000 images de fond pour référence, soit 1 % du total). Aucune étiquette n'est requise pour les images de fond.

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 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 à partir de 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. Recommandé pour les grands jeux de données (par ex. COCO, Objects365, OIv6). Passe l'architecture YAML du modèle qui t'intéresse, accompagnée d'un argument vide --weights '' :

  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 d'abord par t'entraîner avec les paramètres par défaut pour établir une base de performance. Une liste complète des paramètres de train.py se trouve dans l'argparser de train.py.

• Époques. Commence avec 300 époques. Si un surapprentissage se produit tôt, tu peux réduire le nombre d'époques. Si le surapprentissage ne survient pas après 300 époques, entraîne 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 du grand nombre 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, c'est-à-dire que si tu t'entraînes avec --img 1280, tu devrais également tester et détecter avec --img 1280.
• Batch size. Utilise la plus grande --batch-size que ton matériel permet. Les petites tailles de lot produisent de mauvaises statistiques de batch normalization et doivent être évitées. Tu peux utiliser --batch-size -1 pour sélectionner automatiquement la taille de lot optimale pour ton GPU.
• Learning rate. 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 flag --cos-lr pour activer le programme de taux d'apprentissage en cosinus, qui réduit progressivement le taux d'apprentissage en suivant une courbe cosinus au fil des époques.
• Augmentation de données. YOLOv5 inclut diverses techniques d'augmentation comme la mosaïque, qui combine plusieurs images d'entraînement. Pour les dernières époques, envisage d'utiliser --close-mosaic 10 pour désactiver l'augmentation par mosaïque, ce qui peut 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 d'abord avec les hyperparamètres par défaut avant de penser à en modifier un. 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 des composantes 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 sur l'évolution des hyperparamètres.
• Entraînement en précision mixte. Active l'entraînement en précision mixte avec --amp pour accélérer l'entraînement et réduire 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 (Early stopping). 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 d'optimisation avancées

• Transfer learning. Pour des jeux de données spécialisés, commence par des poids pré-entraînés et dégèle progressivement les couches pendant l'entraînement pour 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 la taille du modèle sans perte de performance significative.
• 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.
• Test-time augmentation. 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 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 « Recette pour entraîner des réseaux neuronaux » 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 sur les paramètres d'entraînement d'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 !

FAQ

Comment savoir si mon modèle est en surapprentissage ?

Ton modèle est peut-être en surapprentissage si la perte d'entraînement continue de diminuer tandis 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 des données, ou la mise en œuvre de techniques de régularisation.

Quelle est la taille de lot optimale pour entraîner YOLOv5 ?

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

Comment puis-je accélérer l'entraînement de YOLOv5 ?

Pour accélérer l'entraînement, essaie : d'activer l'entraînement en précision mixte avec --amp, 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. Envisage également d'utiliser une variante de modèle plus petite comme YOLOv5s si la précision absolue n'est pas critique.