Link to this sectionBonnes pratiques et conseils en apprentissage automatique pour l'entraînement de modèles#

Link to this sectionIntroduction#

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 la performance et la précision de ton application. Dans ce guide, nous aborderons les bonnes pratiques, les techniques d'optimisation et les conseils de dépannage pour t'aider à entraîner tes modèles de vision par ordinateur efficacement.

Link to this sectionComment 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 est alimenté par un large ensemble d'images étiquetées. Il effectue 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 valeurs réelles.

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. Avec le temps, il apprend à reconnaître des motifs complexes tels que les formes, les couleurs et les 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'instance, la segmentation sémantique 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 lorsque nous entraînons un modèle, examinons les points à considérer lors de l'entraînement d'un modèle.

Link to this sectionEntraî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.

Link to this sectionTaille 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 prise en charge par ton GPU, tu peux tirer pleinement parti de ses capacités et réduire le temps que prend 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 le paramètre batch 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 du lot qui peut être traitée efficacement en fonction des capacités de ton appareil. En affinant la taille du lot, tu peux tirer le meilleur parti de tes ressources GPU et améliorer le processus d'entraînement global.

Link to this sectionEntraî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 plus large. 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 avec 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 pour régler ton modèle avant de t'engager dans l'entraînement d'un modèle complet sur tout le jeu de données. L'entraînement sur sous-ensemble t'aide à progresser rapidement et à identifier les problèmes potentiels dès le début.

Link to this sectionEntraî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 ainsi 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 prend également en charge l'entraînement multi-échelle de la taille de l'image via le paramètre multi_scale. Contrairement à scale, qui zoome les images puis remplit/recadre vers imgsz, multi_scale change imgsz lui-même à chaque lot (arrondi au pas 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 exemple, 480, 512, 544, ..., 800), tandis que multi_scale=0.0 maintient une taille fixe.

Link to this sectionMise 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 les 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.

Link to this sectionEntraînement en précision mixte#

L'entraînement en précision mixte utilise à la fois des types de virgule flottante 16 bits (FP16) et 32 bits (FP32). Les forces du FP16 et du FP32 sont exploitées en utilisant FP16 pour un calcul plus rapide et FP32 pour maintenir la précision là où c'est 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 plus faible. Cependant, une copie maître 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 prend en charge. De nombreux frameworks de deep learning modernes, tels que PyTorch et TensorFlow, offrent une prise en charge intégrée de 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.

Link to this sectionPoids 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 réglage fin (fine-tuning) d'un modèle pré-entraîné consiste à partir de ces poids, puis à 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 rapides 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é. L'utilisation efficace des poids pré-entraînés et du transfer learning booste les capacités de ton modèle et réduit les coûts d'entraînement.

Link to this sectionAutres techniques à envisager lors de la manipulation d'un grand jeu de données#

Il existe quelques autres techniques à envisager lors de la manipulation 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 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 d'entraînement sur plusieurs GPU ou machines. Cette approche est particulièrement précieuse pour les projets à l'échelle de l'entreprise disposant de ressources informatiques substantielles.

Link to this sectionLe nombre d'époques pour lesquelles s'entraîner#

Lors de l'entraînement d'un modèle, une époque 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 se pose 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) prématurément, 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 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. De plus grands jeux de données pourraient nécessiter plus d'époques pour que le modèle apprenne efficacement, tandis que de plus petits jeux de données pourraient nécessiter moins d'époques pour éviter le surapprentissage. Concernant YOLO26, tu peux définir le paramètre epochs dans ton script d'entraînement.

Link to this sectionArrêt anticipé (Early Stopping)#

L'arrêt anticipé est une technique précieuse pour optimiser l'entraînement d'un modèle. 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 ainsi économiser des ressources informatiques et prévenir le surapprentissage.

Le processus implique de définir un paramètre de patience qui détermine combien d'époques attendre 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 au cours de 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.

Link to this sectionChoisir entre entraînement dans le cloud et 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 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 augmenter les 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 continus du cloud. Il peut être plus économique pour les projets à long terme, et comme tes données restent sur site, 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 grands modèles.

Link to this sectionSélectionner 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 les performances 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 vitesse et la précision avec lesquelles le modèle apprend.

Tu peux également affiner les paramètres de l'optimiseur pour améliorer les performances du modèle. L'ajustement du 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, le réglage du 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.

Link to this sectionOptimiseurs 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 pourrait rester bloqué dans des minima locaux.

• Adam (Adaptive Moment Estimation) :

  • Combine les avantages à la fois 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 style SGD avec un comportement inspiré de Muon pour une stabilité améliorée dans l'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 par 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

Link to this sectionSe 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 vite. Voici quelques moyens de te connecter, d'obtenir de l'aide et de partager des idées.

Link to this sectionRessources communautaires#

• Problèmes GitHub : 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 Ultralytics : Rejoins le serveur Discord Ultralytics pour discuter avec d'autres utilisateurs et développeurs, obtenir du support et partager tes expériences.

Link to this sectionDocumentation officielle#

• Documentation Ultralytics YOLO26 : Consulte la 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 les défis et à rester à jour avec les dernières tendances et pratiques dans la communauté de la vision par ordinateur.

Link to this sectionPoints 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 au fur et à mesure qu'ils surviennent. Des techniques comme l'ajustement de la taille des lots, 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 accélérer leur entraînement. Des méthodes comme l'entraînement sur sous-ensemble et l'arrêt anticipé t'aident à économiser du temps et des ressources. Rester connecté avec la communauté et suivre les nouvelles tendances t'aidera à continuer d'améliorer tes compétences en entraînement de modèles.

Link to this sectionFAQ#

Link to this sectionComment 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 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 ainsi le temps d'entraînement. Si tu rencontres des erreurs de mémoire, réduis progressivement la taille du 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, réfère-toi à la configuration d'entraînement.

Link to this sectionQu'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 précision du modèle. Pour activer l'entraînement en précision mixte dans YOLO26, règle 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, voir la configuration d'entraînement.

Link to this sectionComment 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 s'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 réglant 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 vers 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 la configuration d'entraînement.

Link to this sectionComment 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 exploitant un modèle déjà familier avec les caractéristiques visuelles fondamentales. Dans YOLO26, règle 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. En apprends davantage sur la façon d'utiliser des poids pré-entraînés et leurs avantages dans le guide de configuration d'entraînement.

Link to this sectionQuel 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 300 époques. Si ton modèle fait du surapprentissage prématurément, tu peux réduire le nombre. Alternativement, si le surapprentissage n'est pas observé, tu pourrais étendre l'entraînement à 600, 1200 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, consulte cette section sur le nombre d'époques.