Entraînement de modèle avec Ultralytics YOLO#

Introduction#

Entraîner un modèle de deep learning consiste à lui fournir des données et à ajuster ses paramètres pour qu'il puisse faire des prédictions précises. Le mode Train dans Ultralytics YOLO26 est conçu pour un entraînement efficace et performant de modèles de détection d'objets, en exploitant pleinement les capacités du matériel moderne. Ce guide vise à couvrir tous les détails dont tu as besoin pour commencer à entraîner tes propres modèles en utilisant l'ensemble de fonctionnalités robustes de YOLO26. Si tu n'as pas encore installé Ultralytics, commence par le guide de démarrage rapide.

Pourquoi choisir Ultralytics YOLO pour l'entraînement ?#

Voici quelques raisons convaincantes d'opter pour le mode Train de YOLO26 :

• Efficacité : Tire le meilleur parti de ton matériel, que tu sois sur une configuration à un seul GPU ou que tu passes à l'échelle sur plusieurs GPU.
• Polyvalence : Entraîne sur des jeux de données personnalisés en plus de ceux facilement disponibles comme COCO, VOC et ImageNet.
• Convivialité : Interfaces CLI et Python simples mais puissantes pour une expérience d'entraînement directe.
• Flexibilité des hyperparamètres : Une large gamme d'hyperparamètres personnalisables pour affiner les performances du modèle. Pour un contrôle plus approfondi, tu peux personnaliser le formateur toi-même.
• Entraînement dans le cloud : Entraîne-toi sur des GPU cloud via Ultralytics Platform avec des métriques en temps réel et la création automatique de points de contrôle.

Fonctionnalités clés du mode Train#

Voici quelques fonctionnalités notables du mode Train de YOLO26 :

• Téléchargement automatique des jeux de données : Les configurations de jeux de données dotées d'une source de téléchargement sont téléchargées automatiquement lors de la première utilisation, par exemple yolo train data=coco8.yaml. Consulte la présentation des jeux de données pour connaître les formats et jeux de données pris en charge.
• Prise en charge multi-GPU : Fais évoluer tes efforts d'entraînement de manière transparente sur plusieurs GPU pour accélérer le processus.
• Configuration des hyperparamètres : L'option de modifier les hyperparamètres via des fichiers de configuration YAML ou des arguments CLI.
• Visualisation et surveillance : Suivi en temps réel des métriques d'entraînement et visualisation du processus d'apprentissage pour de meilleures perspectives.

Exemples d'utilisation#

Entraîne YOLO26n sur le jeu de données COCO8 pendant 100 époques avec une taille d'image de 640. Le périphérique d'entraînement peut être spécifié à l'aide de l'argument device. Si aucun argument n'est fourni, le GPU device=0 sera utilisé s'il est disponible ; sinon, device='cpu' sera utilisé. Consulte la section Arguments ci-dessous pour obtenir la liste complète des arguments d'entraînement.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.yaml")  # build a new model from YAML
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Entraînement multi-GPU#

L'entraînement multi-GPU permet une utilisation plus efficace des ressources matérielles disponibles en répartissant la charge d'entraînement sur plusieurs GPU. Cette fonctionnalité est disponible via l'API Python et l'interface en ligne de commande. Pour activer l'entraînement multi-GPU, spécifie les ID des périphériques GPU que tu souhaites utiliser.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model with 2 GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Train the model with the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

python -m torch.distributed.run --nproc_per_node 2 your_training_script.py

L'entraînement sur GPU AMD utilise une compilation PyTorch ROCm avec la syntaxe standard device=0 ou device=cuda:0. Consulte le guide d'intégration AMD pour l'installation et l'état actuel de la prise en charge de MIGraphX, DirectML et Ryzen AI NPU.

L'entraînement sur GPU Intel utilise device=xpu:0, ou plusieurs identifiants XPU avec une compilation PyTorch qui fournit XCCL.

Entraînement sur NPU Huawei Ascend#

Ultralytics prend en charge l'entraînement et la validation sur les NPU Huawei Ascend via torch_npu. Installe des versions mutuellement compatibles de CANN, PyTorch et torch_npu en suivant le guide d'installation d'Ascend Extension for PyTorch, puis charge l'environnement CANN avant de démarrer Ultralytics :

