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.
Astuce
- Les ensembles de données YOLO11 tels que COCO, VOC, ImageNet et bien d'autres sont automatiquement téléchargés lors de la première utilisation, c'est-à-dire
yolo train data=coco.yaml
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.
Erreur de multi-traitement Windows
Sous Windows, vous pouvez recevoir un RuntimeError
lors du lancement de l'entraînement en tant que script. Ajouter un if __name__ == "__main__":
bloquez avant votre code d'entraînement pour le résoudre.
Exemple d'entraînement sur un seul GPU et CPU
L'appareil est déterminé automatiquement. Si un GPU est disponible, il sera utilisé (appareil CUDA par défaut 0), sinon l'entraînement commencera sur le CPU.
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.
Exemple d'entraînement multi-GPU
Pour entraîner avec 2 GPU, les périphériques CUDA 0 et 1, utilisez les commandes suivantes. Étendez-vous à des GPU supplémentaires si nécessaire.
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.
Exemple d'entraînement GPU inactif
Pour sélectionner et utiliser automatiquement le(s) GPU(s) le(s) plus inactif(s) pour l'entraînement, utilisez le -1
paramètre device. Ceci est particulièrement utile dans les environnements informatiques partagés ou les serveurs avec plusieurs utilisateurs.
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 :
- Pourcentages d'utilisation du courant inférieurs
- Plus de mémoire disponible (VRAM libre)
- 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 :
Exemple d'entraînement MPS
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 :
Exemple de reprise d'entraînement
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.
Argument | Type | Par défaut | Description |
---|---|---|---|
model |
str |
None |
Spécifie le fichier de modèle pour l'entraînement. Accepte un chemin d'accès à un modèle .pt pré-entraîné ou à un fichier de .yaml configuration. Essentiel pour définir la structure du modèle ou initialiser les poids. |
data |
str |
None |
Chemin d'accès au fichier de configuration de l'ensemble de données (par exemple, coco8.yaml ). Ce fichier contient des paramètres spécifiques à l'ensemble de données, y compris les chemins d'accès aux données d'entraînement et de validation, les noms de classe et le nombre de classes. |
epochs |
int |
100 |
Nombre total d'époques d'entraînement. Chaque époque représente un passage complet sur l'ensemble de données. L'ajustement de cette valeur peut affecter la durée de l'entraînement et les performances du modèle. |
time |
float |
None |
Durée maximale de l'entraînement en heures. Si elle est définie, elle remplace l'argument epochs , permettant à l'entraînement de s'arrêter automatiquement après la durée spécifiée. Utile pour les scénarios d'entraînement à durée limitée. |
patience |
int |
100 |
Nombre d'époques à attendre sans amélioration des métriques de validation avant d'arrêter précocement l'entraînement. Aide à prévenir le surapprentissage en arrêtant l'entraînement lorsque les performances se stabilisent. |
batch |
int ou float |
16 |
Taille du lot, avec trois modes : défini comme un entier (par exemple, batch=16 ), mode automatique pour une utilisation de la mémoire GPU de 60 % (batch=-1 ), ou mode automatique avec une fraction d'utilisation spécifiée (batch=0.70 ). |
imgsz |
int |
640 |
Taille d'image cible pour l'entraînement. Les images sont redimensionnées en carrés dont les côtés sont égaux à la valeur spécifiée (si rect=False ), en conservant le rapport hauteur/largeur pour les modèles YOLO mais pas pour RTDETR. Affecte le modèle précision et la complexité de calcul. |
save |
bool |
True |
Permet de sauvegarder les points de contrôle d'entraînement et les poids finaux du modèle. Utile pour reprendre l'entraînement ou le déploiement du modèle. |
save_period |
int |
-1 |
Fréquence de sauvegarde des points de contrôle du modèle, spécifiée en époques. Une valeur de -1 désactive cette fonctionnalité. Utile pour sauvegarder les modèles intermédiaires pendant les longues sessions d'entraînement. |
cache |
bool |
False |
Permet de mettre en cache les images de l'ensemble de données en mémoire (True /ram ), sur le disque (disk ), ou le désactive (False ). Améliore la vitesse d'entraînement en réduisant les E/S disque au prix d'une utilisation accrue de la mémoire. |
device |
int ou str ou list |
None |
Spécifie le(s) périphérique(s) de calcul pour l'entraînement : un seul GPU (device=0 ), plusieurs GPU (device=[0,1] ), CPU (device=cpu ), MPS pour Apple Silicon (device=mps ), ou la sélection automatique du GPU le plus inactif (device=-1 ) ou plusieurs GPU inactifs (device=[-1,-1] ) |
workers |
int |
8 |
Nombre de threads de travail pour le chargement des données (par RANK si entraînement multi-GPU). Influe sur la vitesse de prétraitement des données et d'alimentation du modèle, particulièrement utile dans les configurations multi-GPU. |
project |
str |
None |
Nom du répertoire de projet où les sorties d'entraînement sont enregistrées. Permet un stockage organisé des différentes expériences. |
name |
str |
None |
Nom de l'exécution de l'entraînement. Utilisé pour créer un sous-répertoire dans le dossier du projet, où les journaux d'entraînement et les sorties sont stockés. |
exist_ok |
bool |
False |
Si True, permet de remplacer 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 |
bool ou str |
True |
Détermine s'il faut commencer l'entraînement à partir d'un modèle pré-entraîné. Peut être une valeur booléenne ou un chemin d'accès à un modèle spécifique à partir duquel charger les poids. Améliore l'efficacité de l'entraînement et les performances du modèle. |
optimizer |
str |
'auto' |
Choix de l'optimiseur pour l'entraînement. Les options incluent SGD , Adam , AdamW , NAdam , RAdam , RMSProp etc., ou auto pour une sélection automatique basée sur la configuration du modèle. Affecte la vitesse et la stabilité de la convergence. |
seed |
int |
0 |
Définit la graine aléatoire pour l'entraînement, assurant la reproductibilité des résultats entre les exécutions avec les mêmes configurations. |
deterministic |
bool |
True |
Force l'utilisation d'algorithmes déterministes, assurant la reproductibilité mais pouvant affecter les performances et la vitesse en raison de la restriction sur les algorithmes non déterministes. |
single_cls |
bool |
False |
Traite toutes les classes dans les ensembles de données multi-classes comme une seule classe pendant l'entraînement. 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. |
classes |
list[int] |
None |
Spécifie une liste d'identifiants de classe sur lesquels effectuer l'apprentissage. Utile pour filtrer et se concentrer uniquement sur certaines classes pendant l'entraînement. |
rect |
bool |
False |
Active la stratégie de remplissage minimum : les images d'un lot sont minimalement remplies pour atteindre une taille commune, le côté le plus long étant égal à imgsz . Peut améliorer l'efficacité et la vitesse, mais peut affecter la précision du modèle. |
multi_scale |
bool |
False |
Active l'entraînement multi-échelle en augmentant/diminuant imgsz par un facteur allant jusqu'à 0.5 pendant l'entraînement. Entraîne le modèle à être plus précis avec plusieurs imgsz pendant l'inférence. |
cos_lr |
bool |
False |
Utilise un planificateur de taux d'apprentissage cosinus, ajustant le taux d'apprentissage suivant une courbe cosinus sur les époques. Aide à gérer le taux d'apprentissage pour une meilleure convergence. |
close_mosaic |
int |
10 |
Désactive l'augmentation de données en mosaïque dans les N dernières époques pour stabiliser l'entraînement avant la fin. Définir sur 0 désactive cette fonctionnalité. |
resume |
bool |
False |
Reprend l'entraînement à 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, poursuivant l'entraînement de manière transparente. |
amp |
bool |
True |
Active l'entraînement en Précision Mixte Automatique (AMP), réduisant l'utilisation de la mémoire et accélérant potentiellement l'entraînement avec un impact minimal sur la précision. |
fraction |
float |
1.0 |
Spécifie la fraction de l'ensemble de données à utiliser pour l'entraînement. Permet de s'entraîner sur un sous-ensemble de l'ensemble de données complet, utile pour les expériences ou lorsque les ressources sont limitées. |
profile |
bool |
False |
Active le profilage des vitesses ONNX et TensorRT pendant l'entraînement, ce qui est utile pour optimiser le déploiement du modèle. |
freeze |
int ou list |
None |
Gèle les N premières couches du modèle ou les couches spécifiées par leur index, réduisant ainsi le nombre de paramètres entraînables. Utile pour l'affinage ou l'apprentissage par transfert. |
lr0 |
float |
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, influençant la rapidité avec laquelle les poids du modèle sont mis à jour. |
lrf |
float |
0.01 |
Taux d'apprentissage final en tant que fraction du taux initial = (lr0 * lrf ), utilisé conjointement avec les schedulers pour ajuster le taux d'apprentissage au fil du temps. |
momentum |
float |
0.937 |
Facteur d'impulsion pour SGD ou bêta1 pour les optimiseurs Adam, influençant l'incorporation des gradients passés dans la mise à jour actuelle. |
weight_decay |
float |
0.0005 |
Terme de régularisation L2, pénalisant les poids importants pour éviter le surapprentissage. |
warmup_epochs |
float |
3.0 |
Nombre d'epochs pour l'échauffement du taux d'apprentissage (warmup), augmentant progressivement le taux d'apprentissage d'une valeur faible au taux d'apprentissage initial afin de stabiliser l'entraînement dès le début. |
warmup_momentum |
float |
0.8 |
Impulsion initiale pour la phase d'échauffement, s'ajustant progressivement à l'impulsion définie pendant la période d'échauffement. |
warmup_bias_lr |
float |
0.1 |
Taux d'apprentissage pour les paramètres de biais pendant la phase d'échauffement, aidant à stabiliser l'entraînement du modèle dans les premières epochs. |
box |
float |
7.5 |
Poids de la composante de perte de la 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 |
float |
0.5 |
Poids de la perte de classification dans la fonction de perte totale, affectant l'importance de la prédiction correcte de la classe par rapport aux autres composantes. |
dfl |
float |
1.5 |
Poids de la perte focale de distribution, utilisé dans certaines versions de YOLO pour une classification fine. |
pose |
float |
12.0 |
Poids de la perte de pose dans les modèles entraînés pour l'estimation de pose, influençant l'importance accordée à la prédiction précise des points clés de la pose. |
kobj |
float |
2.0 |
Poids de la perte d'objectivité des keypoints dans les modèles d'estimation de pose, équilibrant la confiance de la détection avec la précision de la pose. |
nbs |
int |
64 |
Taille nominale du lot pour la normalisation de la perte. |
overlap_mask |
bool |
True |
Détermine si les masques d'objet doivent être fusionnés en un seul masque pour l'entraînement, ou conservés séparés pour chaque objet. En cas de chevauchement, le plus petit masque est superposé au plus grand masque lors de la fusion. |
mask_ratio |
int |
4 |
Taux de sous-échantillonnage pour les masques de segmentation, affectant la résolution des masques utilisés pendant l'entraînement. |
dropout |
float |
0.0 |
Taux d'abandon pour la régularisation dans les tâches de classification, empêchant le surapprentissage en omettant aléatoirement des unités pendant l'entraînement. |
val |
bool |
True |
Active la validation pendant l'entraînement, permettant une évaluation périodique des performances du modèle sur un ensemble de données distinct. |
plots |
bool |
False |
Génère et enregistre des graphiques des métriques d'entraînement et de validation, ainsi que des exemples de prédiction, fournissant des informations visuelles sur les performances du modèle et la progression de l'apprentissage. |
Remarque sur les paramètres de la taille de lot
L'argument batch
peut être configuré de trois manières :
- Taille de lot fixe: Définissez une valeur entière (par exemple,
batch=16
), en spécifiant directement le nombre d'images par lot. - Mode Auto (60 % de mémoire GPU): Utilisez
batch=-1
pour ajuster automatiquement la taille du lot afin d'utiliser environ 60 % de la mémoire CUDA. - Mode Auto avec Fraction d'Utilisation: Définissez une valeur de fraction (par exemple,
batch=0.70
) pour ajuster la taille du lot en fonction de la fraction spécifiée de l'utilisation de la mémoire GPU.
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 :
Argument | Type | Par défaut | Plage | Description |
---|---|---|---|---|
hsv_h |
float |
0.015 |
0.0 - 1.0 |
Ajuste la teinte de l'image d'une fraction de la roue chromatique, introduisant une variabilité des couleurs. Aide le modèle à se généraliser à différentes conditions d'éclairage. |
hsv_s |
float |
0.7 |
0.0 - 1.0 |
Modifie la saturation de l'image d'une fraction, affectant 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, aidant le modèle à bien fonctionner dans diverses conditions d'éclairage. |
degrees |
float |
0.0 |
0.0 - 180 |
Fait pivoter l'image de manière aléatoire dans la plage de degrés spécifiée, améliorant la capacité du modèle à reconnaître les objets à diverses orientations. |
translate |
float |
0.1 |
0.0 - 1.0 |
Translate l'image horizontalement et verticalement d'une fraction de la taille de l'image, aidant à apprendre à détecter les objets partiellement visibles. |
scale |
float |
0.5 |
>=0.0 |
Met à l'échelle l'image par un facteur de gain, simulant des objets à 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 de perspective aléatoire à l'image, améliorant la capacité du modèle à comprendre les objets dans l'espace 3D. |
flipud |
float |
0.0 |
0.0 - 1.0 |
Retourne l'image à l'envers avec la probabilité spécifiée, augmentant 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é de l'ensemble de données. |
bgr |
float |
0.0 |
0.0 - 1.0 |
Inverse les canaux d'image de RGB à BGR avec la probabilité spécifiée, utile pour augmenter la robustesse à l'ordre incorrect des canaux. |
mosaic |
float |
1.0 |
0.0 - 1.0 |
Combine quatre images d'entraînement en une seule, simulant différentes compositions de scène 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 une image composite. Améliore la capacité du modèle à se généraliser en introduisant du bruit d'étiquette et de la variabilité visuelle. |
cutmix |
float |
0.0 |
0.0 - 1.0 |
Combine des portions de deux images, créant un mélange partiel tout en conservant des régions distinctes. Améliore la robustesse du modèle en créant des scénarios d'occlusion. |
copy_paste |
float |
0.0 |
0.0 - 1.0 |
Segmentation uniquement. Copie et colle des objets à travers les images pour augmenter le nombre d'instances d'objets. |
copy_paste_mode |
str |
flip |
- | Segmentation uniquement. Spécifie le copy-paste stratégie à utiliser. Les options incluent 'flip' et 'mixup' . |
auto_augment |
str |
randaugment |
- | Classification uniquement. Applique une politique d'augmentation prédéfinie ('randaugment' , 'autoaugment' , ou 'augmix' ) pour améliorer les performances du modèle grâce à la diversité visuelle. |
erasing |
float |
0.4 |
0.0 - 0.9 |
Classification uniquement. Efface aléatoirement des régions de l'image pendant l'entraînement pour encourager le modèle à se concentrer sur des caractéristiques moins évidentes. |
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.
Info
Pour plus d'informations sur les opérations d'augmentation de l'entraînement, consultez la section de référence.
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 :
Exemple
# 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 :
Exemple
# 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 :
Exemple
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/
.
Exemple
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 :
Exemple d'entraînement sur un seul GPU et CPU
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é.
Exemple de reprise d'entraînement
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.
Exemple d'entraînement MPS
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 :
Argument | Par défaut | Description |
---|---|---|
model |
None |
Chemin d’accès au fichier de modèle pour l’entraînement. |
data |
None |
Chemin d'accès au fichier de configuration de l'ensemble de données (par exemple, coco8.yaml ). |
epochs |
100 |
Nombre total d’époques d’entraînement. |
batch |
16 |
Taille de lot, réglable en tant qu’entier ou en mode automatique. |
imgsz |
640 |
Taille d’image cible pour l’entraînement. |
device |
None |
Périphérique(s) de calcul pour l’entraînement comme cpu , 0 , 0,1 , ou mps . |
save |
True |
Active l’enregistrement des points de contrôle d’entraînement et des poids du modèle final. |
Pour un guide détaillé sur les paramètres d’entraînement, consultez la section Paramètres d’entraînement.