Entraîner un modèle 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 en tirant pleinement parti des capacités du matériel moderne. Ce guide a pour objectif de couvrir tout ce dont tu as besoin pour commencer à entraîner tes propres modèles avec les nombreuses fonctionnalités de YOLO26. Si tu n’as pas encore installé Ultralytics, commence par le guide de démarrage rapide.

Consulte l’aperçu de YOLO27 non encore publié pour découvrir les exemples d’entraînement prévus.

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

Voici quelques bonnes raisons de choisir le mode Train de YOLO26 :

• Efficacité : tire le meilleur parti de ton matériel, que tu utilises une configuration avec un seul GPU ou que tu répartisses la charge sur plusieurs GPU.
• Polyvalence : entraîne tes modèles sur des jeux de données personnalisés, mais aussi sur des jeux de données facilement accessibles tels que COCO, VOC et ImageNet.
• Facilité d’utilisation : des interfaces CLI et Python simples, mais puissantes, pour une expérience d’entraînement fluide.
• Flexibilité des hyperparamètres : un large éventail d’hyperparamètres personnalisables pour affiner les performances du modèle. Pour un contrôle plus poussé, tu peux aussi personnaliser le trainer lui-même.
• Entraînement dans le cloud : entraîne tes modèles sur des GPU cloud via l’Ultralytics Platform, avec des métriques en temps réel et une sauvegarde automatique des points de contrôle.

Principales fonctionnalité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 définissent 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 les jeux de données pris en charge.
• Prise en charge de plusieurs GPU : répartis facilement l’entraînement sur plusieurs GPU pour accélérer le processus.
• Configuration des hyperparamètres : modifie les hyperparamètres à l’aide de fichiers de configuration YAML ou d’arguments CLI.
• Visualisation et suivi : suis les métriques d’entraînement en temps réel et visualise le processus d’apprentissage pour mieux comprendre son déroulement.

Exemples d'utilisation#

Entraîne YOLO26n sur le jeu de données COCO8 pendant 100 époques, avec une taille d’image de 640. Tu peux spécifier l’appareil d’entraînement à 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

# Charger un modèle
model = YOLO("yolo26n.yaml")  # créer un nouveau modèle à partir du fichier YAML
model = YOLO("yolo26n.pt")  # charger un modèle préentraîné (recommandé pour l’entraînement)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # créer à partir du fichier YAML et transférer les poids

# Entraîner le modèle
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 entre plusieurs GPU. Cette fonctionnalité est accessible via l’API Python et l’interface en ligne de commande. Pour activer l’entraînement sur plusieurs GPU, indique les ID des GPU que tu souhaites utiliser.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")  # charger un modèle préentraîné (recommandé pour l’entraînement)

# Entraîner le modèle sur 2 GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Entraîner le modèle sur les deux GPU les moins sollicités
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 compilée avec ROCm et la syntaxe standard device=0 ou device=cuda:0. Consulte le guide d’intégration AMD pour l’installation de ROCm, l’entraînement sur plusieurs GPU, les notes sur AMP et l’inférence MIGraphX des modèles exportés.

L’entraînement sur GPU Intel utilise device=xpu:0, ou plusieurs ID XPU avec une version de 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 compatibles entre elles 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")

# Entraîner sur un NPU Ascend
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Entraîner sur deux NPU Ascend avec HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Les fonctionnalités d’entraînement standard, notamment AMP, la validation, la sauvegarde des 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 ID NPU lancent un entraînement distribué via HCCL. Consulte le guide d’intégration Huawei Ascend pour exporter et déployer le modèle après l’entraînement.

Entraînement sur les GPU les moins sollicités#

L’entraînement sur les GPU les moins sollicités sélectionne automatiquement les GPU les moins utilisés sur les systèmes qui en possèdent plusieurs, afin d’optimiser l’utilisation des ressources sans sélection manuelle. Cette fonctionnalité repère les GPU disponibles en fonction de leur taux d’utilisation et de la mémoire VRAM disponible.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")  # charger un modèle préentraîné (recommandé pour l’entraînement)

# Entraîner le modèle sur le GPU le moins sollicité
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Entraîner le modèle sur les deux GPU les moins sollicités
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

L’algorithme de sélection automatique privilégie les GPU qui présentent :

1. Un taux d’utilisation actuel plus faible
2. Une plus grande quantité de mémoire disponible (VRAM libre)

Cette fonctionnalité est particulièrement utile dans les environnements informatiques partagés ou lorsque plusieurs tâches d’entraînement sont exécutées sur différents modèles. Elle s’adapte automatiquement à l’évolution des conditions du système et garantit une allocation optimale des ressources sans intervention manuelle.

Entraînement MPS sur Apple Silicon#

Grâce à la prise en charge intégrée des puces Apple Silicon dans les 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 performante pour exécuter des tâches de calcul et de traitement d’images sur les puces conçues par Apple.

Pour activer l’entraînement sur les puces Apple Silicon, indique 'mps' comme appareil au démarrage de l’entraînement. Voici un exemple d’utilisation en Python et en ligne de commande :

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")  # charger un modèle préentraîné (recommandé pour l’entraînement)

