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 pour qu'il puisse faire des prédictions précises. Le mode Train dans Ultralytics YOLOv8 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 à l'aide de l'ensemble robuste de fonctionnalités de YOLOv8.

Regarde : Comment former un modèle YOLOv8 sur ton ensemble 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 YOLOv8:

• Efficacité : Tire le meilleur parti de ton matériel, qu'il s'agisse d'une configuration à un seul GPU 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 YOLOv8:

• 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 multi-GPU : 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 YOLOv8n sur l'ensemble de données COCO8 pour 100 époques à une taille d'image de 640. Le dispositif d'entraînement peut être spécifié à l'aide de l'option 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('yolov8n.yaml')  # build a new model from YAML
model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
model = YOLO('yolov8n.yaml').load('yolov8n.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=yolov8n.yaml epochs=100 imgsz=640

# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolov8n.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=yolov8n.yaml pretrained=yolov8n.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 via l'API Python et l'interface de ligne de commande. Pour activer l'entraînement multi-GPU, spécifie les ID de périphériques GPU que tu souhaites utiliser.

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.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=yolov8n.pt epochs=100 imgsz=640 device=0,1

Formation Apple M1 et M2 MPS

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

Pour activer la formation sur les puces Apple M1 et M2, tu dois spécifier 'mps' comme appareil lorsque tu lances 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('yolov8n.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='mps')

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

Tout en tirant parti de la puissance de calcul des puces M1/M2, cela permet un traitement plus efficace des tâches de formation. 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 à intervalle fixe à 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 la formation d'un modèle YOLOv8 , il peut être 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'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 métriques quantitatives sur l'exécution de ton graphique, et de montrer 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 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.

Commentaires