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 computer vision project est l'entraînement du modèle. Avant d'atteindre cette étape, tu dois define your goals et collect and annotate your data. Après avoir preprocessing the data pour t'assurer qu'elles sont propres et cohérentes, tu peux passer à l'entraînement de ton modèle.

Model training est le processus qui consiste à apprendre à ton modèle à reconnaître des motifs visuels et à faire des prédictions à partir de tes données, et cela façonne directement la précision de ton application. Ce guide passe en revue les meilleures pratiques, les techniques d'optimisation et les conseils de dépannage pour t'aider à entraîner efficacement tes modèles de computer vision.

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 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 fait des prédictions de manière itérative, calcule les erreurs et met à jour ses paramètres grâce à un processus appelé backpropagation. 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 les formes, les couleurs et les textures.

Ce processus d'apprentissage permet au modèle de computer vision d'exécuter diverses tasks, notamment object detection, instance segmentation, semantic segmentation et image classification. 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 lorsque nous entraînons un modèle, examinons les points à considérer lors de l'entraînement d'un modèle.

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 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 les Train mode arguments pour correspondre à la capacité de ton GPU. Sur un seul accélérateur, batch=-1 analyse le modèle et choisit une batch size visant environ 60 % d'utilisation de la mémoire ; une fraction telle que batch=0.70 cible une part différente. Les exécutions multi-GPU nécessitent une taille de lot globale explicite qui est un multiple du nombre de puces. Sur CPU et Apple silicon, AutoBatch émet un avertissement et revient à batch=16.

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 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.

Quand il s'agit de YOLO26, tu peux facilement implémenter l'entraînement sur sous-ensemble avec le 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 fraction (split) et ignorer les images de test. Les listes à deux éléments telles que [300, 100] laissent la fraction de test complète. Les jeux de données NDJSON sélectionnent des enregistrements espacés de manière égale avant de les télécharger, de sorte que les exécutions répétées réutilisent le sous-ensemble exact. Cette technique favorise les itérations rapides et le réglage avant de t'engager sur le jeu de données complet.

Entraînement multi-échelle#

L'entraînement multi-échelle est une technique qui améliore la capacité de ton modèle à généraliser 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'augmentation d'échelle en définissant le paramètre scale. Ce paramètre ajuste la taille des images d'entraînement d'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 d'un facteur compris entre 0,5 et 1,5 pendant l'entraînement. La configuration de ce paramètre permet à ton modèle de faire l'expérience d'une variété d'échelles d'images et d'améliorer ses capacités de détection à travers différentes tailles d'objets et scénarios.