# Entraîner le modèle avec MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

En tirant parti de la puissance de calcul des puces Apple Silicon, cette fonctionnalité améliore l’efficacité du traitement des tâches d’entraînement. Pour obtenir des conseils plus détaillés et découvrir les options de configuration avancées, consulte la documentation PyTorch MPS.

Reprendre un entraînement interrompu#

La reprise de l’entraînement à partir d’un état précédemment enregistré est une fonctionnalité essentielle lorsqu’on travaille avec des modèles d’apprentissage profond. 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 poursuivre l’entraînement d’un modèle avec de nouvelles données ou pendant davantage d’époques.

Lors de la reprise de l’entraînement, Ultralytics YOLO charge les poids du dernier modèle enregistré et restaure également l’état de l’optimiseur, le planificateur de taux d’apprentissage, le numéro de l’époque et le jeu de données. Cela te permet de reprendre le processus d’entraînement sans interruption là où il s’était arrêté. Transmets explicitement data= avec resume pour poursuivre l’entraînement sur un autre jeu de données au lieu de celui du point de reprise.

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 indiquant le chemin du fichier .pt contenant les poids du modèle partiellement entraîné.

Voici un exemple de reprise d’un entraînement interrompu avec Python et depuis la ligne de commande :

from ultralytics import YOLO

# Charger un modèle
model = YOLO("path/to/last.pt")  # charger un modèle partiellement entraîné

# Reprendre l’entraînement
results = model.train(resume=True)

En définissant resume=True, la fonction train poursuivra l’entraînement là où il s’était arrêté, à partir de l’état enregistré 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 points de reprise sont enregistrés par défaut à la fin de chaque époque, ou à 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 des modèles YOLO comprennent différents hyperparamètres et réglages utilisés pendant le processus d’entraînement. Ces paramètres influent sur les performances, la vitesse et la précision du modèle. Les principaux paramètres d’entraînement comprennent la taille de lot, 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 influer sur le processus d’entraînement. Il est essentiel de régler ces paramètres avec soin et d’expérimenter afin d’optimiser les performances.

Optimiseur MuSGD#

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

Il est recommandé pour les entraînements YOLO26 de longue durée et les jeux de données plus volumineux, où les mises à jour Muon orthogonalisées peuvent contribuer à 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 type Muon avec SGD, tandis que tous les autres paramètres, comme les poids de normalisation par lot et les termes de biais, restent soumis au SGD standard.

Lorsque optimizer=auto est utilisé, Ultralytics sélectionne automatiquement MuSGD pour les entraînements de longue durée (généralement lorsque le nombre d’itérations > 10000). Pour les entraînements plus courts, l’entraîneur utilise AdamW. En mode auto, l’entraîneur sélectionne également le taux d’apprentissage ; tout lr0 fourni par l’utilisateur est donc ignoré. Pour contrôler ces paramètres manuellement, sélectionne explicitement un optimiseur, par exemple optimizer=AdamW lr0=0.001.

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, car elles introduisent de la variabilité dans les données d’entraînement, ce qui aide le modèle à mieux généraliser à des données inédites. Le tableau suivant présente l’objectif et l’effet de chaque argument d’augmentation :

Tu peux ajuster ces paramètres pour répondre aux exigences spécifiques du jeu de données et de la tâche. L’expérimentation avec différentes valeurs peut aider à trouver la stratégie d’augmentation optimale pour obtenir les meilleures performances du modèle.

Journalisation#

Les métriques d’entraînement, les graphiques et les points de reprise sont toujours écrits dans le répertoire d’exécution. Ultralytics les transmet également à tout outil de suivi d’expériences que tu as installé et activé : Comet, ClearML, TensorBoard, MLflow, Weights & Biases et DVCLive. Chaque outil de journalisation s’active via les paramètres 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 des expériences et des modèles. Elle propose notamment des métriques en temps réel, la comparaison des différences de code et le suivi des hyperparamètres.

Pour utiliser Comet :

# pip install comet_ml
import comet_ml

comet_ml.login()

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 leur travail en 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. Elle te permet de visualiser le graphe TensorFlow, de tracer des métriques quantitatives sur l’exécution du 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’emplacement localhost:6006.

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

Cette commande chargera TensorBoard et l’orientera vers le répertoire où sont enregistrés tes journaux d’entraînement.

Après avoir configuré ton outil de journalisation, tu peux lancer l’entraînement de ton modèle. Toutes les métriques d’entraînement seront automatiquement journalisées sur la plateforme de ton choix. Tu pourras consulter ces journaux pour suivre les performances de ton modèle au fil du temps, comparer différents modèles et repérer les points à améliorer.

Et ensuite ?#

Évalue ton modèle entraîné sur des données mises de côté pour vérifier sa précision en conditions réelles, puis exporte-le au format ONNX, TensorRT ou dans un autre format de déploiement. Tu entraînes ton modèle sur tes propres données plutôt que sur COCO8 ? Commence par les formater à l’aide du guide des jeux de données.

FAQ#