Meilleures pratiques et conseils en apprentissage automatique pour l'entraînement de modèles

Introduction

L'une des étapes les plus importantes lors du travail sur un projet de vision par ordinateur est l'entraînement du modèle. Avant d'atteindre cette étape, tu dois définir tes objectifs ainsi que collecter et annoter tes données. Après avoir prétraité les données pour t'assurer qu'elles sont propres et cohérentes, tu peux passer à l'entraînement de ton modèle.

Alors, qu'est-ce que l'entraînement de modèle ? L'entraînement de modèle est le processus consistant à apprendre à ton modèle à reconnaître des motifs visuels et à effectuer des prédictions basées sur tes données. Cela impacte directement les performances et la précision de ton application. Dans ce guide, nous aborderons les meilleures pratiques, les techniques d'optimisation et des conseils de dépannage pour t'aider à entraîner tes modèles de vision par ordinateur efficacement.

Comment entraîner un modèle d'apprentissage automatique

Un modèle de vision par ordinateur est entraîné en ajustant ses paramètres internes afin de minimiser les erreurs. Initialement, le modèle reçoit un grand ensemble d'images étiquetées. Il effectue des prédictions sur ce que contiennent ces images, et celles-ci sont comparées aux étiquettes ou aux contenus réels pour calculer les erreurs. Ces erreurs indiquent à quel point les prédictions du modèle s'écartent des vraies valeurs.

Pendant l'entraînement, le modèle effectue de manière itérative des prédictions, calcule les erreurs et met à jour ses paramètres via un processus appelé rétropropagation. Dans ce processus, le modèle ajuste ses paramètres internes (poids et biais) pour réduire les erreurs. En répétant ce cycle de nombreuses fois, le modèle améliore progressivement sa précision. Au fil du temps, il apprend à reconnaître des motifs complexes tels que des formes, des couleurs et des textures.

Ce processus d'apprentissage permet au modèle de vision par ordinateur d'effectuer diverses tâches, y compris la détection d'objets, la segmentation d'instances et la classification d'images. L'objectif ultime est de créer un modèle capable de généraliser son apprentissage à de nouvelles images inédites afin de comprendre précisément les données visuelles dans des applications réelles.

Maintenant que nous savons ce qui se passe en coulisses lors de l'entraînement d'un modèle, examinons les points à considérer lors de cette opération.

Entraînement sur de grands jeux de données

Il y a quelques aspects différents à prendre en compte lorsque tu prévois d'utiliser un grand jeu de données pour entraîner un modèle. Par exemple, tu peux ajuster la taille du lot, contrôler l'utilisation du GPU, choisir d'utiliser un entraînement multi-échelle, etc. Passons en revue chacune de ces options en détail.

Taille de lot et utilisation du GPU

Lors de l'entraînement de modèles sur de grands jeux de données, utiliser efficacement ton GPU est essentiel. La taille de lot est un facteur important. Il s'agit du nombre d'échantillons de données qu'un modèle d'apprentissage automatique traite en une seule itération d'entraînement. En utilisant la taille de lot maximale supportée par ton GPU, tu peux profiter pleinement de ses capacités et réduire le temps nécessaire à l'entraînement du modèle. Cependant, tu dois éviter de manquer de mémoire GPU. Si tu rencontres des erreurs de mémoire, réduis la taille de lot progressivement jusqu'à ce que le modèle s'entraîne sans problème.

En ce qui concerne YOLO26, tu peux définir le paramètre batch_size dans la configuration d'entraînement pour correspondre à la capacité de ton GPU. De plus, définir batch=-1 dans ton script d'entraînement déterminera automatiquement la taille de lot pouvant être traitée efficacement en fonction des capacités de ton appareil. En ajustant finement la taille de lot, tu peux tirer le meilleur parti de tes ressources GPU et améliorer le processus d'entraînement global.

Entraînement sur sous-ensemble

L'entraînement sur sous-ensemble est une stratégie intelligente qui consiste à entraîner ton modèle sur un ensemble de données plus petit représentant le jeu de données complet. Cela peut économiser du temps et des ressources, surtout lors du développement et des tests initiaux du modèle. Si tu manques de temps ou si tu expérimentes différentes configurations de modèle, l'entraînement sur sous-ensemble est une bonne option.

