Link to this sectionEntraînement de modèle avec Ultralytics YOLO#

Link to this sectionIntroduction#

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 dans Ultralytics YOLO26 est conçu pour un entraînement efficace et performant des modèles de détection d'objets, en utilisant pleinement les capacités du matériel moderne. Ce guide a pour but de 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.

Link to this sectionPourquoi 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 trainer lui-même.
• Entraînement dans le cloud : Entraîne sur des GPU cloud via Ultralytics Platform avec des métriques en temps réel et une sauvegarde automatique des points de contrôle.

Link to this sectionFonctionnalités clés du mode Train#

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

• Téléchargement automatique du jeu de données : Les jeux de données standard 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 perspectives.

Link to this sectionExemples d'utilisation#

Entraîne YOLO26n sur le jeu de données COCO8 pendant 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é lorsqu'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)

Link to this sectionEntraî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

Link to this sectionEntraî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.

Link to this sectionEntraî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")

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.

Link to this sectionReprise 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 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 s'est arrêté.

Tu peux facilement reprendre l'entraînement dans Ultralytics YOLO en réglant l'argument resume sur True lors de l'appel de la méthode train, et en spécifiant le chemin vers le 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 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, donc tu dois compléter au moins 1 epoch pour reprendre une exécution d'entraînement.

Link to this sectionParamè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 l'accuracy du modèle. Les paramètres d'entraînement clés incluent la taille de batch, le taux d'apprentissage, le momentum et la décroissance du poids. De plus, le choix de l'optimiseur, de la loss function et de la composition du jeu de données d'entraînement peut impacter le processus d'entraînement. Un réglage minutieux et l'expérimentation avec ces paramètres sont cruciaux pour optimiser les performances.

Link to this sectionOptimiseur 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 paramètres avec param.ndim >= 2 (tels que les poids de convolution) reçoivent la mise à jour de style Muon avec SGD, tandis que les paramètres de dimension inférieure comme les couches de normalisation de batch 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 exécutions plus courtes, 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 d'auto-sélection de l'optimiseur dans BaseTrainer.build_optimizer.

Link to this sectionParamè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 training data, aidant le modèle à mieux généraliser à des données non vues. 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 à accomplir. Expérimenter avec différentes valeurs peut aider à trouver la stratégie d'augmentation optimale menant à la meilleure performance du modèle.

Link to this sectionJournalisation#

Lors de l'entraînement d'un modèle YOLO26, tu pourrais trouver utile de suivre les performances du modèle au fil du temps. C'est là que la journalisation entre en jeu. Ultralytics YOLO prend en charge trois types d'outils de journalisation - 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é.

Link to this sectionComet#

Comet est une plateforme qui permet aux data scientists et aux développeurs de suivre, comparer, expliquer et optimiser leurs expériences et modèles. Elle fournit des fonctionnalités telles que des métriques en temps réel, des diffs 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.

Link to this sectionClearML#

ClearML est une plateforme open-source qui automatise le suivi des expériences et aide au 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.

Link to this sectionTensorBoard#

TensorBoard est une boîte à outils de visualisation pour TensorFlow. Elle te permet de visualiser ton graphe TensorFlow, de tracer des métriques quantitatives sur l'exécution de ton graphe et de montrer 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 visualise 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.

Link to this sectionFAQ#

Link to this sectionPuis-je entraîner sans GPU local ?#

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

Link to this sectionComment 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 en utilisant Ultralytics YOLO26, tu peux utiliser soit l'API Python, soit 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, consulte la section Paramètres d'entraînement.

Link to this sectionQuelles sont les fonctionnalités clés du mode Entraînement (Train) d'Ultralytics YOLO26 ?#

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

• Téléchargement automatique du jeu de données : Télécharge automatiquement les jeux de données standard comme COCO, VOC et ImageNet.
• Prise en charge multi-GPU : Échelonne 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 suivi : 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, consulte la section Fonctionnalités clés du mode Entraînement.

Link to this sectionComment reprendre un entraînement à partir d'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 sur la Reprise des entraînements interrompus pour plus d'informations.

Link to this sectionComment 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 entraîner une mauvaise performance du modèle 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 basée sur la fréquence inverse totale
• 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)

Link to this sectionPuis-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, consulte la section Entraînement MPS Apple Silicon.

Link to this sectionQuels sont les paramètres d'entraînement courants et comment les configurer ?#

Ultralytics YOLO26 te permet de configurer une variété de paramètres d'entraînement tels que la taille de lot (batch size), le taux d'apprentissage (learning rate), les époques et plus encore via des arguments. Voici un bref aperçu :

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