Entraînement de 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 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 matérielles modernes. Ce guide vise à couvrir tous les détails dont tu as besoin pour commencer à entraîner tes propres modèles en utilisant l'ensemble robuste de fonctionnalités de YOLO26.

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-toi 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 trainer lui-même.
• Entraînement dans le cloud : Entraîne-toi sur des GPU dans le cloud via Ultralytics Platform avec des métriques en temps réel et une sauvegarde automatique des 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 jeux de données standards comme COCO, VOC et ImageNet sont téléchargés automatiquement lors de la première utilisation.
• 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 analyses.

Exemples d'utilisation

Entraîne YOLO26n sur le jeu de données COCO8 pour 100 epochs avec une taille d'image de 640. Le périphérique d'entraînement peut être spécifié en utilisant l'argument device. Si aucun argument n'est transmis, le GPU device=0 sera utilisé s'il est disponible ; sinon device='cpu' sera utilisé. Consulte la section Arguments ci-dessous pour une 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 distribuant la charge d'entraînement sur plusieurs GPU. Cette fonctionnalité est disponible à la fois via l'API Python et l'interface de ligne de commande. Pour activer l'entraînement multi-GPU, spécifie 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

Entraînement sur GPU inactif

L'entraînement sur GPU inactif permet la sélection automatique des GPU les moins utilisés dans les systèmes multi-GPU, optimisant 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 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 faibles

Cette fonctionnalité est particulièrement précieuse dans les environnements de calcul partagés ou lors de l'exécution de plusieurs travaux d'entraînement sur différents modèles. Elle s'adapte automatiquement aux conditions changeantes du système, garantissant 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 framework puissant 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 périphérique lors du lancement du processus d'entraînement. Voici un exemple de comment tu peux le faire 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")

Tout en tirant parti de 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, veuillez te référer à la documentation PyTorch MPS.

Reprise des entraînements interrompus

Reprendre l'entraînement à partir d'un état précédemment enregistré est une fonctionnalité cruciale lors du travail avec des modèles de deep learning. Cela peut être utile dans divers scénarios, comme 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 pour plus d'epochs.

Lorsque l'entraînement est repris, Ultralytics YOLO charge les poids du dernier modèle enregistré et restaure également l'état de l'optimiseur, le planificateur de learning rate et le numéro d'epoch. Cela te permet de poursuivre le processus d'entraînement de manière transparente là où il a été interrompu.

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

Voici un exemple de comment reprendre un entraînement interrompu en 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 réglant resume=True, la fonction train continuera l'entraînement là où il s'est arrêté, en utilisant l'état stocké dans le fichier 'path/to/last.pt'. Si l'argument resume est omis ou réglé sur False, la fonction train démarrera une nouvelle session d'entraînement.

N'oublie pas que les points de contrôle sont enregistrés à la fin de chaque epoch par défaut, ou à des intervalles fixes en utilisant l'argument save_period, tu dois donc terminer au moins 1 epoch pour reprendre une exécution d'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 de lot (batch size), le taux d'apprentissage (learning rate), le momentum et la décroissance du poids (weight decay). 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 impacter le processus. Un réglage minutieux et des expérimentations avec ces paramètres sont cruciaux pour optimiser les performances.

Optimiseur MuSGD

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

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

Seuls les paramètres avec param.ndim >= 2 (tels que les poids convolutifs) reçoivent la mise à jour de style Muon avec SGD, tandis que les paramètres de dimension inférieure comme les couches de normalisation par lots (batch normalization) 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 les itérations > 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 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 le modèle à mieux se généraliser aux données inconnues. Le tableau suivant décrit 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 en cours. Expérimenter avec différentes valeurs peut aider à trouver la stratégie d'augmentation optimale menant aux meilleures performances du modèle.

Journalisation

Lors de l'entraînement d'un modèle YOLO26, il peut être précieux de suivre les performances du modèle au fil du temps. C'est là que la journalisation intervient. Ultralytics YOLO prend en charge trois types d'enregistreurs - Comet, ClearML et TensorBoard.

Pour utiliser un enregistreur, sélectionne-le dans le menu déroulant du snippet de code ci-dessus et exécute-le. L'enregistreur 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 pour obtenir ta clé API. Tu devras l'ajouter à tes variables d'environnement ou à ton script pour enregistrer tes expériences.