Pour YOLO26, tu peux facilement implémenter l'entraînement sur sous-ensemble en utilisant le paramètre fraction. Ce paramètre te permet de spécifier quelle fraction de ton jeu de données utiliser pour l'entraînement. Par exemple, définir fraction=0.1 entraînera ton modèle sur 10 % des données. Tu peux utiliser cette technique pour des itérations rapides et le réglage de ton modèle avant de t'engager à entraîner un modèle sur un jeu de données complet. L'entraînement sur sous-ensemble t'aide à progresser rapidement et à identifier les problèmes potentiels dès le début.

Entraînement multi-échelle

L'entraînement multi-échelle est une technique qui améliore la capacité de généralisation de ton modèle en l'entraînant sur des images de tailles variables. Ton modèle peut apprendre à détecter des objets à différentes échelles et distances et devenir plus robuste.

Par exemple, lorsque tu entraînes YOLO26, tu peux activer l'entraînement multi-échelle en définissant le paramètre scale. Ce paramètre ajuste la taille des images d'entraînement selon un facteur spécifié, simulant des objets à différentes distances. Par exemple, définir scale=0.5 zoome aléatoirement les images d'entraînement par un facteur compris entre 0,5 et 1,5 pendant l'entraînement. Configurer ce paramètre permet à ton modèle de découvrir une variété d'échelles d'images et d'améliorer ses capacités de détection sur différentes tailles d'objets et scénarios.

Ultralytics supporte également l'entraînement multi-échelle par taille d'image via le paramètre multi_scale. Contrairement à scale, qui zoome les images puis applique un padding/recadrage pour revenir à imgsz, multi_scale modifie imgsz lui-même à chaque lot (arrondi au stride du modèle). Par exemple, avec imgsz=640 et multi_scale=0.25, la taille d'entraînement est échantillonnée de 480 à 800 par paliers (par ex. 480, 512, 544, ..., 800), tandis que multi_scale=0.0 conserve une taille fixe.

Mise en cache

La mise en cache est une technique importante pour améliorer l'efficacité de l'entraînement des modèles d'apprentissage automatique. En stockant les images prétraitées en mémoire, la mise en cache réduit le temps que le GPU passe à attendre que les données soient chargées depuis le disque. Le modèle peut recevoir des données en continu sans délais causés par les opérations d'E/S disque.

La mise en cache peut être contrôlée lors de l'entraînement de YOLO26 en utilisant le paramètre cache :

• cache=True : Stocke les images du jeu de données en RAM, offrant la vitesse d'accès la plus rapide mais au prix d'une utilisation mémoire accrue.
• cache='disk' : Stocke les images sur le disque, plus lent que la RAM mais plus rapide que de charger des données fraîches à chaque fois.
• cache=False : Désactive la mise en cache, s'appuyant entièrement sur les E/S disque, ce qui est l'option la plus lente.

Entraînement en précision mixte

L'entraînement en précision mixte utilise à la fois des types à virgule flottante 16 bits (FP16) et 32 bits (FP32). Les points forts du FP16 et du FP32 sont exploités en utilisant le FP16 pour un calcul plus rapide et le FP32 pour maintenir la précision là où nécessaire. La plupart des opérations du réseau de neurones sont effectuées en FP16 pour bénéficier d'un calcul plus rapide et d'une utilisation mémoire moindre. Cependant, une copie maîtresse des poids du modèle est conservée en FP32 pour garantir la précision lors des étapes de mise à jour des poids. Tu peux gérer des modèles plus grands ou des tailles de lot plus importantes avec les mêmes contraintes matérielles.

Pour implémenter l'entraînement en précision mixte, tu devras modifier tes scripts d'entraînement et t'assurer que ton matériel (comme les GPU) le supporte. De nombreux frameworks modernes de deep learning, tels que PyTorch et TensorFlow, offrent un support intégré pour la précision mixte.

L'entraînement en précision mixte est simple lorsque tu travailles avec YOLO26. Tu peux utiliser l'indicateur amp dans ta configuration d'entraînement. Définir amp=True active l'entraînement en Précision Mixte Automatique (AMP). L'entraînement en précision mixte est un moyen simple mais efficace d'optimiser ton processus d'entraînement de modèle.

Poids pré-entraînés

