Modèle de formation avec Ultralytics YOLO

Introduction

Former un modèle d'apprentissage profond consiste à lui fournir des données et à ajuster ses paramètres afin qu'il puisse faire des prédictions précises. Le mode Train sur Ultralytics YOLO11 est conçu pour une formation efficace et efficiente 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 tu as besoin pour commencer à former tes propres modèles en utilisant l'ensemble robuste de fonctionnalités de YOLO11.

Regarde : Comment former un modèle YOLO sur ton jeu de données personnalisé dans Google Colab.

Pourquoi choisir Ultralytics YOLO pour la formation ?

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

• Efficacité : Tire le meilleur parti de ton matériel, qu'il s'agisse d'une configuration à une seule adresseGPU ou d'une mise à l'échelle de plusieurs GPU.
• Polyvalence : Entraîne-toi sur des ensembles de données personnalisés en plus de ceux qui sont déjà disponibles comme COCO, VOC et ImageNet.
• Convivialité : interfaces simples mais puissantes CLI et Python pour une expérience de formation directe.
• Flexibilité des hyperparamètres : Un large éventail d'hyperparamètres personnalisables pour affiner les performances du modèle.

Principales caractéristiques du mode train

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

• Téléchargement automatique des 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 de plusieurs sitesGPU : Fais évoluer tes efforts de formation de façon transparente sur plusieurs GPU pour accélérer le processus.
• Configuration des hyperparamètres : La possibilité de modifier les hyperparamètres par le biais de fichiers de configuration YAML ou d'arguments CLI .
• Visualisation et suivi : Suivi en temps réel des métriques de formation et visualisation du processus d'apprentissage pour une meilleure compréhension.

Exemples d'utilisation

Entraîne YOLO11n sur l'ensemble de données COCO8 pour 100 époques à la taille de l'image 640. Le dispositif d'entraînement peut être spécifié à l'aide de la fonction device argument. Si aucun argument n'est transmis GPU device=0 sera utilisée si elle est disponible, sinon device='cpu' sera utilisé. Voir la section Arguments ci-dessous pour une liste complète des arguments de formation.

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

Formation multi-GPU

L'entraînement multi-GPU permet d'utiliser plus efficacement les ressources matérielles disponibles en répartissant la charge d'entraînement sur plusieurs GPU. Cette fonction est disponible à la fois via l'API Python et l'interface de ligne de commande. Pour activer l'entraînement multiGPU , spécifie les ID de périphériques GPU que tu souhaites 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])

# 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

Formation Apple Silicon MPS

Grâce à la prise en charge des puces de silicium Apple intégrées dans les modèles Ultralytics YOLO , il est désormais possible d'entraîner tes modèles sur des appareils utilisant le puissant cadre Metal Performance Shaders (MPS). Le site MPS offre un moyen très performant d'exécuter des tâches de calcul et de traitement d'images sur le silicium personnalisé d'Apple.

Pour activer la formation sur les puces en silicium d'Apple, tu dois spécifier 'mps' comme appareil lorsque tu démarres le processus de formation. Tu trouveras ci-dessous un exemple de la façon dont tu peux procéder dans 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 en silicium d'Apple, 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, tu peux te référer à la documentation dePyTorch MPS .

Reprise des formations interrompues

La reprise de l'entraînement à partir d'un état précédemment sauvegardé est une fonctionnalité cruciale lorsqu'on travaille avec des modèles d'apprentissage profond. Cela peut s'avérer pratique dans différents scénarios, comme 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 pour plus d'époques.

Lorsque la formation reprend, Ultralytics YOLO charge les poids du dernier modèle sauvegardé et restaure également l'état de l'optimiseur, le planificateur du taux d'apprentissage et le nombre d'époques. Cela te permet de reprendre le processus d'apprentissage là où il s'est arrêté.

Tu peux facilement reprendre la formation sur Ultralytics YOLO en paramétrant l'option resume argument pour True lors de l'appel du train et en spécifiant le chemin d'accès à la méthode .pt contenant les poids du modèle partiellement entraîné.

Tu trouveras ci-dessous un exemple de reprise d'un entraînement interrompu à l'aide de 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 réglant resume=True, le train reprend l'entraînement là où il s'est arrêté, en utilisant l'état stocké dans le fichier 'path/to/last.pt'. Si le fichier resume est omis ou a la valeur False, le train démarre une nouvelle session de formation.

