Entraînement de modèles avec Ultralytics YOLO

Introduction

L'entraînement d'un modèle de deep learning implique de lui fournir des données et d'ajuster ses paramètres afin qu'il puisse faire des prédictions précises. Le mode Train d'Ultralytics YOLO11 est conçu pour un entraînement efficace des modèles de détection d'objets, en utilisant pleinement les capacités du matériel moderne. Ce guide vise à couvrir tous les détails dont vous avez besoin pour commencer à entraîner vos propres modèles en utilisant l'ensemble robuste de fonctionnalités de YOLO11.

Regarder : Comment entraîner un modèle YOLO sur votre ensemble de données personnalisé dans Google Colab.

Pourquoi choisir Ultralytics YOLO pour l'entraînement ?

Voici quelques raisons impérieuses d'opter pour le mode Train de YOLO11 :

• Efficacité : Tirez le meilleur parti de votre matériel, que vous soyez sur une configuration à GPU unique ou que vous évoluiez sur plusieurs GPU.
• Polyvalence : Entraînez-vous sur des ensembles de données personnalisés en plus de ceux disponibles comme COCO, VOC et ImageNet.
• Facilité d'utilisation : Interfaces CLI et python simples mais puissantes pour une expérience d'entraînement simple.
• Flexibilité des hyperparamètres : Une large gamme d'hyperparamètres personnalisables pour affiner les performances du modèle.

Principales caractéristiques du mode d'entraînement

Voici quelques caractéristiques notables du mode Train de YOLO11 :

• Téléchargement automatique de l'ensemble de données : Les ensembles de données standard tels que COCO, VOC et ImageNet sont téléchargés automatiquement lors de la première utilisation.
• Prise en charge multi-GPU : Faites évoluer vos efforts de formation de manière transparente sur plusieurs GPU pour 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 surveillance : Suivi en temps réel des mesures d'entraînement et visualisation du processus d'apprentissage pour de meilleures informations.

Exemples d'utilisation

Entraînez YOLO11n sur l'ensemble de données COCO8 pour 100 epochs à la taille d'image 640. Le dispositif d'entraînement peut être spécifié en utilisant l' device argument. Si aucun argument n'est passé GPU device=0 sera utilisé s'il est disponible, sinon device='cpu' sera utilisé. Consultez la section Arguments ci-dessous pour une liste complète des arguments d'entraînement.

from ultralytics import YOLO

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

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

# Build a new model from YAML and start training from scratch
yolo detect train data=coco8.yaml model=yolo11n.yaml epochs=100 imgsz=640

# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640

# Build a new model from YAML, transfer pretrained weights to it and start training
yolo detect train data=coco8.yaml model=yolo11n.yaml pretrained=yolo11n.pt 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 de ligne de commande. Pour activer l'entraînement multi-GPU, spécifiez les ID des périphériques GPU que vous souhaitez utiliser.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.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])

# Start training from a pretrained *.pt model using GPUs 0 and 1
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=0,1

# Use the two most idle GPUs
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=-1,-1

Entraînement GPU inactif

L'entraînement GPU inactif permet la sélection automatique des GPU les moins utilisés dans les systèmes multi-GPU, optimisant ainsi 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("yolov8n.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])

# Start training using the single most idle GPU
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=-1

# Start training using the two most idle GPUs
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=-1,-1

L'algorithme de sélection automatique priorise les GPU avec :

1. Pourcentages d'utilisation du courant inférieurs
2. Plus de mémoire disponible (VRAM libre)
3. Température et consommation d'énergie plus faibles

Cette fonctionnalité est particulièrement intéressante 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, garantissant une allocation optimale des ressources sans intervention manuelle.

Entraînement Apple Silicon MPS

Grâce à la prise en charge des puces Apple Silicon intégrées dans les modèles Ultralytics YOLO, il est désormais possible d'entraîner vos modèles sur des appareils utilisant le puissant framework Metal Performance Shaders (MPS). Le MPS offre un moyen performant 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, vous devez spécifier 'mps' comme périphérique lors du lancement du processus d'entraînement. Vous trouverez ci-dessous un exemple de la manière dont vous pouvez le faire en python et via la ligne de commande :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.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")

# Start training from a pretrained *.pt model using MPS
yolo detect train data=coco8.yaml model=yolo11n.pt 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 consulter la documentation PyTorch MPS.

Reprise des entraînements interrompus

La reprise de l'entraînement à partir d'un état précédemment enregistré est une fonctionnalité essentielle lorsque vous travaillez avec des modèles d'apprentissage profond. 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 vous souhaitez continuer à entraîner un modèle avec de nouvelles données ou pour plus d'époques.

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 taux d'apprentissage et le numéro d'époque. Cela vous permet de poursuivre le processus d'entraînement de manière transparente là où il avait été interrompu.