source /usr/local/Ascend/ascend-toolkit/set_env.sh

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Train on one Ascend NPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Train across two Ascend NPUs with HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Les fonctionnalités d'entraînement standard, notamment l'AMP, la validation, la création de points de contrôle et la reprise, utilisent le NPU actif. AutoBatch est disponible pour l'entraînement sur un seul NPU, tandis que plusieurs identifiants NPU lancent un entraînement distribué via HCCL. Consulte le guide d'intégration Huawei Ascend pour l'exportation et le déploiement du modèle après l'entraînement.

Entraînement sur GPU inactif#

L'entraînement sur GPU inactif permet une sélection automatique des GPU les moins utilisés dans les systèmes multi-GPU, optimisant l'utilisation des ressources sans sélection manuelle de GPU. Cette fonctionnalité identifie les GPU disponibles en fonction des métriques d'utilisation et de la disponibilité VRAM.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train using the single most idle GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Train using the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

L'algorithme d'auto-sélection privilégie les GPU avec :

1. Des pourcentages d'utilisation actuels plus faibles
2. Une mémoire disponible plus élevée (VRAM libre)
3. Une température et une consommation d'énergie plus basses

Cette fonctionnalité est particulièrement précieuse dans les environnements informatiques partagés ou lors de l'exécution de plusieurs tâches d'entraînement sur différents modèles. Elle s'adapte automatiquement aux conditions changeantes du système, assurant une allocation optimale des ressources sans intervention manuelle.

Entraînement MPS sur Apple Silicon#

Avec la prise en charge des puces Apple silicon intégrée dans les modèles Ultralytics YOLO, il est désormais possible d'entraîner tes modèles sur des appareils utilisant le puissant framework Metal Performance Shaders (MPS). Le MPS offre un moyen haute performance d'exécuter des tâches de calcul et de traitement d'image sur le silicium personnalisé d'Apple.

Pour activer l'entraînement sur les puces Apple silicon, tu dois spécifier 'mps' comme ton périphérique lors de l'initialisation du processus d'entraînement. Voici ci-dessous un exemple de la façon dont tu pourrais faire cela en Python et via la ligne de commande :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model with MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

En exploitant la puissance de calcul des puces Apple Silicon, cela permet un traitement plus efficace des tâches d'entraînement. Pour des conseils plus détaillés et des options de configuration avancées, réfère-toi à la documentation PyTorch MPS.

Reprise d'entraînements interrompus#

Reprendre l'entraînement à partir d'un état précédemment enregistré est une fonctionnalité cruciale lorsque tu travailles avec des modèles de deep learning. Cela peut s'avérer utile dans divers scénarios, comme lorsque le processus d'entraînement a été interrompu de manière inattendue, ou lorsque tu souhaites continuer l'entraînement d'un modèle avec de nouvelles données ou pour plus d'epochs.

Lorsque l'entraînement est repris, Ultralytics YOLO charge les poids du dernier modèle sauvegardé et restaure également l'état de l'optimiseur, le planificateur de taux d'apprentissage et le numéro d'époque. Cela te permet de poursuivre le processus d'entraînement de manière transparente là où il s'était arrêté.

Tu peux facilement reprendre l'entraînement dans Ultralytics YOLO en définissant l'argument resume sur True lors de l'appel de la méthode train, et en spécifiant le chemin d'accès au fichier .pt contenant les poids du modèle partiellement entraîné.

Voici ci-dessous un exemple de la façon de reprendre un entraînement interrompu en utilisant Python et via la ligne de commande :

from ultralytics import YOLO

# Load a model
model = YOLO("path/to/last.pt")  # load a partially trained model

# Resume training
results = model.train(resume=True)

En définissant resume=True, la fonction train reprendra l'entraînement là où il s'était arrêté, en utilisant l'état stocké dans le fichier 'path/to/last.pt'. Si l'argument resume est omis ou défini sur False, la fonction train démarrera une nouvelle session d'entraînement.

Rappelle-toi que les points de contrôle sont sauvegardés à la fin de chaque époque par défaut, ou à des intervalles fixes à l'aide de l'argument save_period, tu dois donc terminer au moins 1 époque pour reprendre un entraînement.

Paramètres d'entraînement#

Les paramètres d'entraînement pour les modèles YOLO englobent divers hyperparamètres et configurations utilisés pendant le processus d'entraînement. Ces paramètres influencent les performances, la vitesse et la précision du modèle. Les principaux paramètres d'entraînement incluent la taille des lots, le taux d'apprentissage, le moment et la décroissance des poids. De plus, le choix de l'optimiseur, de la fonction de perte et de la composition du jeu de données d'entraînement peut avoir un impact sur le processus. Un réglage minutieux et des expérimentations avec ces paramètres sont essentiels pour optimiser les performances.

