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

Introduction

L'une des étapes les plus importantes lorsque tu travailles sur un projet de vision par ordinateur est l'entraînement de modèle. Avant d'atteindre cette étape, tu dois définir tes objectifs et en collecter et annoter tes données. Après le prétraitement des 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 du modèle ? L'entraînement de modèle est le processus qui consiste à apprendre à ton modèle à reconnaître des modèles 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 couvrirons les bonnes pratiques, les techniques d'optimisation et des conseils de dépannage pour t'aider à entraîner efficacement tes modèles de vision par ordinateur.

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 pour minimiser les erreurs. Initialement, le modèle est alimenté par un vaste ensemble d'images étiquetées. Il fait des prédictions sur ce que contiennent ces images, et les prédictions sont comparées aux étiquettes ou aux contenus réels pour calculer les erreurs. Ces erreurs montrent à quel point les prédictions du modèle s'écartent des vraies valeurs.

Pendant l'entraînement, le modèle effectue itérativement 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. Avec le temps, il apprend à reconnaître des modèles complexes tels que les formes, les couleurs et les textures.

Ce processus d'apprentissage permet au modèle computer vision d'effectuer diverses tâchesPolyvalence selon les tâchesobject detection, 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 du monde réel.

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

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 (batch size), contrôler l'utilisation du GPU, choisir d'utiliser l'entraînement multi-échelle, etc. Passons en revue chacune de ces options en détail.

Taille du 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 du 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 tirer pleinement parti de ses capacités et réduire le temps nécessaire à l'entraînement du modèle. Cependant, tu veux éviter de manquer de mémoire GPU. Si tu rencontres des erreurs de mémoire, réduis la taille du lot progressivement jusqu'à ce que le modèle s'entraîne sans problème.

Concernant YOLO26, tu peux définir la batch_size dans la méthode 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 qui peut être traitée efficacement en fonction des capacités de ton appareil. En ajustant finement la taille du lot, tu peux maximiser 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 plus petit ensemble de données représentatif du jeu de données complet. Cela peut économiser du temps et des ressources, surtout pendant le développement initial et les tests 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.

Lorsqu'il s'agit de 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 pour ajuster ton modèle avant de t'engager à l'entraîner 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 variées. 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 par un facteur spécifié, simulant des objets à différentes distances. Par exemple, définir scale=0.5 zoome aléatoirement sur 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 sur les images puis ajoute des bordures ou recadre pour revenir à imgsz, multi_scale modifie imgsz lui-même à chaque lot (arrondi au pas du modèle). Par exemple, avec imgsz=640 et en multi_scale=0.25, la taille d'entraînement est échantillonnée de 480 jusqu'à 800 par pas de progression (par ex. 480, 512, 544, ..., 800), tandis que multi_scale=0.0 conserve une taille fixe.

Mise en cache (Caching)

Le 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, le 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.

Le cache peut être contrôlé lors de l'entraînement de YOLO26 en utilisant le 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 disque, plus lent que la RAM mais plus rapide que de charger de nouvelles données à chaque fois.
• cache=False : Désactive le cache, reposant 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 forces du FP16 et du FP32 sont exploitées 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éseaux de neurones sont effectuées en FP16 pour bénéficier d'un calcul plus rapide et d'une utilisation mémoire réduite. Cependant, une copie maître des poids du modèle est conservée en FP32 pour assurer la précision lors des étapes de mise à jour des poids. Tu peux ainsi 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 deep learning, tels que PyTorch et en 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 le drapeau 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. Apprentissage par transfert (Transfer learning) adapte des modèles pré-entraînés à de nouvelles tâches connexes. Le fine-tuning d'un modèle pré-entraîné implique de commencer avec ces poids, puis de poursuivre l'entraînement sur ton jeu de données spécifique. Cette méthode d'entraînement se traduit par 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.

La méthode pretrained le paramètre facilite l'apprentissage par transfert 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 efficacement les poids pré-entraînés et l'apprentissage par transfert booste les capacités de ton modèle et réduit les coûts d'entraînement.

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

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

• Taux d'apprentissage Planificateurs (Schedulers): Implémenter des 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 d'apprentissage 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 sur plusieurs GPU ou machines. Cette approche est particulièrement précieuse pour les projets à l'échelle de l'entreprise disposant de ressources de calcul substantielles.

Le nombre d'époques pour lesquelles s'entraîner

