Bonnes pratiques et conseils pour l’entraînement des modèles de machine learning#

Introduction#

L’une des étapes les plus importantes lorsque tu travailles 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 et 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.

L’entraînement du modèle est le processus qui consiste à apprendre à ton modèle à reconnaître des motifs visuels et à effectuer des prédictions à partir de tes données, ce qui façonne directement la précision de ton application. Ce guide présente les bonnes pratiques, les techniques d’optimisation et les conseils de dépannage pour t’aider à entraîner efficacement tes modèles de vision par ordinateur.

Comment entraîner un modèle de machine learning#

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 vaste ensemble d’images annotées. Il effectue des prédictions sur le contenu de ces images, puis ces prédictions sont comparées aux annotations ou au contenu réel afin de calculer les erreurs. Ces erreurs indiquent dans quelle mesure les prédictions du modèle s’éloignent des valeurs réelles.

Pendant l’entraînement, le modèle effectue des prédictions de manière itérative, calcule les erreurs et met à jour ses paramètres au moyen d’un processus appelé rétropropagation. Dans ce processus, le modèle ajuste ses paramètres internes (poids et biais) afin de 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 les formes, les couleurs et les textures.

Ce processus d’apprentissage permet au modèle de vision par ordinateur d’effectuer différentes tâches, notamment la détection d’objets, la segmentation d’instances, 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 à prendre en compte lors de l’entraînement d’un modèle.

Entraînement sur de grands jeux de données#

Plusieurs aspects sont à prendre en compte lorsque tu prévois d’utiliser un grand jeu de données pour entraîner un modèle. Tu peux par exemple ajuster la taille des lots, contrôler l’utilisation du GPU, choisir l’entraînement mult i-échelle, etc. Examinons chacune de ces options en détail.

Taille des lots et utilisation du GPU#

Lors de l’entraînement de modèles sur de grands jeux de données, il est essentiel d’utiliser efficacement ton GPU. La taille des lots est un facteur important. Elle correspond au nombre d’échantillons de données qu’un modèle de machine learning traite au cours d’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 la durée de l’entraînement du modèle. Toutefois, tu dois éviter de manquer de mémoire GPU. Si tu rencontres des erreurs de mémoire, réduis progressivement la taille des lots jusqu’à ce que le modèle s’entraîne correctement.

Pour YOLO26, tu peux définir le paramètre batch dans les arguments du mode Train en fonction de la capacité de ton GPU. Sur un accélérateur unique, batch=-1 profile le modèle et choisit une taille de lot visant environ 60 % d’utilisation de la mémoire ; une fraction telle que batch=0.70 vise une autre proportion. Les exécutions multi-GPU nécessitent une taille de lot globale explicite qui soit un multiple du nombre de périphériques. Sur CPU et Apple silicon, AutoBatch émet un avertissement et revient à batch=16.

Entraînement sur un sous-ensemble#

L’entraînement sur un 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. Cette méthode peut faire gagner du temps et économiser des ressources, notamment lors du développement initial et des tests du modèle. Si tu manques de temps ou si tu expérimentes différentes configurations de modèle, l’entraînement sur un sous-ensemble constitue une bonne option.

Avec YOLO26, tu peux facilement mettre en œuvre l’entraînement sur un sous-ensemble à l’aide du paramètre fraction. Utilise un ratio tel que fraction=0.1 pour 10 % des données d’entraînement, un entier tel que fraction=300 pour exactement 300 images d’entraînement, ou une liste [train, val, test] telle que fraction=[300, 100, 0] pour limiter chaque partition et ignorer les images de test. Les listes à deux éléments telles que [300, 100] laissent la partition de test complète. Les jeux de données NDJSON sélectionnent des enregistrements régulièrement espacés avant leur téléchargement ; les exécutions répétées réutilisent donc exactement le même sous-ensemble. Cette technique permet d’itérer et d’ajuster rapidement le modèle avant de passer au jeu de données complet.

Entraînement mult i-échelle#