Optimiseur MuSGD#

Dans YOLO26, MuSGD est un optimiseur hybride qui combine les mises à jour SGD standard avec des mises à jour orthogonalisées de style Muon.

Il est recommandé pour les exécutions d'entraînement YOLO26 plus longues et les jeux de données plus grands, où les mises à jour orthogonales Muon peuvent aider à stabiliser l'optimisation.

Seuls les poids linéaires 2D et les filtres de convolution 4D (redimensionnés en 2D) reçoivent la mise à jour de style Muon avec SGD, tandis que tous les autres paramètres, tels que les poids de normalisation par lot et les termes de biais, restent sur le SGD standard.

Lorsque optimizer=auto est utilisé, Ultralytics sélectionne automatiquement MuSGD pour les entraînements plus longs (généralement lorsque les itérations > 10000). Pour les entraînements plus courts, le formateur se replie sur AdamW.

Exemple d'utilisation :

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

Consulte l'implémentation dans ultralytics/optim/muon.py et la logique de sélection automatique de l'optimiseur dans BaseTrainer.build_optimizer.

Paramètres d'augmentation et hyperparamètres#

Les techniques d'augmentation sont essentielles pour améliorer la robustesse et les performances des modèles YOLO en introduisant de la variabilité dans les données d'entraînement, aidant ainsi le modèle à mieux généraliser face à des données inédites. Le tableau suivant présente le rôle et l'effet de chaque argument d'augmentation :

Ces paramètres peuvent être ajustés pour répondre aux exigences spécifiques du jeu de données et de la tâche à accomplir. Expérimenter avec différentes valeurs peut aider à trouver la stratégie d'augmentation optimale menant à la meilleure performance du modèle.

Journalisation#

Lors de l'entraînement d'un modèle YOLO26, il peut être utile de suivre les performances du modèle au fil du temps. C'est là qu'intervient la journalisation. Ultralytics YOLO offre une prise en charge de trois types de journaliseurs : Comet, ClearML et TensorBoard.

Pour utiliser un outil de journalisation, sélectionne-le dans le menu déroulant du snippet de code ci-dessus et exécute-le. L'outil choisi sera installé et initialisé.

Comet#

Comet est une plateforme qui permet aux data scientists et aux développeurs de suivre, comparer, expliquer et optimiser des expériences et des modèles. Elle fournit des fonctionnalités telles que des métriques en temps réel, des différences de code et le suivi des hyperparamètres.

Pour utiliser Comet :

# pip install comet_ml
import comet_ml

comet_ml.init()

N'oublie pas de te connecter à ton compte Comet sur leur site web et de récupérer ta clé API. Tu devras l'ajouter à tes variables d'environnement ou à ton script pour journaliser tes expériences.

ClearML#

ClearML est une plateforme open source qui automatise le suivi des expériences et facilite le partage efficace des ressources. Elle est conçue pour aider les équipes à gérer, exécuter et reproduire leur travail de ML plus efficacement.

Pour utiliser ClearML :

# pip install clearml
import clearml

clearml.browser_login()

Après avoir exécuté ce script, tu devras te connecter à ton compte ClearML dans le navigateur et authentifier ta session.

TensorBoard#

TensorBoard est une boîte à outils de visualisation pour TensorFlow. Il te permet de visualiser ton graphique TensorFlow, de tracer des métriques quantitatives sur l'exécution de ton graphique et d'afficher des données supplémentaires telles que des images qui y transitent.

Pour utiliser TensorBoard dans Google Colab :

load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directory

Pour utiliser TensorBoard localement, exécute la commande ci-dessous et consulte les résultats sur localhost:6006.

tensorboard --logdir ultralytics/runs # replace with 'runs' directory

Cela chargera TensorBoard et le dirigera vers le répertoire où tes journaux d'entraînement sont enregistrés.

Après avoir configuré ton outil de journalisation, tu peux poursuivre l'entraînement de ton modèle. Toutes les métriques d'entraînement seront automatiquement journalisées sur la plateforme choisie, et tu pourras accéder à ces journaux pour surveiller les performances de ton modèle au fil du temps, comparer différents modèles et identifier les axes d'amélioration.

Et après ?#

Valide ton modèle entraîné sur des données de test isolées pour vérifier sa précision dans le monde réel, puis exporte-le vers ONNX, TensorRT ou un autre format de déploiement. Tu t'entraînes sur tes propres données au lieu de COCO8 ? Formate-les d'abord à l'aide du guide des jeux de données.

FAQ#