Utiliser des poids pré-entraînés est un moyen intelligent d'accélérer le processus d'entraînement de ton modèle. Les poids pré-entraînés proviennent de modèles déjà entraînés sur de grands jeux de données, donnant à ton modèle une longueur d'avance. Le transfer learning adapte les modèles pré-entraînés à de nouvelles tâches connexes. Le fine-tuning d'un modèle pré-entraîné consiste à commencer avec ces poids, puis à poursuivre l'entraînement sur ton jeu de données spécifique. Cette méthode d'entraînement permet des temps d'entraînement plus courts et souvent de meilleures performances, car le modèle commence avec une solide compréhension des caractéristiques de base.

Le paramètre pretrained rend le transfer learning facile avec YOLO26. Définir pretrained=True utilisera les poids pré-entraînés par défaut, ou tu peux spécifier un chemin vers un modèle pré-entraîné personnalisé. Utiliser des poids pré-entraînés et le transfer learning stimule efficacement les capacités de ton modèle et réduit les coûts d'entraînement.

Autres techniques à considérer lors de la gestion d'un grand jeu de données

Il existe quelques autres techniques à considérer lors de la gestion d'un grand jeu de données :

• Planificateurs de taux d'apprentissage : L'implémentation de planificateurs de taux d'apprentissage ajuste dynamiquement le taux d'apprentissage pendant l'entraînement. Un taux d'apprentissage bien réglé peut empêcher le modèle de dépasser les minima et améliorer la stabilité. Lors de l'entraînement de YOLO26, le paramètre lrf aide à gérer la planification du taux d'apprentissage en définissant le taux final comme une fraction du taux initial.
• Entraînement distribué : Pour gérer de grands jeux de données, l'entraînement distribué peut changer la donne. Tu peux réduire le temps d'entraînement en répartissant la charge de travail entre plusieurs GPU ou machines. Cette approche est particulièrement précieuse pour les projets à l'échelle de l'entreprise disposant de ressources computationnelles substantielles.

Le nombre d'époques pour l'entraînement

Lors de l'entraînement d'un modèle, une époque fait référence à un passage complet sur l'ensemble du jeu de données d'entraînement. Durant une époque, le modèle traite chaque exemple de l'ensemble d'entraînement une fois et met à jour ses paramètres selon l'algorithme d'apprentissage. Plusieurs époques sont généralement nécessaires pour permettre au modèle d'apprendre et d'affiner ses paramètres au fil du temps.

Une question courante est de savoir comment déterminer le nombre d'époques pour entraîner le modèle. Un bon point de départ est 300 époques. Si le modèle est en surapprentissage (overfit) trop tôt, tu peux réduire le nombre d'époques. Si le surapprentissage ne se produit pas après 300 époques, tu peux étendre l'entraînement à 600, 1200 époques ou plus.

Cependant, le nombre idéal d'époques peut varier en fonction de la taille de ton jeu de données et des objectifs du projet. Les jeux de données plus grands peuvent nécessiter plus d'époques pour que le modèle apprenne efficacement, tandis que les jeux de données plus petits peuvent nécessiter moins d'époques pour éviter le surapprentissage. En ce qui concerne YOLO26, tu peux définir le paramètre epochs dans ton script d'entraînement.

Arrêt précoce (Early Stopping)

L'arrêt précoce est une technique précieuse pour optimiser l'entraînement de modèles. En surveillant les performances de validation, tu peux arrêter l'entraînement une fois que le modèle cesse de s'améliorer. Tu peux économiser des ressources computationnelles et éviter le surapprentissage.

Le processus implique de définir un paramètre de patience qui détermine combien d'époques attendre pour une amélioration des métriques de validation avant d'arrêter l'entraînement. Si les performances du modèle ne s'améliorent pas dans ces délais, l'entraînement est arrêté pour éviter de gaspiller du temps et des ressources.

Pour YOLO26, tu peux activer l'arrêt précoce en définissant le paramètre de patience dans ta configuration d'entraînement. Par exemple, patience=5 signifie que l'entraînement s'arrêtera s'il n'y a aucune amélioration des métriques de validation pendant 5 époques consécutives. Utiliser cette méthode garantit que le processus d'entraînement reste efficace et atteint des performances optimales sans calcul excessif.

Choisir entre entraînement dans le cloud et local

Il existe deux options pour entraîner ton modèle : l'entraînement dans le cloud et l'entraînement local.

L'entraînement dans le cloud offre évolutivité et matériel puissant, et est idéal pour gérer de grands jeux de données et des modèles complexes. Des plateformes comme Google Cloud, AWS et Azure fournissent un accès à la demande à des GPU et TPU haute performance, accélérant les temps d'entraînement et permettant des expériences avec des modèles plus grands. Cependant, l'entraînement dans le cloud peut être coûteux, surtout sur de longues périodes, et le transfert de données peut ajouter des coûts et de la latence.

