Meilleures pratiques et conseils d'apprentissage automatique pour l'entraînement des modèles

Introduction

L'une des étapes les plus importantes lorsque l'on travaille sur un projet de vision par ordinateur est l'entraînement du modèle. Avant d'atteindre cette étape, vous devez définir vos objectifs et collecter et annoter vos données. Après avoir prétraité les données pour vous assurer qu'elles sont propres et cohérentes, vous pouvez passer à l'entraînement de votre modèle.

Regarder : Conseils pour l'entraînement de modèles | Comment gérer les grands ensembles de données | Taille du lot, utilisation du GPU et Précision Mixte

Alors, qu'est-ce que l'entraînement du modèle ? L'entraînement du modèle est le processus qui consiste à apprendre à votre modèle à reconnaître les motifs visuels et à faire des prédictions basées sur vos données. Il a un impact direct sur les performances et la précision de votre application. Dans ce guide, nous aborderons les meilleures pratiques, les techniques d'optimisation et les conseils de dépannage pour vous aider à entraîner efficacement vos 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 reçoit un grand ensemble d'images étiquetées. Il fait des prédictions sur ce qui se trouve dans ces images, et les prédictions sont comparées aux étiquettes ou au contenu réels pour calculer les erreurs. Ces erreurs montrent à quel point les prédictions du modèle s'éloignent des valeurs réelles.

Pendant l'entraînement, le modèle effectue itérativement des prédictions, calcule les erreurs et met à jour ses paramètres grâce à 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 plusieurs 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 diverses tâches, notamment la détection d'objets, la segmentation d'instance 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 qu'il puisse comprendre avec précision les données visuelles dans les 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 à prendre en compte lors de l'entraînement d'un modèle.

Entraînement sur de grands ensembles de données

Il y a différents aspects à considérer lorsque vous prévoyez d'utiliser un grand ensemble de données pour entraîner un modèle. Par exemple, vous pouvez ajuster la taille du lot, contrôler l'utilisation du GPU, choisir d'utiliser l'entraînement multi-échelle, etc. Examinons 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 ensembles de données, l'utilisation efficace de votre GPU est essentielle. 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 votre GPU, vous pouvez profiter pleinement de ses capacités et réduire le temps nécessaire à l'entraînement du modèle. Cependant, vous devez éviter de manquer de mémoire GPU. Si vous rencontrez des erreurs de mémoire, réduisez progressivement la taille du lot jusqu'à ce que le modèle s'entraîne correctement.

Regarder : Comment utiliser l'inférence par lots avec Ultralytics YOLO11 | Accélérer la détection d'objets en Python 🎉

En ce qui concerne YOLO11, vous pouvez définir le batch_size paramètre dans le configuration d'entraînement pour correspondre à la capacité de votre GPU. De plus, définir batch=-1 dans votre script d'entraînement déterminera automatiquement la taille de lot qui peuvent être traitées efficacement en fonction des capacités de votre appareil. En ajustant la taille du lot, vous pouvez tirer le meilleur parti des ressources de votre GPU et améliorer le processus d'entraînement global.

Entraînement sur un sous-ensemble

L'entraînement sur un sous-ensemble est une stratégie intelligente qui consiste à entraîner votre modèle sur un ensemble de données plus petit qui représente l'ensemble de données plus grand. Cela peut vous faire gagner du temps et des ressources, en particulier lors du développement et des tests initiaux du modèle. Si vous manquez de temps ou si vous expérimentez différentes configurations de modèle, l'entraînement sur un sous-ensemble est une bonne option.

En ce qui concerne YOLO11, vous pouvez facilement implémenter l'entraînement de sous-ensemble en utilisant le fraction paramètre. Ce paramètre vous permet de spécifier quelle fraction de votre ensemble de données utiliser pour l'entraînement. Par exemple, définir fraction=0.1 entraînera votre modèle sur 10 % des données. Vous pouvez utiliser cette technique pour des itérations rapides et pour ajuster votre modèle avant de vous engager à entraîner un modèle en utilisant un ensemble de données complet. L'entraînement de sous-ensembles vous aide à progresser rapidement et à identifier rapidement les problèmes potentiels.

Entraînement multi-échelle

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

Par exemple, lorsque vous entraînez YOLO11, vous pouvez activer l'entraînement multi-échelle en définissant le scale paramètre. 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 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 à votre modèle d'expérimenter une variété d'échelles d'image et d'améliorer ses capacités de détection à travers différentes tailles d'objets et scénarios.

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

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

