Skip to content

Modèle de formation avec Ultralytics YOLO

Ultralytics YOLO écosystème et intégrations

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 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.

Astuce

  • YOLOv8 Les ensembles de donnĂ©es tels que COCO, VOC, ImageNet et bien d'autres se tĂ©lĂ©chargent automatiquement lors de la première utilisation, c'est-Ă -dire... yolo train data=coco.yaml

Exemples d'utilisation

Entraîne YOLOv8n sur l'ensemble de données COCO128 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é s'il est disponible, sinon device=cpu sera utilisé. Voir la section Arguments ci-dessous pour une liste complète des arguments de formation.

Exemple de formation avec un seul processeur et une seule unité centrale

Le périphérique est déterminé automatiquement. Si un GPU est disponible, il sera utilisé, sinon la formation commencera sur le CPU.

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='coco128.yaml', epochs=100, imgsz=640)
# Build a new model from YAML and start training from scratch
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640

# Start training from a pretrained *.pt model
yolo detect train data=coco128.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=coco128.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.

Exemple de formation multi-GPU

Pour s'entraîner avec 2 GPU, les périphériques CUDA 0 et 1, utilise les commandes suivantes. Étends-toi à d'autres GPU si nécessaire.

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='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
# Start training from a pretrained *.pt model using GPUs 0 and 1
yolo detect train data=coco128.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 :

Exemple de formation MPS

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='coco128.yaml', epochs=100, imgsz=640, device='mps')
# Start training from a pretrained *.pt model using GPUs 0 and 1
yolo detect train data=coco128.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 :

Exemple de formation au curriculum vitae

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.