L'entraînement local offre un meilleur contrôle et une plus grande personnalisation, te permettant d'adapter ton environnement à des besoins spécifiques et d'éviter les coûts continus du cloud. Cela peut être plus économique pour des projets à long terme, et puisque tes données restent sur place, c'est plus sécurisé. Cependant, le matériel local peut avoir des limitations de ressources et nécessiter une maintenance, ce qui peut entraîner des temps d'entraînement plus longs pour les modèles importants.

Sélection d'un optimiseur

Un optimiseur est un algorithme qui ajuste les poids de ton réseau de neurones pour minimiser la fonction de perte, qui mesure la performance du modèle. En termes plus simples, l'optimiseur aide le modèle à apprendre en ajustant ses paramètres pour réduire les erreurs. Choisir le bon optimiseur affecte directement la rapidité et la précision avec lesquelles le modèle apprend.

Tu peux également ajuster finement les paramètres de l'optimiseur pour améliorer les performances du modèle. Ajuster le taux d'apprentissage définit la taille des pas lors de la mise à jour des paramètres. Pour la stabilité, tu pourrais commencer avec un taux d'apprentissage modéré et le diminuer progressivement au fil du temps pour améliorer l'apprentissage à long terme. De plus, définir le momentum détermine quelle influence les mises à jour passées ont sur les mises à jour actuelles. Une valeur courante pour le momentum est d'environ 0,9. Cela fournit généralement un bon équilibre.

Optimiseurs courants

Différents optimiseurs ont diverses forces et faiblesses. Jetons un coup d'œil à quelques optimiseurs courants.

• SGD (Stochastic Gradient Descent) :

  • Met à jour les paramètres du modèle en utilisant le gradient de la fonction de perte par rapport aux paramètres.
  • Simple et efficace, mais peut être lent à converger et peut rester bloqué dans des minima locaux.

• Adam (Adaptive Moment Estimation) :

  • Combine les avantages du SGD avec momentum et de RMSProp.
  • Ajuste le taux d'apprentissage pour chaque paramètre en fonction des estimations des premier et second moments des gradients.
  • Bien adapté aux données bruitées et aux gradients épars.
  • Efficace et nécessite généralement moins de réglages, ce qui en fait un optimiseur recommandé pour YOLO26.

• RMSProp (Root Mean Square Propagation) :

  • Ajuste le taux d'apprentissage pour chaque paramètre en divisant le gradient par une moyenne mobile des magnitudes des gradients récents.
  • Aide à gérer le problème de disparition du gradient et est efficace pour les réseaux de neurones récurrents.

• MuSGD (Hybride Muon + SGD) :

  • Combine des mises à jour de type SGD avec un comportement inspiré de Muon pour une meilleure stabilité lors d'un entraînement à grande échelle.
  • Un bon choix lorsque tu veux une généralisation similaire à SGD mais que tu as besoin d'une convergence plus fluide que le SGD standard.
  • Particulièrement pertinent pour les recettes d'entraînement YOLO26 ; en cas de doute, commence avec optimizer=auto et compare avec MuSGD sur ton jeu de données.

Pour YOLO26, le paramètre optimizer te permet de choisir parmi divers optimiseurs, incluant SGD, MuSGD, Adam, AdamW, NAdam, RAdam et RMSProp, ou tu peux le définir sur auto pour une sélection automatique basée sur la configuration du modèle.

yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGD

Se connecter avec la communauté

Faire partie d'une communauté de passionnés de vision par ordinateur peut t'aider à résoudre des problèmes et à apprendre plus rapidement. Voici quelques moyens de te connecter, d'obtenir de l'aide et de partager des idées.

Ressources communautaires

• GitHub Issues : Visite le dépôt GitHub YOLO26 et utilise l'onglet Issues pour poser des questions, signaler des bugs et suggérer de nouvelles fonctionnalités. La communauté et les responsables sont très actifs et prêts à t'aider.
• Serveur Discord Ultralytics : Rejoins le serveur Discord Ultralytics pour discuter avec d'autres utilisateurs et développeurs, obtenir du support et partager tes expériences.

Documentation officielle

• Documentation Ultralytics YOLO26 : Consulte la documentation officielle YOLO26 pour des guides détaillés et des conseils utiles sur divers projets de vision par ordinateur.