ClearML

ClearML est une plateforme open-source qui automatise le suivi des expériences et aide à partager efficacement les 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 un kit d'outils de visualisation pour TensorFlow. Il te permet de visualiser ton graphe TensorFlow, de tracer des métriques quantitatives sur l'exécution de ton graphe et d'afficher des données supplémentaires comme les images qui y passent.

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 enregistreur, tu peux procéder à l'entraînement de ton modèle. Toutes les métriques d'entraînement seront automatiquement enregistré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 points à améliorer.

FAQ

Puis-je entraîner sans GPU local ?

Oui. Ultralytics Platform prend en charge l'entraînement dans le cloud avec des crédits gratuits pour démarrer. Télécharge ton jeu de données, sélectionne un modèle et un GPU, puis entraîne directement depuis le navigateur. Consulte le guide d'entraînement cloud pour plus de détails.

Comment entraîner un modèle de détection d'objets en utilisant Ultralytics YOLO26 ?

Pour entraîner un modèle de détection d'objets avec Ultralytics YOLO26, tu peux utiliser l'API Python ou la CLI. Voici un exemple pour les deux :

from ultralytics import YOLO

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

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

Pour plus de détails, réfère-toi à la section Paramètres d'entraînement.

Quelles sont les fonctionnalités clés du mode Entraînement d'Ultralytics YOLO26 ?

Les fonctionnalités clés du mode Entraînement d'Ultralytics YOLO26 incluent :

• Téléchargement automatique de jeux de données : Télécharge automatiquement des jeux de données standards comme COCO, VOC et ImageNet.
• Support multi-GPU : Échelle l'entraînement sur plusieurs GPU pour un traitement plus rapide.
• Configuration des hyperparamètres : Personnalise les hyperparamètres via des fichiers YAML ou des arguments CLI.
• Visualisation et surveillance : Suivi en temps réel des métriques d'entraînement pour de meilleures analyses.

Ces fonctionnalités rendent l'entraînement efficace et personnalisable selon tes besoins. Pour plus de détails, voir la section Fonctionnalités clés du mode Entraînement.

Comment reprendre l'entraînement après une session interrompue dans Ultralytics YOLO26 ?

Pour reprendre l'entraînement à partir d'une session interrompue, règle l'argument resume sur True et spécifie le chemin vers le dernier point de contrôle enregistré.

from ultralytics import YOLO

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

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

Consulte la section Reprise des entraînements interrompus pour plus d'informations.

Comment entraîner un modèle sur un jeu de données déséquilibré ?

Le déséquilibre des classes survient lorsque certaines classes ont significativement moins d'exemples que d'autres dans tes données d'entraînement. Cela peut amener le modèle à moins bien performer sur les classes rares. Ultralytics YOLO prend en charge la pondération des classes via l'argument cls_pw pour résoudre ce problème.

L'argument cls_pw contrôle la puissance de pondération des classes basée sur la fréquence inverse des classes :

• cls_pw=0.0 (par défaut) : Désactive la pondération des classes
• cls_pw=1.0 : Applique une pondération complète par fréquence inverse
• Valeurs entre 0.0 et 1.0 : Fournissent une pondération partielle pour un déséquilibre modéré

Les poids des classes sont calculés comme (1.0 / class_counts) ^ cls_pw et normalisés pour que leur moyenne soit égale à 1.0.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n.pt")

# Train with full class weighting for severely imbalanced data
results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0)

# Or use partial weighting (0.25) for moderate imbalance
results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)

Puis-je entraîner des modèles YOLO26 sur des puces Apple Silicon ?

Oui, Ultralytics YOLO26 prend en charge l'entraînement sur des puces Apple Silicon en utilisant le framework Metal Performance Shaders (MPS). Spécifie 'mps' comme périphérique d'entraînement.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n.pt")

# Train the model on Apple silicon chip (M1/M2/M3/M4)
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Pour plus de détails, réfère-toi à la section Entraînement MPS Apple Silicon.

Quels sont les paramètres d'entraînement courants et comment les configurer ?

Ultralytics YOLO26 te permet de configurer divers paramètres d'entraînement tels que la taille de lot, le taux d'apprentissage, les époques, et plus, via des arguments. Voici un bref aperçu :

Pour un guide approfondi sur les paramètres d'entraînement, consulte la section Paramètres d'entraînement.