Argument DĂ©faut Description
model None Spécifie le fichier modèle pour la formation. Accepte un chemin vers un fichier .pt modèle pré-entraîné ou un .yaml fichier de configuration. Indispensable pour définir la structure du modèle ou initialiser les poids.
data None Chemin d'accès au fichier de configuration du jeu de données (par ex, coco128.yaml). Ce fichier contient des paramètres spécifiques au jeu de données, notamment les chemins d'accès aux données d'entraînement et de validation, les noms des classes et le nombre de classes.
epochs 100 Nombre total d'époques de formation. Chaque époque représente un passage complet sur l'ensemble des données. Le réglage de cette valeur peut affecter la durée de la formation et les performances du modèle.
time None Durée maximale de la formation en heures. S'il est défini, ce paramètre remplace le paramètre epochs permettant à la formation de s'arrêter automatiquement après la durée spécifiée. Utile pour les scénarios de formation limités dans le temps.
patience 100 Nombre d'époques à attendre sans amélioration des mesures de validation avant d'arrêter la formation. Permet d'éviter le surajustement en arrêtant la formation lorsque les performances atteignent un plateau.
batch 16 Taille du lot pour l'entraînement, indiquant combien d'images sont traitées avant que les paramètres internes du modèle ne soient mis à jour. AutoBatch (batch=-1) ajuste dynamiquement la taille du lot en fonction de la disponibilité de la mémoire du GPU.
imgsz 640 Taille cible de l'image pour la formation. Toutes les images sont redimensionnées à cette dimension avant d'être introduites dans le modèle. Affecte la précision du modèle et la complexité de calcul.
save True Permet d'enregistrer les points de contrôle de l'entraînement et les poids finaux du modèle. Utile pour reprendre la formation ou le déploiement du modèle.
save_period -1 Fréquence de sauvegarde des points de contrôle du modèle, spécifiée en époques. La valeur -1 désactive cette fonction. Utile pour sauvegarder des modèles provisoires pendant de longues sessions de formation.
cache False Permet la mise en cache des images du jeu de données dans la mémoire (True/ram), sur disque (disk), ou la désactive (False). Améliore la vitesse de l'entraînement en réduisant les entrées/sorties sur disque au prix d'une utilisation accrue de la mémoire.
device None Spécifie le(s) dispositif(s) de calcul pour la formation : un seul GPU (device=0), plusieurs GPU (device=0,1), CPU (device=cpu), ou MPS pour le silicium d'Apple (device=mps).
workers 8 Nombre de threads de travail pour le chargement des données (par RANK si formation multi-GPU). Influence la vitesse de prétraitement des données et d'alimentation du modèle, particulièrement utile dans les configurations multi-GPU.
project None Nom du répertoire du projet dans lequel les résultats de la formation sont enregistrés. Permet un stockage organisé des différentes expériences.
name None Nom de la formation. Utilisé pour créer un sous-répertoire dans le dossier du projet, où sont stockés les journaux de formation et les résultats.
exist_ok False Si True, permet d'écraser un répertoire projet/nom existant. Utile pour l'expérimentation itérative sans avoir besoin d'effacer manuellement les sorties précédentes.
pretrained True Détermine s'il faut commencer la formation à partir d'un modèle pré-entraîné. Il peut s'agir d'une valeur booléenne ou d'un chemin d'accès à un modèle spécifique à partir duquel les poids sont chargés. Améliore l'efficacité de la formation et les performances du modèle.
optimizer 'auto' Choix de l'optimiseur pour la formation. Les options comprennent SGD, Adam, AdamW, NAdam, RAdam, RMSProp etc. auto pour une sélection automatique basée sur la configuration du modèle. Affecte la vitesse de convergence et la stabilité.
verbose False Active la sortie verbale pendant l'entraînement, fournissant des journaux détaillés et des mises à jour de la progression. Utile pour déboguer et surveiller de près le processus de formation.
seed 0 Définit la graine aléatoire pour l'entraînement, ce qui garantit la reproductibilité des résultats d'un cycle à l'autre avec les mêmes configurations.
deterministic True Force l'utilisation d'algorithmes déterministes, ce qui garantit la reproductibilité, mais peut affecter les performances et la vitesse en raison de la restriction sur les algorithmes non déterministes.
single_cls False Traite toutes les classes des ensembles de données multi-classes comme une seule classe pendant la formation. Utile pour les tâches de classification binaire ou lorsque l'on se concentre sur la présence d'objets plutôt que sur la classification.
rect False Permet un entraînement rectangulaire, en optimisant la composition des lots pour un remplissage minimal. Cela peut améliorer l'efficacité et la vitesse, mais peut affecter la précision du modèle.
cos_lr False Utilise un planificateur de taux d'apprentissage en cosinus, qui ajuste le taux d'apprentissage en suivant une courbe en cosinus au fil des époques. Aide à gérer le taux d'apprentissage pour une meilleure convergence.
close_mosaic 10 Désactive l'augmentation des données de la mosaïque dans les N dernières époques pour stabiliser l'entraînement avant qu'il ne soit terminé. La valeur 0 désactive cette fonction.
resume False Reprend la formation à partir du dernier point de contrôle enregistré. Charge automatiquement les poids du modèle, l'état de l'optimiseur et le nombre d'époques, afin de poursuivre la formation de façon transparente.
amp True Permet l'apprentissage automatique de la précision mixte (AMP), ce qui réduit l'utilisation de la mémoire et accélère éventuellement l'apprentissage avec un impact minimal sur la précision.
fraction 1.0 Spécifie la fraction de l'ensemble de données à utiliser pour la formation. Permet la formation sur un sous-ensemble de l'ensemble des données, utile pour les expériences ou lorsque les ressources sont limitées.
profile False Permet d'établir le profil des vitesses ONNX et TensorRT pendant la formation, ce qui est utile pour optimiser le déploiement du modèle.
freeze None Gèle les N premières couches du modèle ou des couches spécifiées par index, réduisant ainsi le nombre de paramètres entraînables. Utile pour le réglage fin ou l'apprentissage par transfert.
lr0 0.01 Taux d'apprentissage initial (c'est-à-dire SGD=1E-2, Adam=1E-3) . L'ajustement de cette valeur est crucial pour le processus d'optimisation, car il influence la rapidité avec laquelle les poids du modèle sont mis à jour.
lrf 0.01 Taux d'apprentissage final en tant que fraction du taux initial = (lr0 * lrf), utilisés conjointement avec les programmateurs pour ajuster le taux d'apprentissage au fil du temps.
momentum 0.937 Facteur d'impulsion pour SGD ou beta1 pour les optimiseurs Adam, influençant l'incorporation des gradients passés dans la mise à jour actuelle.
weight_decay 0.0005 Terme de régularisation L2, pénalisant les poids importants pour éviter l'ajustement excessif.
warmup_epochs 3.0 Nombre d'époques pour l'échauffement du taux d'apprentissage, en augmentant progressivement le taux d'apprentissage à partir d'une faible valeur jusqu'au taux d'apprentissage initial pour stabiliser l'entraînement dès le début.
warmup_momentum 0.8 Élan initial pour la phase d'échauffement, s'ajustant progressivement à l'élan défini au cours de la période d'échauffement.
warmup_bias_lr 0.1 Taux d'apprentissage pour les paramètres de biais pendant la phase d'échauffement, ce qui permet de stabiliser l'apprentissage du modèle dans les époques initiales.
box 7.5 Poids de la composante de perte de boîte dans la fonction de perte, influençant l'importance accordée à la prédiction précise des coordonnées de la boîte englobante.
cls 0.5 Poids de la perte de classification dans la fonction de perte totale, affectant l'importance d'une prédiction de classe correcte par rapport aux autres composants.
dfl 1.5 Poids de la perte focale de distribution, utilisé dans certaines versions de YOLO pour une classification plus fine.
pose 12.0 Le poids de la perte de pose dans les modèles formés pour l'estimation de la pose, influençant l'accent mis sur la prédiction précise des points clés de la pose.
kobj 2.0 Poids de la perte d'objectivité du point clé dans les modèles d'estimation de la pose, équilibrant la confiance de la détection avec la précision de la pose.
label_smoothing 0.0 Applique le lissage des étiquettes, en adoucissant les étiquettes dures pour obtenir un mélange de l'étiquette cible et une distribution uniforme des étiquettes, ce qui peut améliorer la généralisation.
nbs 64 Taille nominale du lot pour la normalisation de la perte.
overlap_mask True Détermine si les masques de segmentation doivent se chevaucher pendant la formation, applicable dans les tâches de segmentation d'instances.
mask_ratio 4 Taux de sous-échantillonnage pour les masques de segmentation, affectant la résolution des masques utilisés pendant l'entraînement.
dropout 0.0 Taux d'abandon pour la régularisation dans les tâches de classification, empêchant le surajustement en omettant aléatoirement des unités pendant la formation.
val True Active la validation pendant la formation, ce qui permet d'évaluer périodiquement les performances du modèle sur un ensemble de données distinct.
plots False Génère et enregistre des graphiques des mesures d'entraînement et de validation, ainsi que des exemples de prédiction, ce qui donne un aperçu visuel des performances du modèle et de la progression de l'apprentissage.

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 :

