Entraînement de modèles avec Ultralytics YOLO#

Introduction#

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

Consulte l'aperçu unreleased YOLO27 preview pour voir les exemples d'entraînement prévus.

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

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

• Efficacité : exploite au maximum ton matériel, que tu utilises une configuration avec un seul GPU ou que tu passes à plusieurs GPU.
• Polyvalence : entraîne tes modèles sur des jeux de données personnalisés, en plus de jeux de données disponibles tels que COCO, VOC et ImageNet.
• Simplicité d'utilisation : des interfaces CLI et Python simples, mais puissantes, pour une expérience d'entraînement fluide.
• Flexibilité des hyperparamètres : une vaste gamme d'hyperparamètres personnalisables pour affiner les performances du modèle. Pour un contrôle plus approfondi, tu peux personnaliser le trainer lui-même.
• Entraînement dans le cloud : entraîne tes modèles sur des GPU cloud via Ultralytics Platform, avec des métriques en temps réel et une sauvegarde automatique des checkpoints.

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 qui indiquent une source de téléchargement sont téléchargées automatiquement lors de leur 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 de plusieurs GPU : répartis facilement ton entraînement sur plusieurs GPU afin d'accélérer le processus.
• Configuration des hyperparamètres : possibilité de modifier les hyperparamètres via des fichiers de configuration YAML ou des arguments CLI.
• Visualisation et suivi : suivi en temps réel des métriques d'entraînement et visualisation du processus d'apprentissage pour obtenir de meilleures informations.

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 transmis, le GPU device=0 sera utilisé lorsqu'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 sur plusieurs GPU#

L'entraînement sur plusieurs GPU permet d'utiliser plus efficacement les 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 de ligne de commande. Pour activer l'entraînement sur plusieurs GPU, indique les identifiants 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 version de 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 du support pour MIGraphX, DirectML et Ryzen AI NPU.

L'entraînement sur GPU Intel utilise device=xpu:0, ou plusieurs identifiants XPU avec une version PyTorch fournissant 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 de l'extension Ascend pour PyTorch, puis charge l'environnement CANN avant de lancer 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, y compris 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 de 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 de sélectionner automatiquement les GPU les moins utilisés dans les systèmes équipés de plusieurs GPU, afin d'optimiser l'utilisation des ressources sans sélection manuelle du GPU. Cette fonctionnalité identifie les GPU disponibles en fonction des métriques d'utilisation et de la disponibilité de la 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 de sélection automatique donne la priorité aux GPU présentant :

1. Un pourcentage d'utilisation actuel plus faible
2. Une mémoire disponible plus importante (VRAM libre)
3. Une température et une consommation électrique plus faibles

Cette fonctionnalité est particulièrement utile 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 à l'évolution des conditions du système, garantissant une allocation optimale des ressources sans intervention manuelle.

Entraînement MPS sur Apple Silicon#

Grâce à la prise en charge des puces Apple Silicon intégrée aux modèles Ultralytics YOLO, tu peux désormais entraîner tes modèles sur des appareils utilisant le puissant framework Metal Performance Shaders (MPS). MPS offre une méthode hautement performante pour 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 périphérique lors du lancement du processus d'entraînement. Voici un exemple montrant comment procéder avec 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, cette option permet de traiter les tâches d'entraînement plus efficacement. Pour obtenir des instructions plus détaillées et découvrir les options de configuration avancées, consulte la documentation PyTorch MPS.

Reprise des entraînements interrompus#

La reprise de l'entraînement à partir d'un état précédemment sauvegardé est une fonctionnalité essentielle lorsque tu travailles avec des modèles de deep learning. Elle peut s'avérer utile dans diverses situations, par exemple lorsque le processus d'entraînement a été interrompu de manière inattendue ou lorsque tu souhaites continuer à entraîner un modèle avec de nouvelles données ou pendant un plus grand nombre d'époques.

Quand 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 learning rate, le numéro d'époque et le dataset. Cela te permet de continuer le processus d'entraînement de manière transparente là où il s'était arrêté. Passe un explicite data= avec resume pour continuer sur un dataset différent au lieu de celui du point de contrôle.

Tu peux facilement reprendre un 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 du fichier .pt contenant les poids du modèle partiellement entraîné.

Voici un exemple montrant comment reprendre un entraînement interrompu avec 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 poursuivra 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.

N'oublie pas que les checkpoints sont sauvegardés à la fin de chaque époque par défaut, ou à intervalles fixes à l'aide de l'argument save_period ; tu dois donc terminer au moins 1 époque pour reprendre une session d'entraînement.

Paramètres d'entraînement#

Les paramètres d'entraînement des modèles YOLO comprennent 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 momentum 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 d'entraînement. Un réglage précis 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 type Muon.

Il est recommandé pour les entraînements YOLO26 plus longs et les jeux de données plus volumineux, car les mises à jour Muon orthogonalisées peuvent contribuer à stabiliser l'optimisation.

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

Lorsque optimizer=auto est utilisé, Ultralytics sélectionne automatiquement MuSGD pour les entraînements plus longs (généralement lorsque le nombre d'itérations est > 10000). Pour les entraînements plus courts, le trainer revient à 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 et hyperparamètres d'augmentation#

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, ce qui aide le modèle à mieux généraliser sur des données inédites. Le tableau suivant présente l'objectif 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 concernée. Expérimenter avec différentes valeurs peut aider à trouver la stratégie d'augmentation optimale, celle qui permet d'obtenir les meilleures performances du modèle.

Journalisation#

Les métriques d'entraînement, les graphiques et les points de contrôle sont toujours écrits dans le répertoire d'exécution, et Ultralytics les diffuse également vers n'importe quel outil de suivi des expériences que tu as installé et activé : Comet, ClearML, TensorBoard, MLflow, Weights & Biases et DVCLive. Chaque journaliseur s'active ou se désactive via les paramètres d'Ultralytics, par exemple yolo settings tensorboard=True. Les trois configurations les plus courantes sont présentées ci-dessous.

Comet#

Comet est une plateforme qui permet aux spécialistes des données et aux développeurs de suivre, comparer, expliquer et optimiser les expériences et les modèles. Elle offre notamment des fonctionnalités de suivi des métriques en temps réel, des différences de code et 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 d'obtenir 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 plus efficacement leurs travaux de ML.

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. Elle te permet de visualiser ton graphe TensorFlow, de représenter graphiquement les métriques quantitatives relatives à l'exécution de ton graphe et d'afficher des données supplémentaires, comme les images qui le traversent.

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 à l'adresse localhost:6006.

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

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

Après avoir configuré ton journaliseur, 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 repérer les points à améliorer.

Et ensuite ?#

Valide ton modèle entraîné sur des données mises de côté afin de vérifier sa précision dans le monde réel, puis exporte-le vers ONNX, TensorRT ou un autre format de déploiement. Tu entraînes ton modèle sur tes propres données plutôt que sur COCO8 ? Formate-les d'abord avec le guide des jeux de données.

FAQ#