Lors de l'entraînement d'un modèle, une epoch fait référence à un passage complet à travers l'ensemble du jeu de données d'entraînement. Au cours d'une époque, le modèle traite chaque exemple de l'ensemble d'entraînement une fois et met à jour ses paramètres en fonction de 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 qui surgit est de savoir comment déterminer le nombre d'époques pour lesquelles entraîner le modèle. Un bon point de départ est 300 époques. Si le modèle fait du surapprentissage (overfitting) tôt, tu peux réduire le nombre d'époques. Si overfitting ne se produit pas après 300 époques, tu peux étendre l'entraînement à 600, 1200, 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 grands jeux de données peuvent nécessiter plus d'époques pour que le modèle apprenne efficacement, tandis que les plus petits peuvent en nécessiter moins pour éviter le surapprentissage. Concernant YOLO26, tu peux définir le paramètre epochs dans ton script d'entraînement.

Arrêt anticipé (Early Stopping)

L'arrêt anticipé est une technique précieuse pour optimiser l'entraînement de modèle. En surveillant les performances de validation, tu peux interrompre l'entraînement dès que le modèle cesse de s'améliorer. Tu peux économiser des ressources de calcul et prévenir 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 la performance du modèle ne s'améliore pas dans ces époques, l'entraînement est arrêté pour éviter de gaspiller du temps et des ressources.

Pour YOLO26, tu peux activer l'arrêt anticipé 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 pas d'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 en local

Il y a 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 une évolutivité et un 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 la 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 de plus grands modèles. 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 aux coûts et à la latence.

L'entraînement local offre un meilleur contrôle et une personnalisation accrue, te permettant d'adapter ton environnement à des besoins spécifiques et d'éviter les coûts cloud continus. Il 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 de grands modèles.

Sélectionner un optimiseur

Un optimiseur est un algorithme qui ajuste les poids de ton réseau neuronal pour minimiser la loss function, 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 aussi ajuster 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 (Descente de Gradient Stochastique):

  • 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 coincé dans des minima locaux.

• Adam (Estimation Adaptative des Moments):

  • Combine les avantages à la fois du SGD avec momentum et du RMSProp.
  • Ajuste le taux d'apprentissage pour chaque paramètre sur la base d'estimations des premier et deuxième moments des gradients.
  • Bien adapté aux données bruitées et aux gradients creux.
  • Efficace et nécessitant 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 stabilité améliorée lors de l'entraînement à grande échelle.
  • Un bon choix lorsque tu souhaites une généralisation de type 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, notamment 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 tes 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 mainteneurs sont très actifs et prêts à t'aider.
• Serveur Discord d'Ultralytics : Rejoins le serveur Discord d'Ultralytics pour discuter avec d'autres utilisateurs et développeurs, obtenir du support et partager tes expériences.

Documentation officielle

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

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

Points clés

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 au fur et à mesure qu'ils surviennent. Des techniques comme l'ajustement de la taille des lots (batch sizes), le précision entraînement en précision mixte et l'utilisation de poids pré-entraînés peuvent améliorer tes modèles et accélérer l'entraînement. Des méthodes comme l'entraînement sur sous-ensemble et l'arrêt précoce (early stopping) t'aident à gagner du temps et des ressources. Rester en contact avec la communauté et suivre les nouvelles tendances t'aidera à continuer d'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, règle le paramètre batch_size dans ta configuration d'entraînement à la taille maximale prise en charge par ton GPU. Cela garantit que tu utilises pleinement les capacités du GPU, réduisant ainsi le temps d'entraînement. Si tu rencontres des erreurs de mémoire, réduis progressivement la taille du batch 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 batch optimale pour un traitement efficace. Pour plus d'informations, reporte-toi au 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 de 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 de la mémoire sans sacrifier la la précision du modèle. Pour activer l'entraînement en précision mixte dans YOLO26, définis le amp à 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, voir le 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 entraînant sur des images de tailles variées, 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 remplit/recadre à 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, consulte le 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 considérablement 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 les caractéristiques visuelles fondamentales. Dans YOLO26, définis simplement le pretrained à 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 apprentissage par transfert (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 à travers le jeu de données d'entraînement pendant l'entraînement du modèle. Un point de départ typique est de 300 époques. Si ton modèle sur-apprend (overfits) rapidement, tu peux réduire ce nombre. Alternativement, si aucun sur-apprentissage n'est observé, tu pourrais prolonger l'entraînement à 600, 1200 ou plus d'époques. 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.