Ultralytics prend également en charge l'entraînement multi-échelle de la taille des images via le paramètre multi_scale. Contrairement à scale, qui zoome les images puis ajoute un remplissage ou les rogne pour revenir à imgsz, multi_scale modifie imgsz lui-même à chaque batch (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 jusqu'à 800 par pas (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 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 dataset dans la RAM, offrant la vitesse d'accès la plus rapide mais 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 de charger de nouvelles données à chaque fois.
• cache=False : Désactive la mise en cache, s'appuyant entièrement sur les E/S du 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 les 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ù c'est nécessaire. La plupart des opérations du neural network sont effectuées en FP16 pour bénéficier d'un calcul plus rapide et d'une utilisation de la mémoire réduite. Cependant, 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 plus grands ou des tailles de lots plus importantes dans les mêmes limites matérielles.

Pour implémenter l'entraînement en précision mixte, tu dois 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 un support intégré pour la précision mixte.

L'entraînement en précision mixte est simple lorsque tu travailles avec YOLO26 : l'AMP est déjà activé par défaut (amp=True). Sur un GPU CUDA, YOLO effectue une vérification de capacité unique au début de l'entraînement et revient au FP32 complet en cas d'échec ; sur CPU et Apple silicon, l'AMP est entièrement ignoré. Définis amp=False pour forcer le FP32.

Poids pré-entraînés#

L'utilisation de 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 datasets, donnant à ton modèle une longueur d'avance. Le transfer learning adapte des modèles pré-entraînés à de nouvelles tâches apparentées. Affiner un modèle pré-entraîné consiste à partir de ces poids, puis à poursuivre l'entraînement sur ton dataset 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.

Les poids pré-entraînés proviennent de l'argument model, de sorte que model=yolo26n.pt démarre déjà à partir des poids COCO. Le paramètre pretrained contrôle si ces poids sont conservés (True, la valeur par défaut), rejetés (False), ou remplacés par un autre point de contrôle (pretrained=path/to/best.pt). Définir pretrained=True sur un modèle *.yaml ne récupère pas les poids de lui-même. Consulte How to Fine-Tune YOLO on a Custom Dataset pour le flux de travail complet de transfert d'apprentissage.

Autres 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 :

• Learning Rate Schedulers : La mise en œuvre 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. Pour un comportement qu'aucun argument n'expose, tel que des taux d'apprentissage par couche ou le découpage de gradient, subclass the trainer.
• 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.
• 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. Définis channels_last=False pour conserver NCHW ; PyTorch 1.10 et les versions antérieures, le CPU et MPS restent en NCHW par défaut.

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

Lors de l'entraînement d'un modèle, une epoch correspond à un passage complet à travers l'ensemble du dataset d'entraînement. Au cours d'une epoch, le modèle traite chaque exemple du jeu d'entraînement une fois et met à jour ses paramètres en fonction de l'algorithme d'apprentissage. Plusieurs epochs 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 fréquente qui se pose est de savoir comment déterminer le nombre d'epochs pour entraîner le modèle. Un bon point de départ est de 300 epochs. Si le modèle fait du surapprentissage (overfitting) trop tôt, tu peux réduire le nombre d'epochs. Si l'overfitting ne se produit pas après 300 epochs, tu peux prolonger l'entraînement à 600, 1200 epochs ou plus.

Cependant, le nombre idéal d'epochs peut varier en fonction de la taille de ton dataset et des objectifs du project. Les datasets plus grands peuvent nécessiter plus d'epochs pour que le modèle apprenne efficacement, tandis que les datasets plus petits peuvent avoir besoin de moins d'epochs pour éviter l'overfitting. En ce qui concerne 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 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 précoce (early stopping) 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 epochs consécutives. L'utilisation de 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 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 scalabilité et un matériel puissant, et il est idéal pour gérer de grands datasets et des modèles complexes. Des plateformes telles que 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, en particulier 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.

Sélectionner un optimiseur#

Un optimisateur est un algorithme qui ajuste les poids de ton neural network pour minimiser la loss function, qui mesure les performances du modèle. En termes plus simples, l'optimisateur aide le modèle à apprendre en modifiant ses paramètres pour réduire les erreurs. Le choix du bon optimisateur affecte directement la vitesse 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 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.

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 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. Pour les entraînements plus courts, le optimizer=auto de YOLO26 sélectionne l'optimisateur étroitement apparenté AdamW plutôt qu'Adam lui-même.

• 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 à résoudre le problème de la disparition du gradient (vanishing gradient) et est efficace pour les recurrent neural networks.

• 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 YOLO26 training recipes ; en cas de doute, commence par optimizer=auto et compare avec MuSGD sur ton dataset.

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

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

Ressources communautaires#

• GitHub Issues: Visite le YOLO26 GitHub repository 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.
• Ultralytics Discord Server: Rejoins le Ultralytics Discord server pour discuter avec d'autres utilisateurs et développeurs, obtenir du support et partager tes expériences.

Documentation officielle#

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

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.

Points clés à retenir#

L'entraînement de modèles de computer vision implique de suivre de bonnes pratiques, d'optimiser tes stratégies et de résoudre les problèmes au fur et à mesure qu'ils se présentent. Des techniques telles que l'ajustement des tailles de lots, l'entraînement en precision mixte et le démarrage avec des poids pré-entraînés peuvent rendre tes modèles plus performants et plus rapides à entraîner. Des méthodes telles que l'entraînement sur sous-ensemble et l'early stopping t'aident à économiser du temps et des ressources. Rester connecté avec la communauté et te tenir au courant des nouvelles tendances t'aidera à continuer d'améliorer tes compétences en matière d'entraînement de modèles.

FAQ#