L’entraînement mult i-é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 ainsi apprendre à détecter des objets à différentes échelles et distances, et devenir plus robuste.

Par exemple, lors de l’entraînement de YOLO26, tu peux activer l’augmentation d’échelle en définissant le paramètre scale. Ce paramètre ajuste la taille des images d’entraînement selon un facteur donné, simulant des objets situés à différentes distances. Par exemple, définir scale=0.5 applique aléatoirement aux images d’entraînement un zoom compris entre 0,5 et 1,5 pendant l’entraînement. La configuration de ce paramètre permet à ton modèle d’être exposé à différentes échelles d’image et d’améliorer ses capacités de détection pour diverses tailles et situations d’objets.

Ultralytics prend également en charge l’entraînement mult i-échelle selon la taille des images via le paramètre multi_scale. Contrairement à scale, qui zoome les images puis les complète ou les recadre pour revenir à imgsz, multi_scale modifie directement imgsz à chaque lot (en l’arrondissant selon le 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 pas de stride (p. 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 de machine learning. En stockant les images prétraitées en mémoire, elle réduit le temps pendant lequel le GPU attend le chargement des données depuis le disque. Le modèle peut recevoir continuellement des données sans subir les délais liés aux opérations d’E/S disque.

La mise en cache peut être contrôlée lors de l’entraînement de YOLO26 à l’aide du paramètre cache :

• cache=True : stocke les images du jeu de données dans la RAM, offrant la vitesse d’accès la plus élevée, au prix d’une utilisation accrue de la mémoire.
• cache='disk' : stocke les images sur le disque, ce qui est plus lent que la RAM, mais plus rapide que le chargement de nouvelles données à chaque fois.
• cache=False : désactive la mise en cache et repose entièrement sur les E/S disque, ce qui constitue l’option la plus lente.

Entraînement en précision mixte#

L’entraînement en précision mixte utilise à la fois des types flottants 16 bits (FP16) et 32 bits (FP32). Les points forts de FP16 et de FP32 sont exploités en utilisant FP16 pour accélérer les calculs et FP32 pour préserver la précision lorsque cela est nécessaire. La plupart des opérations du réseau neuronal sont effectuées en FP16 afin de bénéficier de calculs plus rapides et d’une utilisation réduite de la mémoire. Toutefois, une copie principale 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 ainsi gérer des modèles ou des tailles de lots plus importants dans les mêmes contraintes matérielles.

Pour mettre en œuvre l’entraînement en précision mixte, tu dois modifier tes scripts d’entraînement et vérifier que ton matériel, notamment tes GPU, la prend en charge. De nombreux frameworks modernes de deep learning, 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 avec YOLO26 : AMP est déjà activé par défaut (amp=True). Sur un GPU CUDA, YOLO effectue une vérification ponctuelle des capacités au début de l’entraînement et revient à FP32 intégral en cas d’échec ; sur CPU et Apple silicon, AMP est entièrement ignoré. Définis amp=False pour forcer FP32.

Poids préentraînés#

L’utilisation de poids préentraînés est une méthode intelligente pour accélérer l’entraînement de ton modèle. Ces poids proviennent de modèles déjà entraînés sur de grands jeux de données, ce qui donne une longueur d’avance à ton modèle. L’apprentissage par transfert adapte des modèles préentraînés à de nouvelles tâches connexes. L’ajustement fin d’un modèle préentraîné consiste à commencer avec ces poids, puis à poursuivre l’entraînement sur ton propre jeu de données. Cette méthode permet de réduire la durée d’entraînement et d’obtenir souvent de meilleures performances, car le modèle possède déjà une solide compréhension des caractéristiques fondamentales.

Les poids préentraînés proviennent de l’argument model ; model=yolo26n.pt démarre donc déjà avec des poids COCO. Le paramètre pretrained contrôle si ces poids sont conservés (True, valeur par défaut), supprimés (False) ou remplacés par un autre checkpoint (pretrained=path/to/best.pt). Définir pretrained=True sur un modèle *.yaml ne télécharge pas les poids automatiquement. Consulte Comment ajuster finement YOLO sur un jeu de données personnalisé pour découvrir le workflow complet d’apprentissage par transfert.

Autres techniques à envisager lors de la gestion d’un grand jeu de données#

Voici quelques autres techniques à envisager lors de la gestion d’un grand jeu de données :

• Planificateurs du taux d’apprentissage : les planificateurs du taux d’apprentissage ajustent 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. Pour les comportements qu’aucun argument n’expose, tels que les taux d’apprentissage par couche ou l’écrêtage des gradients, crée une sous-classe du trainer.
• Entraînement distribué : pour gérer de grands jeux de données, l’entraînement distribué peut changer radicalement la donne. Tu peux réduire la durée d’entraînement en répartissant la charge sur plusieurs GPU ou machines. Cette approche est particulièrement utile pour les projets à l’échelle de l’entreprise disposant de ressources de calcul importantes.
• Format de mémoire channels-last : l'entraînement CUDA utilise automatiquement la disposition mémoire NHWC plus rapide sur PyTorch 1.11 et les versions plus récentes, sauf sur Windows, où les performances étaient plus lentes. Définis channels_last=True pour forcer ce format ou channels_last=False pour conserver NCHW ; PyTorch 1.10 et les versions plus anciennes, le CPU et le MPS restent en NCHW par défaut.

Nombre d’époques d’entraînement#

Lors de l’entraînement d’un modèle, une époque correspond à un passage complet sur l’ensemble du jeu de données d’entraînement. Au cours d’une époque, le modèle traite une fois chaque exemple du jeu d’entraînement 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 progressivement ses paramètres.

Une question fréquente consiste à déterminer le nombre d’époques pendant lesquelles entraîner le modèle. Un bon point de départ est de 300 époques. Si le modèle surapprend rapidement, tu peux réduire ce nombre. Si aucun surapprentissage ne survient après 300 époques, tu peux prolonger l’entraînement jusqu’à 600, 1200 époques ou davantage.

Cependant, le nombre idéal d’époques peut varier selon la taille de ton jeu de données et les objectifs du projet. Les jeux de données plus volumineux peuvent nécessiter davantage d’époques pour que le modèle apprenne efficacement, tandis que les jeux de données plus petits peuvent en nécessiter moins afin d’éviter le surapprentissage. Pour YOLO26, tu peux définir le paramètre epochs dans ton script d’entraînement.

Arrêt anticipé#

L’arrêt anticipé est une technique utile pour optimiser l’entraînement d’un modèle. En surveillant les performances sur l’ensemble de validation, tu peux arrêter l’entraînement dès que le modèle cesse de s’améliorer. Tu économises ainsi des ressources de calcul et évites le surapprentissage.

Le processus consiste à définir un paramètre de patience qui détermine le nombre 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 pendant ce nombre d’époques, l’entraînement est interrompu afin d’é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 si les métriques de validation ne s’améliorent pas pendant 5 époques consécutives. Cette méthode garantit un entraînement efficace et des performances optimales sans calculs excessifs.

Choisir entre l’entraînement dans le cloud et l’entraînement local#

Deux options s’offrent à toi 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 grande évolutivité et du matériel puissant ; il 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 hautes performances, accélérant l’entraînement et permettant d’expérimenter avec des modèles plus grands. Toutefois, l’entraînement dans le cloud peut être coûteux, en particulier sur de longues périodes, et le transfert des données peut augmenter les coûts et la latence.

L’entraînement local offre davantage de contrôle et de possibilités de personnalisation, ce qui te permet d’adapter ton environnement à tes besoins spécifiques et d’éviter les coûts récurrents du cloud. Il peut être plus économique pour les projets à long terme et, puisque tes données restent sur site, il est plus sécurisé. En revanche, le matériel local peut présenter des limites de ressources et nécessiter une maintenance, ce qui peut allonger la durée d’entraînement des grands modèles.

Choisir un optimiseur#

Un optimiseur est un algorithme qui ajuste les poids de ton réseau neuronal afin de minimiser la fonction de perte, laquelle mesure les performances du modèle. En termes simples, l’optimiseur aide le modèle à apprendre en modifiant ses paramètres pour réduire les erreurs. Le choix du bon optimiseur influence directement la rapidité et la précision de l’apprentissage du modèle.

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 l’amplitude des pas lors de la mise à jour des paramètres. Pour favoriser la stabilité, tu peux commencer avec un taux d’apprentissage modéré, puis le réduire progressivement afin d’améliorer l’apprentissage à long terme. De plus, le réglage de la vitesse détermine l’influence des mises à jour précédentes sur les mises à jour actuelles. Une valeur courante pour la vitesse est d’environ 0,9. Elle offre généralement un bon équilibre.

Optimiseurs courants#

Les différents optimiseurs présentent diverses forces et faiblesses. Examinons quelques optimiseurs courants.

• SGD (descente de gradient stochastique) :

  • Met à jour les paramètres du modèle à l’aide du gradient de la fonction de perte par rapport aux paramètres.
  • Simple et efficace, mais peut converger lentement et rester bloqué dans des minima locaux.

• Adam (estimation adaptative des moments) :

  • Combine les avantages de SGD avec vitesse et de RMSProp.
  • Ajuste le taux d’apprentissage de chaque paramètre en fonction d’estimations des premier et deuxième moments des gradients.
  • Convient bien aux données bruitées et aux gradients creux.
  • Efficace et nécessitant généralement moins de réglages. Pour les entraînements courts, le optimizer=auto de YOLO26 sélectionne le AdamW qui lui est étroitement lié, plutôt que Adam lui-même.

• RMSProp (propagation de la moyenne quadratique) :

  • Ajuste le taux d’apprentissage de chaque paramètre en divisant le gradient par une moyenne mobile de l’amplitude des gradients récents.
  • Aide à résoudre le problème de disparition du gradient et est efficace pour les réseaux neuronaux récurrents.

• MuSGD (hybride Muon + SGD) :

  • Combine des mises à jour de type SGD avec un comportement inspiré de Muon pour améliorer la stabilité lors des entraînements à grande échelle.
  • Un bon choix si tu recherches une généralisation similaire à celle de SGD, mais une convergence plus régulière que celle de SGD standard.
  • Particulièrement pertinent pour les recettes d’entraînement de YOLO26 ; en cas de doute, commence par optimizer=auto et compare-le à MuSGD sur ton jeu de données.

Pour YOLO26, le paramètre optimizer te permet de choisir parmi différents optimiseurs, notamment SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam et RMSProp, ou de le définir sur auto pour une sélection automatique fondée sur le nombre d’itérations d’entraînement.

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

Rejoindre 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 d’échanger, d’obtenir de l’aide et de partager des idées.

Ressources de la communauté#

• Issues GitHub : consulte le dépôt GitHub de 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 à aider.
• Serveur Discord Ultralytics : rejoins le serveur Discord Ultralytics pour discuter avec d’autres utilisateurs et développeurs, obtenir de l’aide et partager tes expériences.

Documentation officielle#

• Documentation Ultralytics YOLO26 : consulte la documentation officielle de YOLO26 pour accéder à des guides détaillés et à des conseils utiles sur différents projets de vision par ordinateur.

L’utilisation de ces ressources t’aidera à relever les défis et à rester au fait des dernières tendances et pratiques de 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 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 l’utilisation initiale de poids préentraînés peuvent améliorer les performances et accélérer l’entraînement de tes modèles. Des méthodes comme l’entraînement sur un sous-ensemble et l’arrêt anticipé t’aident à économiser du temps et des ressources. En restant connecté à la communauté et au fait des nouvelles tendances, tu continueras à améliorer tes compétences en entraînement de modèles.

FAQ#