Argument Type DĂ©faut Gamme Description
hsv_h float 0.015 0.0 - 1.0 Ajuste la teinte de l'image par une fraction de la roue chromatique, introduisant ainsi la variabilité des couleurs. Aide le modèle à se généraliser dans différentes conditions d'éclairage.
hsv_s float 0.7 0.0 - 1.0 Modifie la saturation de l'image d'une fraction, ce qui affecte l'intensité des couleurs. Utile pour simuler différentes conditions environnementales.
hsv_v float 0.4 0.0 - 1.0 Modifie la valeur (luminosité) de l'image d'une fraction, ce qui aide le modèle à bien fonctionner dans diverses conditions d'éclairage.
degrees float 0.0 -180 - +180 Fait pivoter l'image de façon aléatoire dans la plage de degrés spécifiée, ce qui améliore la capacité du modèle à reconnaître des objets dans diverses orientations.
translate float 0.1 0.0 - 1.0 Traduit l'image horizontalement et verticalement d'une fraction de la taille de l'image, ce qui facilite l'apprentissage de la détection d'objets partiellement visibles.
scale float 0.5 >=0.0 Met l'image à l'échelle en fonction d'un facteur de gain, simulant ainsi des objets situés à différentes distances de la caméra.
shear float 0.0 -180 - +180 Cisaille l'image d'un degré spécifié, imitant l'effet des objets vus sous différents angles.
perspective float 0.0 0.0 - 0.001 Applique une transformation aléatoire de la perspective à l'image, ce qui améliore la capacité du modèle à comprendre les objets dans l'espace 3D.
flipud float 0.0 0.0 - 1.0 Renverse l'image avec la probabilité spécifiée, ce qui augmente la variabilité des données sans affecter les caractéristiques de l'objet.
fliplr float 0.5 0.0 - 1.0 Retourne l'image de gauche à droite avec la probabilité spécifiée, utile pour apprendre les objets symétriques et augmenter la diversité des ensembles de données.
mosaic float 1.0 0.0 - 1.0 Combine quatre images d'entraînement en une seule, simulant ainsi différentes compositions de scènes et interactions d'objets. Très efficace pour la compréhension de scènes complexes.
mixup float 0.0 0.0 - 1.0 Mélange deux images et leurs étiquettes, créant ainsi une image composite. Améliore la capacité du modèle à se généraliser en introduisant le bruit de l'étiquette et la variabilité visuelle.
copy_paste float 0.0 0.0 - 1.0 Copie les objets d'une image et les colle sur une autre, ce qui est utile pour augmenter les instances d'objets et apprendre l'occlusion des objets.
auto_augment str randaugment - Applique automatiquement une politique d'augmentation prédéfinie (randaugment, autoaugment, augmix), optimisant les tâches de classification en diversifiant les caractéristiques visuelles.
erasing float 0.4 0.0 - 1.0 Efface de façon aléatoire une partie de l'image pendant l'entraînement à la classification, ce qui encourage le modèle à se concentrer sur les caractéristiques moins évidentes pour la reconnaissance.

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.

Info

Pour plus d'informations sur les opérations de renforcement de la formation, consulte la section de référence.

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:

Exemple

# 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:

Exemple

# 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:

Exemple

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/.

Exemple

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.



Créé le 2023-11-12, Mis à jour le 2024-02-25
Auteurs : Burhan-Q (1), Laughing-q (1), glenn-jocher (9)

Commentaires