Utiliser ces ressources t'aidera à résoudre les défis et à rester à jour avec les dernières tendances et pratiques dans la communauté de la vision par ordinateur.

Points clés à retenir

L'entraînement de modèles de vision par ordinateur implique de suivre de bonnes pratiques, d'optimiser tes stratégies et de résoudre les problèmes dès qu'ils surviennent. Des techniques comme l'ajustement des tailles de lot, l'entraînement en précision mixte et le démarrage avec des poids pré-entraînés peuvent améliorer tes modèles et les entraîner plus rapidement. Des méthodes comme l'entraînement sur sous-ensemble et l'arrêt précoce t'aident à économiser du temps et des ressources. Rester connecté avec la communauté et suivre les nouvelles tendances t'aidera à continuer à améliorer tes compétences en entraînement de modèles.

FAQ

Comment puis-je améliorer l'utilisation du GPU lors de l'entraînement d'un grand jeu de données avec Ultralytics YOLO ?

Pour améliorer l'utilisation du GPU, définis le paramètre batch_size dans ta configuration d'entraînement à la taille maximale supportée par ton GPU. Cela garantit que tu utilises pleinement les capacités du GPU, réduisant le temps d'entraînement. Si tu rencontres des erreurs de mémoire, réduis progressivement la taille de lot jusqu'à ce que l'entraînement se déroule sans problème. Pour YOLO26, définir batch=-1 dans ton script d'entraînement déterminera automatiquement la taille de lot optimale pour un traitement efficace. Pour plus d'informations, reporte-toi à la configuration d'entraînement.

Qu'est-ce que l'entraînement en précision mixte, et comment l'activer dans YOLO26 ?

L'entraînement en précision mixte utilise à la fois des types à virgule flottante 16 bits (FP16) et 32 bits (FP32) pour équilibrer la vitesse de calcul et la précision. Cette approche accélère l'entraînement et réduit l'utilisation mémoire sans sacrifier la précision du modèle. Pour activer l'entraînement en précision mixte dans YOLO26, définis le paramètre amp sur True dans ta configuration d'entraînement. Cela active l'entraînement en Précision Mixte Automatique (AMP). Pour plus de détails sur cette technique d'optimisation, consulte la configuration d'entraînement.

Comment l'entraînement multi-échelle améliore-t-il les performances du modèle YOLO26 ?

L'entraînement multi-échelle améliore les performances du modèle en l'entraînant sur des images de tailles variables, permettant au modèle de mieux généraliser à travers différentes échelles et distances. Dans YOLO26, tu peux activer l'entraînement multi-échelle en définissant le paramètre scale dans la configuration d'entraînement. Par exemple, scale=0.5 échantillonne un facteur de zoom entre 0,5 et 1,5, puis applique un padding/recadrage pour revenir à imgsz. Cette technique simule des objets à différentes distances, rendant le modèle plus robuste dans divers scénarios. Pour les paramètres et plus de détails, jette un œil à la configuration d'entraînement.

Comment puis-je utiliser des poids pré-entraînés pour accélérer l'entraînement dans YOLO26 ?

Utiliser des poids pré-entraînés peut grandement accélérer l'entraînement et améliorer la précision du modèle en tirant parti d'un modèle déjà familier avec des caractéristiques visuelles fondamentales. Dans YOLO26, définis simplement le paramètre pretrained sur True ou fournis un chemin vers tes poids pré-entraînés personnalisés dans la configuration d'entraînement. Cette méthode, appelée transfer learning, permet aux modèles entraînés sur de grands jeux de données d'être efficacement adaptés à ton application spécifique. Apprends-en plus sur la façon d'utiliser les poids pré-entraînés et leurs avantages dans le guide de configuration d'entraînement.

Quel est le nombre recommandé d'époques pour entraîner un modèle, et comment le définir dans YOLO26 ?

Le nombre d'époques fait référence aux passages complets sur le jeu de données d'entraînement lors de l'entraînement du modèle. Un point de départ typique est 300 époques. Si ton modèle est en surapprentissage trop tôt, tu peux réduire le nombre. Alternativement, si le surapprentissage n'est pas observé, tu pourrais étendre l'entraînement à 600, 1200 époques ou plus. Pour définir cela dans YOLO26, utilise le paramètre epochs dans ton script d'entraînement. Pour des conseils supplémentaires sur la détermination du nombre idéal d'époques, reporte-toi à cette section sur le nombre d'époques.