• cache=True: Stocke les images du jeu de données 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, plus lentement que la RAM, mais plus rapidement que le chargement de nouvelles données à 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 de données à virgule flottante de 16 bits (FP16) et de 32 bits (FP32). Les avantages de FP16 et FP32 sont exploités 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 neuronal sont effectuées en FP16 pour bénéficier d'un calcul plus rapide et d'une utilisation réduite de la mémoire. 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. Vous pouvez gérer des modèles plus grands ou des tailles de lots plus importantes dans les mêmes contraintes matérielles.

Pour implémenter l'apprentissage en précision mixte, vous devrez modifier vos scripts d'apprentissage et vous assurer que votre matériel (comme les GPU) le prend en charge. De nombreux frameworks d'apprentissage profond 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 vous travaillez avec YOLO11. Vous pouvez utiliser le amp flag dans votre configuration d'entraînement. Définir amp=True active l'entraînement AMP (Automatic Mixed Precision). L'entraînement en précision mixte est un moyen simple mais efficace d'optimiser votre processus d'entraînement de modèle.

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 votre modèle. Les poids pré-entraînés proviennent de modèles déjà entraînés sur de grands ensembles de données, ce qui donne à votre modèle une longueur d'avance. L'apprentissage par transfert adapte les modèles pré-entraînés à de nouvelles tâches connexes. Le réglage fin d'un modèle pré-entraîné consiste à commencer avec ces poids, puis à poursuivre l'entraînement sur votre ensemble de données spécifique. Cette méthode d'entraînement permet d'obtenir 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.

L'argument pretrained Le paramètre facilite l'apprentissage par transfert avec YOLO11. Définir pretrained=True utilisera les poids pré-entraînés par défaut, ou vous pouvez spécifier un chemin d'accès vers un modèle pré-entraîné personnalisé. L'utilisation de poids pré-entraînés et l'apprentissage par transfert améliorent efficacement les capacités de votre modèle et réduisent les coûts d'entraînement.

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

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

• Planificateurs du taux d'apprentissage: La mise en œuvre de schedulers 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 YOLO11, le lrf Le paramètre permet de 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 la gestion de grands ensembles de données, l'entraînement distribué peut changer la donne. Vous pouvez 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 intéressante pour les projets à l'échelle de l'entreprise disposant d'importantes ressources de calcul.

Le nombre d'epochs pour l'entraînement

Lors de l'entraînement d'un modèle, une époque fait référence à un passage complet dans l'ensemble des 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 entraîner le modèle. Un bon point de départ est de 300 époques. Si le modèle surajuste tôt, vous pouvez réduire le nombre d’époques. Si le surapprentissage ne se produit pas après 300 époques, vous pouvez étendre l’entraînement à 600, 1200 ou plus d’époques.

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

Arrêt précoce

L'arrêt précoce est une technique précieuse pour optimiser l'entraînement du modèle. En surveillant les performances de validation, vous pouvez interrompre l'entraînement une fois que le modèle cesse de s'améliorer. Vous pouvez économiser des ressources de calcul et éviter le surapprentissage.

Le processus consiste à définir un paramètre de patience qui détermine le nombre 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 au cours de ces époques, l'entraînement est arrêté afin d'éviter de gaspiller du temps et des ressources.

Pour YOLO11, vous pouvez activer l'arrêt anticipé en définissant le paramètre de patience dans votre 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écutifs. 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 la formation dans le cloud et la formation locale

Il existe deux options pour entraîner votre 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 ensembles 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 des TPU haute performance, accélérant les temps d'entraînement et permettant d'expérimenter 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 augmenter les coûts et la latence.

L'entraînement local offre un contrôle et une personnalisation accrus, vous permettant d'adapter votre 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 vos données restent sur site, il est plus sûr. 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élection d'un optimiseur

Un optimiseur est un algorithme qui ajuste les poids de votre réseau neuronal 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 modifiant ses paramètres pour réduire les erreurs. Le choix du bon optimiseur affecte directement la rapidité et la précision avec lesquelles le modèle apprend.

Vous pouvez é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'ampleur des étapes lors de la mise à jour des paramètres. Pour plus de stabilité, vous pouvez commencer avec un taux d'apprentissage modéré et le diminuer progressivement au fil du temps afin d'améliorer l'apprentissage à long terme. De plus, la définition du moment détermine l'influence des mises à jour passées sur les mises à jour actuelles. Une valeur courante pour le moment est d'environ 0,9, ce qui offre généralement un bon équilibre.

Optimiseurs courants

Différents optimiseurs ont des forces et des faiblesses variées. Examinons 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 bloqué dans des minima locaux.

• Adam (Estimation adaptative des moments) :

  • Combine les avantages de SGD avec momentum et de RMSProp.
  • Ajuste le taux d'apprentissage pour chaque paramètre en fonction des estimations des premier et deuxième moments des gradients.
  • Convient bien aux données bruitées et aux gradients clairsemés.
  • Efficace et nécessitant généralement moins de réglages, ce qui en fait un optimiseur recommandé pour YOLO11.