Vous pouvez 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é.

Vous trouverez ci-dessous un exemple de la manière 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)

# Resume an interrupted training
yolo train resume model=path/to/last.pt

En définissant resume=True, la fonction train continuera 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 la fonction lancera une nouvelle session d'entraînement.

N'oubliez pas que les points de contrôle sont sauvegardés par défaut à la fin de chaque époque, ou à intervalles fixes à l'aide de l'argument save_period , vous devez donc effectuer au moins 1 époque 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 du lot, le taux d'apprentissage, le moment et la décroissance du poids. De plus, le choix de l'optimiseur, de la fonction de perte et de la composition de l'ensemble de données d'entraînement peut avoir un impact sur le processus d'entraînement. Un réglage et une expérimentation minutieux avec ces paramètres sont essentiels pour optimiser les performances.

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, ce qui aide le modèle à mieux se généraliser aux données non vues. Le tableau suivant décrit le but et l'effet de chaque argument d'augmentation :

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

Journalisation

Lors de l'entraînement d'un modèle YOLO11, vous pourriez 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 de loggers : Comet, ClearML et TensorBoard.

Pour utiliser un logger, sélectionnez-le dans le menu déroulant de l'extrait de code ci-dessus et exécutez-le. Le logger 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 les expériences et les modèles. Elle offre des fonctionnalités telles que les métriques en temps réel, les diffs de code et le suivi des hyperparamètres.

Pour utiliser Comet :

# pip install comet_ml
import comet_ml

comet_ml.init()

N'oubliez pas de vous connecter à votre compte Comet sur leur site web et d'obtenir votre clé API. Vous devrez l'ajouter à vos variables d'environnement ou à votre script pour enregistrer vos 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, vous devrez vous connecter à votre compte ClearML sur le navigateur et authentifier votre session.

TensorBoard

TensorBoard est une boîte à outils de visualisation pour TensorFlow. Il vous permet de visualiser votre graphe TensorFlow, de tracer des métriques quantitatives sur l'exécution de votre 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écutez la commande ci-dessous et visualisez les résultats à l'adresse http://localhost:6006/.

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

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

Après avoir configuré votre logger, vous pouvez ensuite procéder à l'entraînement de votre modèle. Toutes les métriques d'entraînement seront automatiquement enregistrées dans la plateforme de votre choix, et vous pourrez accéder à ces journaux pour surveiller les performances de votre modèle au fil du temps, comparer différents modèles et identifier les points à améliorer.

FAQ

Comment entraîner un modèle de détection d'objets à l'aide d'Ultralytics YOLO11 ?

Pour entraîner un modèle de détection d'objets à l'aide d'Ultralytics YOLO11, vous pouvez utiliser l'API python ou la CLI. Vous trouverez ci-dessous un exemple pour les deux :

from ultralytics import YOLO

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

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

yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640

Pour plus de détails, consultez la section Paramètres d'entraînement.

Quelles sont les principales caractéristiques du mode Train d'Ultralytics YOLO11 ?

Les principales caractéristiques du mode Train d'Ultralytics YOLO11 sont les suivantes :

• Téléchargement automatique de l'ensemble de données : Télécharge automatiquement les ensembles de données standard tels que COCO, VOC et ImageNet.
• Prise en charge multi-GPU : Faites évoluer l’entraînement sur plusieurs GPU pour un traitement plus rapide.
• Configuration des hyperparamètres : Personnalisez les hyperparamètres via des fichiers YAML ou des arguments de la CLI.
• Visualisation et surveillance : Suivi en temps réel des mesures d’entraînement pour de meilleures informations.

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

Comment reprendre l'entraînement après une interruption de session dans Ultralytics YOLO11 ?

Pour reprendre l’entraînement à partir d’une session interrompue, définissez le paramètre resume sur True et spécifiez le chemin d’accès au 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)

yolo train resume model=path/to/last.pt

Consultez la section sur la Reprise des entraînements interrompus pour plus d’informations.

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

Oui, Ultralytics YOLO11 prend en charge l’entraînement sur les puces Apple Silicon à l’aide du framework Metal Performance Shaders (MPS). Spécifiez « mps » comme périphérique d’entraînement.

from ultralytics import YOLO

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

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

yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=mps

Pour plus de détails, consultez la section Entraînement MPS sur Apple Silicon.

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

Ultralytics YOLO11 vous permet de configurer divers paramètres d’entraînement tels que la taille de lot, le taux d’apprentissage, le nombre d’époques, etc. via des arguments. Voici un bref aperçu :

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

📅 Créé il y a 1 an ✏️ Mis à jour il y a 2 mois

Commentaires