Rappelle-toi que les points de contrôle sont sauvegardés à la fin de chaque époque par défaut, ou à intervalles fixes à l'aide de l'option save_period Tu dois donc terminer au moins une époque pour reprendre un entraînement.

Réglages du train

Les paramètres de formation des modèles YOLO englobent divers hyperparamètres et configurations utilisés pendant le processus de formation. Ces paramètres influencent les performances, la vitesse et la précision du modèle. Les principaux paramètres de formation comprennent la taille du lot, le taux d'apprentissage, l'élan et la décroissance des poids. En outre, le choix de l'optimiseur, de la fonction de perte et de la composition de l'ensemble des données d'apprentissage peut avoir un impact sur le processus d'apprentissage. Un réglage minutieux et l'expérimentation de 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'apprentissage, ce qui aide le modèle à mieux se généraliser à 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 de l'ensemble de données et de la tâche à accomplir. L'expérimentation de différentes valeurs peut aider à trouver la stratégie d'augmentation optimale qui conduit aux meilleures performances du modèle.

Enregistrement

Lors de l'entraînement d'un modèle YOLO11, tu peux trouver intéressant 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'enregistreurs - Comet, ClearML, et TensorBoard.

Pour utiliser un enregistreur, sélectionne-le dans le menu déroulant de l'extrait de code ci-dessus et exécute-le. Le logger choisi sera installé et initialisé.

Comet

Comet est une plateforme qui permet aux scientifiques des données 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 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 et d'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 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 sur le navigateur et authentifier ta session.

TensorBoard

TensorBoard est une boîte à outils de visualisation pour TensorFlow. Il te permet de visualiser ton graphique TensorFlow , de tracer des mesures quantitatives sur l'exécution de ton graphique et d'afficher des données supplémentaires comme les images qui le traversent.

Pour utiliser TensorBoard sur Google Colab:

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

Pour utiliser TensorBoard localement, exécute la commande ci-dessous et affiche les résultats sur http://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 ensuite procéder à l'entraînement de ton modèle. Tous les paramètres d'entraînement seront automatiquement consignés dans la plateforme que tu as choisie, et tu pourras accéder à ces journaux pour suivre les performances de ton modèle au fil du temps, comparer différents modèles et identifier les domaines à améliorer.

FAQ

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

Pour entraîner un modèle de détection d'objets à l'aide de Ultralytics YOLO11, tu peux utiliser l'API Python ou CLI. Tu trouveras 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, reporte-toi à la section Paramètres du train.

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

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

• Téléchargement automatique d'ensembles de données : Télécharge automatiquement les ensembles de données standard tels que COCO, VOC et ImageNet.
• Prise en charge de plusieurs sitesGPU : Met l'entraînement à l'échelle sur plusieurs GPU pour un traitement plus rapide.
• Configuration des hyperparamètres : Personnalise les hyperparamètres à l'aide de fichiers YAML ou d'arguments CLI .
• Visualisation et suivi : Suivi en temps réel des métriques de formation pour une meilleure compréhension.

Ces caractéristiques rendent la formation efficace et personnalisable en fonction de tes besoins. Pour plus de détails, voir la section Caractéristiques principales du mode entraînement.

Comment reprendre la formation après une session interrompue sur Ultralytics YOLO11 ?

Pour reprendre l'entraînement à partir d'une session interrompue, règle l'option resume argument pour True et spécifie le chemin d'accès au dernier point de contrôle sauvegardé.

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

Consulte la section sur la reprise des formations interrompues pour plus d'informations.

Puis-je entraîner les modèles YOLO11 sur les puces de silicium d'Apple ?

Oui, Ultralytics YOLO11 prend en charge la formation sur les puces de silicium d'Apple utilisant le cadre Metal Performance Shaders (MPS). Spécifie 'mps' comme dispositif de formation.

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, reporte-toi à la section Formation Apple Silicon MPS .

Quels sont les paramètres de formation courants et comment les configurer ?

Ultralytics YOLO11 te permet de configurer une variété de paramètres d'entraînement tels que la taille du lot, le taux d'apprentissage, les époques, et plus encore, par le biais d'arguments. En voici un bref aperçu :

Pour un guide approfondi sur les paramètres de formation, consulte la section Paramètres de formation.

📅 C réé il y a 1 an ✏️ Mis à jour il y a 16 jours

Commentaires