• RMSProp (Root Mean Square Propagation) :

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

Pour YOLO11, le optimizer Le paramètre vous permet de choisir parmi différents optimiseurs, notamment SGD, Adam, AdamW, NAdam, RAdam et RMSProp, ou vous pouvez le définir sur auto pour une sélection automatique basée sur la configuration du modèle.

Connectez-vous avec la communauté

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

Ressources communautaires

• Problèmes GitHub : Visitez le dépôt YOLO11 GitHub et utilisez l'onglet Problèmes 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 à vous aider.
• Serveur Discord Ultralytics : Rejoignez le serveur Discord Ultralytics pour discuter avec d’autres utilisateurs et développeurs, obtenir de l’aide et partager vos expériences.

Documentation officielle

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

L'utilisation de ces ressources vous aidera à résoudre les défis et à vous tenir au courant des 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 vos stratégies et de résoudre les problèmes à mesure qu'ils surviennent. Des techniques telles que l'ajustement des tailles de lots, l'entraînement en précision mixte et le démarrage avec des poids pré-entraînés peuvent améliorer le fonctionnement de vos modèles et accélérer l'entraînement. Des méthodes telles que l'entraînement de sous-ensembles et l'arrêt précoce vous aident à économiser du temps et des ressources. Rester connecté à la communauté et se tenir au courant des nouvelles tendances vous aidera à continuer d'améliorer vos compétences en matière d'entraînement de modèles.

FAQ

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

Pour améliorer l'utilisation du GPU, définissez le batch_size paramètre dans votre configuration d'entraînement à la taille maximale prise en charge par votre GPU. Cela garantit que vous utilisez pleinement les capacités du GPU, réduisant ainsi le temps d'entraînement. Si vous rencontrez des erreurs de mémoire, réduisez progressivement la taille du lot jusqu'à ce que l'entraînement se déroule sans problème. Pour YOLO11, définir batch=-1 dans votre script d'entraînement déterminera automatiquement la taille de lot optimale pour un traitement efficace. Pour plus d'informations, consultez la section configuration d'entraînement.

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

L'entraînement en précision mixte utilise à la fois des types de données à virgule flottante de 16 bits (FP16) et de 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 précision. Pour activer l'entraînement en précision mixte dans YOLO11, définissez le amp paramètre à True dans votre configuration d'entraînement. Ceci active l'entraînement en Précision Mixte Automatique (AMP). Pour plus de détails sur cette technique d'optimisation, consultez la section configuration d'entraînement.

Comment l'entraînement multi-échelle améliore-t-il la performance du modèle YOLO11 ?

L'entraînement multi-échelle améliore les performances du modèle en entraînant sur des images de différentes tailles, ce qui permet au modèle de mieux généraliser à différentes échelles et distances. Dans YOLO11, vous pouvez activer l'entraînement multi-échelle en définissant le scale paramètre dans la configuration de l'entraînement. Par exemple, scale=0.5 réduit de moitié la taille de l'image, tandis que scale=2.0 le double. Cette technique simule des objets à différentes distances, ce qui rend le modèle plus robuste dans divers scénarios. Pour les paramètres et plus de détails, consultez la section configuration d'entraînement.

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

L'utilisation de 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à familiarisé avec les caractéristiques visuelles fondamentales. Dans YOLO11, il suffit de définir le pretrained paramètre à True ou indiquez un chemin d'accès à vos poids pré-entraînés personnalisés dans la configuration d'entraînement. Cette méthode, appelée apprentissage par transfert, permet d'adapter efficacement les modèles entraînés sur de grands ensembles de données à votre application spécifique. Pour en savoir plus sur l'utilisation des poids pré-entraînés et leurs avantages, consultez la section guide de configuration de la formation.

Quel est le nombre d'epochs recommandé pour entraîner un modèle, et comment puis-je le définir dans YOLO11 ?

Le nombre d'epochs fait référence au nombre total de passages dans l'ensemble de données d'entraînement pendant l'entraînement du modèle. Un point de départ typique est de 300 epochs. Si votre modèle surajuste rapidement, vous pouvez réduire ce nombre. Inversement, si aucun surapprentissage n'est observé, vous pouvez étendre l'entraînement à 600, 1200 epochs ou plus. Pour définir cela dans YOLO11, utilisez le epochs paramètre dans votre script d'entraînement. Pour des conseils supplémentaires sur la détermination du nombre idéal d'époques, consultez cette section sur nombre d'époques.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 19 jours

Commentaires