Entraîner un modèle avec Ultralytics YOLO
Introduction#
L’entraînement d’un modèle d’apprentissage profond consiste à lui fournir des données et à ajuster ses paramètres afin qu’il puisse produire des prédictions précises. Le mode Train d’Ultralytics YOLO26 entraîne efficacement des modèles de détection d’objets et d’autres tâches de vision sur du matériel moderne. Ce guide présente les détails nécessaires pour commencer à entraîner tes propres modèles avec YOLO26. Si tu n’as pas encore installé Ultralytics, commence par le guide de démarrage rapide.
Consulte l’aperçu de YOLO27 non encore publié pour découvrir les exemples d’entraînement prévus.
Regarder : Comment entraîner un modèle YOLO sur ton jeu de données personnalisé dans Google Colab.
Pourquoi choisir Ultralytics YOLO pour l’entraînement ?#
Pourquoi utiliser le mode Train de YOLO26 :
- Efficacité : tire le meilleur parti de ton matériel, que tu utilises une seule GPU ou que tu passes à plusieurs GPU.
- Polyvalence : entraîne tes modèles sur des jeux de données personnalisés, mais aussi sur des jeux de données prêts à l’emploi comme COCO, VOC et ImageNet.
- Facilité d’utilisation : des interfaces CLI et Python simples, mais puissantes, pour une expérience d’entraînement fluide.
- Souplesse des hyperparamètres : dispose d’un large éventail d’hyperparamètres personnalisables pour affiner les performances du modèle. Pour un contrôle plus poussé, tu peux aussi personnaliser le trainer lui-même.
- Entraînement dans le cloud : entraîne tes modèles sur des GPU cloud via l’Ultralytics Platform, avec des métriques en temps réel et une sauvegarde automatique des points de contrôle.
Principales fonctionnalités du mode Train#
Voici quelques fonctionnalités notables du mode Train de YOLO26 :
- Téléchargement automatique des jeux de données : les configurations de jeux de données qui définissent une source de téléchargement sont téléchargées automatiquement lors de leur première utilisation, par exemple
yolo train data=coco8.yaml. Consulte la présentation des jeux de données pour connaître les formats et les jeux de données pris en charge. - Prise en charge de plusieurs GPU : répartis l’entraînement sur plusieurs GPU pour le raccourcir.
- Configuration des hyperparamètres : modifie les hyperparamètres à l’aide de fichiers de configuration YAML ou d’arguments CLI.
- Visualisation et suivi : suis les métriques d’entraînement en temps réel et visualise le processus d’apprentissage pour mieux comprendre son déroulement.
Exemples d'utilisation#
Entraîne YOLO26n sur le jeu de données COCO8 pendant 100 époques avec une taille d’image de 640. Tu peux spécifier le périphérique d’entraînement à l’aide de l’argument device. Si aucun argument n’est transmis, le GPU device=0 sera utilisé s’il est disponible ; sinon, device='cpu' sera utilisé.
Sous Windows, tu peux rencontrer une erreur RuntimeError lors du lancement de l’entraînement sous forme de script. Ajoute un bloc if __name__ == "__main__": avant ton code d’entraînement pour résoudre le problème.
L’appareil est déterminé automatiquement. Si un GPU est disponible, il sera utilisé (appareil CUDA 0 par défaut) ; sinon, l’entraînement démarrera sur CPU.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.yaml") # créer un nouveau modèle à partir du fichier YAML
model = YOLO("yolo26n.pt") # charger un modèle préentraîné (recommandé pour l’entraînement)
model = YOLO("yolo26n.yaml").load("yolo26n.pt") # créer à partir du fichier YAML et transférer les poids
# Entraîner le modèle
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)Entraînement sur plusieurs GPU#
L’entraînement multi-GPU tire mieux parti du matériel disponible en répartissant la charge d’entraînement sur plusieurs GPU. Cette fonctionnalité est disponible avec l’API Python comme avec l’interface de ligne de commande. Pour activer l’entraînement multi-GPU, indique les identifiants des GPU à utiliser.
Pour entraîner un modèle avec 2 GPU (périphériques CUDA 0 et 1), utilise les commandes suivantes. Ajoute d’autres GPU au besoin.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.pt") # charger un modèle préentraîné (recommandé pour l’entraînement)
# Entraîner le modèle sur 2 GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])
# Entraîner le modèle sur les deux GPU les moins sollicités
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])L’entraînement sur plusieurs GPU ne fonctionne pas sous Windows avec les roues PyTorch officielles pour torch>=2.4. Ultralytics lance DDP via torch.distributed.run, dont l’étape de rendez-vous construit un TCPStore qui utilise le backend libuv par défaut depuis PyTorch 2.4 ; or, les roues Windows officielles sont compilées sans libuv. L’entraînement s’arrête immédiatement avec :
RuntimeError: use_libuv was requested but PyTorch was built without libuv support
Définir USE_LIBUV=0 ne résout pas le problème, car le rendez-vous construit directement TCPStore et ce chemin d’exécution ne lit jamais cette variable. Entraîne ton modèle sous Linux ou WSL2 pour utiliser plusieurs GPU, ou utilise un seul GPU avec device=0 sous Windows.
Lorsque tu spécifies plusieurs périphériques (par exemple, device=[0, 1]), Ultralytics lance en interne une nouvelle instance du trainer et exécute torch.distributed.run en arrière-plan. Cela fonctionne avec l’utilisation standard de la CLI et les scripts Python non modifiés.
Cependant, si ton script contient des composants personnalisés — tels qu’un trainer, un validateur, un jeu de données ou un pipeline d’augmentation personnalisé — ces objets ne peuvent pas être sérialisés et transférés automatiquement aux sous-processus DDP. Dans ce cas, tu dois lancer directement ton script avec torch.distributed.run :
python -m torch.distributed.run --nproc_per_node 2 your_training_script.pyL’entraînement sur GPU AMD utilise une version de PyTorch compilée avec ROCm et la syntaxe standard device=0 ou device=cuda:0. Consulte le guide d’intégration AMD pour l’installation de ROCm, l’entraînement sur plusieurs GPU, les notes sur AMP et l’inférence MIGraphX des modèles exportés.
L’entraînement sur GPU Intel utilise device=xpu:0, ou plusieurs ID XPU avec une version de PyTorch qui fournit XCCL.
Entraînement sur NPU Huawei Ascend#
Ultralytics prend en charge l’entraînement et la validation sur les NPU Huawei Ascend via torch_npu. Installe des versions compatibles entre elles de CANN, PyTorch et torch_npu en suivant le guide d’installation de l’extension Ascend pour PyTorch, puis charge l’environnement CANN avant de lancer Ultralytics :
source /usr/local/Ascend/ascend-toolkit/set_env.shfrom ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Entraîner sur un NPU Ascend
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")
# Entraîner sur deux NPU Ascend avec HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")Les fonctionnalités d’entraînement standard, notamment AMP, la validation, la sauvegarde des points de contrôle et la reprise, utilisent le NPU actif. AutoBatch est disponible pour l’entraînement sur un seul NPU, tandis que plusieurs ID NPU lancent un entraînement distribué via HCCL. Consulte le guide d’intégration Huawei Ascend pour exporter et déployer le modèle après l’entraînement.
Entraînement sur les GPU les moins sollicités#
L’entraînement sur GPU inactifs sélectionne automatiquement les GPU les moins utilisés sur les systèmes multi-GPU : tu n’as donc pas à choisir les périphériques manuellement. Le système classe les GPU disponibles selon leur taux d’utilisation et leur VRAM libre.
Pour sélectionner et utiliser automatiquement le ou les GPU les moins sollicités pour l’entraînement, utilise le paramètre d’appareil -1. Cette fonctionnalité est particulièrement utile dans les environnements informatiques partagés ou sur les serveurs utilisés par plusieurs personnes.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.pt") # charger un modèle préentraîné (recommandé pour l’entraînement)
# Entraîner le modèle sur le GPU le moins sollicité
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)
# Entraîner le modèle sur les deux GPU les moins sollicités
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])L’algorithme de sélection automatique privilégie les GPU qui présentent :
- Un taux d’utilisation actuel plus faible
- Une plus grande quantité de mémoire disponible (VRAM libre)
C’est particulièrement utile dans les environnements de calcul partagés ou lorsque plusieurs tâches d’entraînement s’exécutent simultanément, car les périphériques sont sélectionnés en fonction des conditions du moment à chaque lancement.
Entraînement MPS sur Apple Silicon#
Les modèles Ultralytics YOLO peuvent être entraînés sur les puces Apple grâce au framework Metal Performance Shaders (MPS), qui exécute les calculs et le traitement des images sur les GPU personnalisés d’Apple.
Pour entraîner un modèle sur une puce Apple, spécifie mps comme périphérique au lancement de l’entraînement, en Python ou sur la ligne de commande :
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.pt") # charger un modèle préentraîné (recommandé pour l’entraînement)
# Entraîner le modèle avec MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")Reprendre un entraînement interrompu#
Reprendre l’entraînement à partir d’un point de contrôle enregistré est utile lorsqu’une exécution a été interrompue de façon inattendue ou lorsque tu veux continuer à entraîner un modèle avec de nouvelles données ou pendant davantage d’époques.
Lorsque l’entraînement reprend, Ultralytics YOLO charge les poids du dernier modèle enregistré et restaure également l’état de l’optimiseur, le planificateur du taux d’apprentissage, le numéro d’époque et le jeu de données. L’entraînement reprend ensuite là où il s’était arrêté. Transmets explicitement data= avec resume pour continuer avec un autre jeu de données plutôt que celui du point de contrôle.
Pour reprendre l’entraînement avec Ultralytics YOLO, définis l’argument resume sur True lors de l’appel à la méthode train, et indique le chemin du fichier .pt contenant les poids du modèle partiellement entraîné.
Pour reprendre une exécution d’entraînement interrompue, en Python ou sur la ligne de commande :
from ultralytics import YOLO
# Charger un modèle
model = YOLO("path/to/last.pt") # charger un modèle partiellement entraîné
# Reprendre l’entraînement
results = model.train(resume=True)En définissant resume=True, la fonction train reprend l’entraînement là où il s’était arrêté, à partir de l’état stocké dans le fichier path/to/last.pt. Si l’argument resume est omis ou défini sur False, la fonction train démarre une nouvelle session d’entraînement. Une exécution qui envoie ses données en continu vers Ultralytics Platform continue d’utiliser le même modèle Platform lorsqu’elle reprend.
N’oublie pas que les points de reprise sont enregistrés par défaut à la fin de chaque époque, ou à intervalles fixes à l’aide de l’argument save_period ; tu dois donc terminer au moins 1 époque pour reprendre un entraînement.
Paramètres d’entraînement#
Les paramètres d’entraînement des modèles YOLO regroupent divers hyperparamètres et configurations utilisés pendant l’entraînement. Ils influent sur les performances, la vitesse et la précision du modèle. Les principaux paramètres d’entraînement comprennent la taille de lot, le taux d’apprentissage, le momentum et la décroissance des poids. Le choix de l’optimiseur, de la fonction de perte et de la composition du jeu de données d’entraînement peut également influer sur le processus. Un réglage minutieux et des essais avec ces paramètres sont essentiels pour optimiser les performances.
Optimiseur MuSGD#
Dans YOLO26, MuSGD est un optimiseur hybride qui combine les mises à jour standard SGD avec les mises à jour orthogonalisées de type Muon.
Il est recommandé pour les entraînements YOLO26 de longue durée et les jeux de données plus volumineux, où les mises à jour Muon orthogonalisées peuvent contribuer à stabiliser l’optimisation.
Seuls les poids linéaires 2D et les filtres de convolution 4D (remodelés en 2D) reçoivent la mise à jour de type Muon en plus de SGD, tandis que tous les autres paramètres, comme les poids de normalisation par lot et les termes de biais, restent soumis à SGD standard.
Lorsque optimizer=auto est utilisé, Ultralytics sélectionne automatiquement MuSGD pour les entraînements de longue durée (généralement lorsque le nombre d’itérations > 10000). Pour les entraînements plus courts, l’entraîneur utilise AdamW. En mode auto, l’entraîneur sélectionne également le taux d’apprentissage ; tout lr0 fourni par l’utilisateur est donc ignoré. Pour contrôler ces paramètres manuellement, sélectionne explicitement un optimiseur, par exemple optimizer=AdamW lr0=0.001.
Exemple d’utilisation :
yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGDConsulte l’implémentation dans ultralytics/optim/muon.py et la logique de sélection automatique de l’optimiseur dans BaseTrainer.build_optimizer.
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
model | str | None | Spécifie le fichier du modèle utilisé pour l’entraînement. Accepte le chemin d’accès à un modèle préentraîné .pt ou à un fichier de configuration .yaml. Indispensable pour définir la structure du modèle ou initialiser les poids. |
data | str | None | Chemin d’accès au fichier YAML du jeu de données (p. ex. coco8.yaml), qui contient les chemins vers les données de validation et d’entraînement, les noms des classes et le nombre de classes. Pour la classification, tu peux plutôt indiquer un répertoire de jeu de données ou le nom d’un jeu de données intégré (p. ex. imagenet10). |
epochs | int | 100 | Nombre total d’époques d’entraînement. Chaque époque correspond à un passage complet sur l’ensemble du jeu de données. Modifier cette valeur peut influer sur la durée de l’entraînement et les performances du modèle. |
time | float | None | Durée maximale d’entraînement, en heures. Si cette valeur est définie, elle remplace l’argument epochs et permet à l’entraînement de s’arrêter automatiquement après la durée indiquée. Pratique lorsque le temps d’entraînement est limité. |
patience | int | 100 | Nombre d’époques à attendre sans amélioration des métriques de validation avant d’arrêter prématurément l’entraînement. Aide à prévenir le surapprentissage en interrompant l’entraînement lorsque les performances stagnent. |
batch | int ou float | 16 | Taille de lot, avec trois modes : définir une valeur entière (p. ex. batch=16), utiliser le mode automatique pour 60 % de la mémoire GPU disponible (batch=-1), ou utiliser le mode automatique avec une fraction spécifiée de la mémoire GPU disponible (batch=0.70). |
imgsz | int | 640 | Taille cible des images pour l’entraînement. Les images sont redimensionnées en carrés dont les côtés correspondent à la valeur spécifiée (si rect=False), en préservant le rapport hauteur/largeur pour les modèles YOLO, mais pas pour RT-DETR. Influe sur la précision du modèle et la complexité des calculs. |
save | bool | True | Active l’enregistrement des points de contrôle d’entraînement et des poids finaux du modèle. Pratique pour reprendre l’entraînement ou procéder au déploiement du modèle. |
save_period | int | -1 | Fréquence d’enregistrement des points de contrôle du modèle, exprimée en époques. La valeur -1 désactive cette fonctionnalité. Pratique pour enregistrer des modèles intermédiaires au cours de longues sessions d’entraînement. |
cache | bool ou str | False | Active la mise en cache des images du jeu de données en mémoire (True/ram), sur disque (disk) ou la désactive (False). Accélère l’entraînement en réduisant les entrées-sorties disque, au prix d’une utilisation accrue de la mémoire. |
tile | bool ou int | False | Découpe chaque image source en tuiles d'entraînement fixes, avec des annotations tronquées et des fenêtres négatives conservées. True utilise imgsz ; un entier positif définit la taille des tuiles. Consulte le découpage en tuiles haute résolution. |
device | int ou str ou list | None | Spécifie le ou les périphériques de calcul pour l’entraînement : un seul GPU (device=0), plusieurs GPU (device=[0,1]), un CPU (device=cpu), MPS pour les puces Apple (device=mps), un NPU Huawei Ascend (device=npu:0 ou device=npu:0,1), un Intel XPU (device=xpu:0), ou la sélection automatique d’un GPU inactif (device=-1) ou de plusieurs GPU inactifs (device=[-1,-1]). |
workers | int | 8 | Nombre de threads de travail pour le chargement des données (par RANK en cas d’entraînement multi-GPU). Influe sur la vitesse du prétraitement et de l’envoi des données au modèle, ce qui est particulièrement utile dans les configurations multi-GPU. |
project | str | None | Nom du répertoire du projet où sont enregistrées les sorties de l'entraînement. Un chemin relatif est placé sous runs_dir/<task>, tandis qu'un chemin absolu est utilisé tel quel. |
name | str | None | Nom de la session d’entraînement. Sert à créer un sous-répertoire dans le dossier du projet, où sont stockés les journaux et les résultats de l’entraînement. |
exist_ok | bool | False | Si True, autorise l’écrasement d’un répertoire projet/nom existant. Pratique pour les expérimentations itératives sans devoir supprimer manuellement les résultats précédents. |
save_dir | str | None | Spécifie le répertoire exact dans lequel les résultats de la session sont enregistrés, en remplaçant la combinaison project/name. Le chemin est utilisé tel quel, sans incrémentation automatique ; les exécutions successives réutilisent donc le même répertoire. |
pretrained | bool ou str | True | Détermine si l’entraînement commence à partir de poids préentraînés. La valeur peut être un booléen ou le chemin d’accès aux poids à charger. pretrained=False entraîne le modèle à partir de poids initialisés aléatoirement tout en conservant son architecture. |
cls_remap | bool | True | Lors d’un ajustement fin sur plusieurs jeux de données, copie dans le nouveau modèle les lignes de la tête de classification préentraînée correspondant aux classes dont les noms correspondent. Les classes communes conservent ainsi le biais appris et, si la largeur de la tête reste inchangée, leurs poids. Cette option s’applique que le nombre de classes soit différent ou identique avec un ordre différent. |
optimizer | str | 'auto' | Choix de l’optimiseur pour l’entraînement. Les options incluent SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp ou auto, pour choisir AdamW ou MuSGD en fonction du nombre d’itérations d’entraînement. Influe sur la vitesse et la stabilité de la convergence. |
seed | int | 0 | Définit la graine aléatoire de l’entraînement pour garantir la reproductibilité des résultats d’une exécution à l’autre avec les mêmes configurations. |
deterministic | bool | True | Force l’utilisation d’algorithmes déterministes pour garantir la reproductibilité, mais peut influer sur les performances et la vitesse en raison de l’exclusion des algorithmes non déterministes. |
verbose | bool | True | Active l’affichage détaillé pendant l’entraînement : barres de progression, métriques par époque et informations supplémentaires dans la console. |
single_cls | bool | False | Traite toutes les classes des jeux de données multi-classes comme une seule classe pendant l’entraînement. Pratique pour les tâches de classification binaire ou lorsqu’on s’intéresse à la présence d’objets plutôt qu’à leur classification. |
classes | list[int] | None | Spécifie une liste d’identifiants de classes à utiliser pour l’entraînement. Pratique pour filtrer les classes et se concentrer uniquement sur certaines d’entre elles. |
rect | bool | False | Active la stratégie de padding minimal : les images d'un lot sont rembourrées au minimum pour atteindre une taille commune, le côté le plus long étant égal à imgsz. Cela peut améliorer l'efficacité et la vitesse, mais affecter la précision du modèle. Le trainer YOLO standard utilise rect=True pour la validation de la détection, de la segmentation, de la pose et des OBB, quel que soit ce paramètre. |
multi_scale | float | 0.0 | Fait varier aléatoirement imgsz de +/- multi_scale à chaque lot (p. ex. 0.25 -> 0.75x à 1.25x), en arrondissant aux multiples du pas du modèle ; 0.0 désactive l’entraînement multi-échelle. |
cos_lr | bool | False | Utilise un planificateur de taux d’apprentissage cosinus, qui ajuste ce taux selon une courbe cosinus au fil des époques. Aide à gérer le taux d’apprentissage pour améliorer la convergence. |
close_mosaic | int | 10 | Désactive la mosaïque de l’augmentation des données pendant les N dernières époques afin de stabiliser l’entraînement avant son terme. La valeur 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, puis reprend l’entraînement là où il s’était arrêté. |
amp | bool ou str | True | Définit la précision de l’entraînement : True ou "fp16" utilise FP16, "bf16" utilise BF16 sur les périphériques CUDA compatibles, et False ou "fp32" utilise FP32. |
quantize | int ou str | None | Définis 8 (ou "int8") pour l’entraînement tenant compte de la quantification INT8 (QAT), qui affine le modèle avec une fausse quantification intégrée afin que les poids soient compatibles avec l’export INT8. Consulte l’entraînement tenant compte de la quantification. |
fraction | float, int ou list | 1.0 | Sous-ensemble du jeu de données, exprimé sous forme de ratio, de nombre ou de liste [train, val, test]. 1 désigne l’ensemble de la partition ; les entiers supérieurs à 1 correspondent à un nombre d’images, et seule l’entrée de test facultative accepte 0/0.0 pour signifier « aucun ». Les listes de deux éléments conservent l’ensemble de la partition de test. |
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 certaines couches selon leur indice ou le nom du module (23.cv2, sans le model. initial), ce qui réduit le nombre de paramètres entraînables. Pratique pour l’ajustement fin ou l’apprentissage par transfert. |
lr0 | float | 0.01 | Taux d’apprentissage initial (par ex. SGD=1E-2, Adam=1E-3). Ignoré avec optimizer='auto', l’optimiseur par défaut ; indique explicitement un optimiseur pour l’utiliser. |
lrf | float | 0.01 | Taux d’apprentissage final exprimé en fraction du taux initial = (lr0 * lrf), utilisé avec les planificateurs pour ajuster le taux d’apprentissage au fil du temps. |
momentum | float | 0.937 | Momentum de SGD/MuSGD ou bêta1 pour les optimiseurs Adam. Avec optimizer=auto, AdamW utilise 0.9 ; MuSGD commence à 0.9, puis la phase de préchauffage interpole de warmup_momentum à momentum. Sans préchauffage, MuSGD automatique reste à 0.9. |
weight_decay | float | 0.0005 | Terme de régularisation L2, qui pénalise les poids élevés pour prévenir le surapprentissage. |
warmup_epochs | float | 3.0 | Époques de préchauffage (les fractions sont autorisées), plafonnées de façon à laisser la dernière époque sans préchauffage. Le taux d’apprentissage augmente linéairement de 0 (biais de warmup_bias_lr) à sa valeur planifiée, la quantité de mouvement de warmup_momentum à momentum, et l’accumulation des gradients d’un lot à sa valeur nominale (voir nbs), tous atteignant leurs valeurs cibles à la fin du préchauffage. |
warmup_momentum | float | 0.8 | Quantité de mouvement initiale pour les optimiseurs avec un terme de quantité de mouvement (SGD, MuSGD, RMSprop), augmentée linéairement jusqu’à momentum à la fin du préchauffage. Le beta1 de la famille Adam n’est pas soumis au préchauffage. |
warmup_bias_lr | float | 0.1 | Taux d’apprentissage des paramètres de biais pendant la phase de montée en chauffe, qui aide à stabiliser l’entraînement du modèle lors des premières époques. Défini automatiquement sur 0.0 avec l’option par défaut optimizer='auto' ; nomme explicitement un optimiseur pour l’utiliser. |
distill_model | str | None | Chemin d’accès à un point de contrôle du modèle enseignant (p. ex. yolo26x.pt) pour la distillation des connaissances. Une fois défini, le modèle étudiant est entraîné avec une perte de distillation supplémentaire guidée par le modèle enseignant figé. |
dis | float | 6.0 | Poids de la perte de distillation ajoutée aux pertes de détection standard. Une valeur plus élevée accroît l’influence des caractéristiques fournies par le modèle enseignant. |
box | float | 7.5 | Poids de la composante de perte de boîte dans la fonction de perte, qui détermine 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, qui influe sur l’importance accordée à la prédiction correcte de la classe par rapport aux autres composantes. |
cls_pw | float | 0.0 | Exposant de pondération des classes permettant de gérer le déséquilibre des classes en fonction de leur fréquence inverse. 0.0 désactive la pondération des classes ; 1.0 applique une pondération complète par fréquence inverse. Les valeurs entre 0 et 1 appliquent une pondération partielle. |
dfl | float | 1.5 | Poids du terme de régression de distance des boîtes : perte focale de distribution (DFL) lorsque la tête de détection utilise reg_max > 1, ou perte L1 sur les distances normalisées des boîtes avec YOLO26 sans DFL (reg_max: 1). |
pose | float | 12.0 | Poids de la perte de pose dans les modèles entraînés pour l’estimation de pose, qui influe sur l’importance accordée à la prédiction précise des points clés de la pose. |
kobj | float | 1.0 | Poids de la perte d’objectivité des points clés dans les modèles d’estimation de pose, qui équilibre la confiance de détection et la précision de la pose. |
rle | float | 1.0 | Poids de la perte d’estimation de log-vraisemblance résiduelle dans les modèles d’estimation de pose, qui influe sur la précision de la localisation des points clés. |
angle | float | 1.0 | Poids de la perte angulaire dans les modèles OBB, qui influe sur la précision des prédictions d’angle des boîtes englobantes orientées. |
dlog | float | 1.0 | Poids de la perte logarithmique invariante à l’échelle (SILog) dans les modèles d’estimation de profondeur, terme principal qui détermine la précision de la profondeur. |
dgrad | float | 0.5 | Poids de la perte de gradient dans les modèles d’estimation de profondeur, qui pénalise les erreurs sur les contours de profondeur et favorise des limites de surface plus nettes. |
dlam | float | 1.0 | Facteur de pondération de la variance de la perte SILog dans les modèles d’estimation de profondeur. 1.0 rend la perte entièrement invariante à l’échelle, tandis que 0.0 la réduit à une simple erreur quadratique moyenne logarithmique (log-RMSE). |
nbs | int | 64 | Taille nominale du lot. Les gradients s’accumulent sur round(nbs / batch) lots par étape d’optimisation (au moins 1 et, en dehors du mode time, au plus le nombre total de lots de l’exécution), et weight_decay est mis à l’échelle par batch * accumulate / nbs pour correspondre. |
overlap_mask | bool | True | Détermine si les masques d’objets doivent être fusionnés en un seul masque pour l’entraînement ou conservés séparément pour chaque objet. En cas de chevauchement, le masque le plus petit est superposé au plus grand lors de la fusion. |
mask_ratio | int | 4 | Facteur de sous-échantillonnage des masques de segmentation, qui influe sur la résolution des masques utilisés pendant l’entraînement. Ne modifie pas la résolution des masques prédits. |
dropout | float | 0.0 | Taux de dropout pour la régularisation des tâches de classification, qui prévient le surapprentissage en omettant aléatoirement des unités pendant l’entraînement. |
val | bool | True | Active la validation pendant l’entraînement afin d’évaluer périodiquement les performances du modèle sur un jeu de données distinct. |
split | str | 'val' | Ensemble de données utilisé pour la validation pendant l'entraînement : val, test ou train. Ses métriques sélectionnent best.pt et déclenchent l'arrêt anticipé. |
nms | bool, facultatif | None | Sélectionne la tête d’inférence utilisée pour la validation des époques, la sélection des points de contrôle et l’arrêt anticipé. None ou True utilise la stratégie un-vers-plusieurs avec NMS ; False utilise la tête sans NMS lorsqu’elle est disponible. Les deux têtes conservent leurs pertes d’entraînement. |
plots | bool | True | Génère et enregistre des graphiques des métriques d’entraînement et de validation, ainsi que des exemples de prédictions, afin de fournir un aperçu visuel des performances du modèle et de la progression de l’apprentissage. |
compile | bool ou str | False | Active la compilation de graphes torch.compile de PyTorch 2.x avec backend='inductor'. Accepte True → "default", False → désactivation, ou un mode sous forme de chaîne tel que "default", "reduce-overhead", "max-autotune-no-cudagraphs". En cas d’incompatibilité, revient au mode eager avec un avertissement. |
channels_last | bool | None | Utilise le format mémoire channels_last (NHWC) pour les convolutions pendant l’entraînement. None l’active automatiquement sur CUDA avec PyTorch 1.11 ou ultérieur, sauf sous Windows, où les mesures ont montré un ralentissement. False le désactive et True l’active explicitement. L’entraînement sur CPU ou MPS utilise toujours NCHW (True est ignoré avec un avertissement). |
max_det | int | 300 | Nombre maximal de détections par image pendant la validation de l’entraînement. Pour detect, segment, pose et OBB, la valeur par défaut de 300 est portée au plus grand nombre d’objets annotés dans les ensembles train/val uniquement si ce nombre dépasse 300. Les autres valeurs restent fixes ; tout dépassement de la limite déclenche un avertissement. |
L’argument batch accepte trois types de valeurs, et le trainer ajoute deux garde-fous :
- Taille de lot fixe Taille de lot : définis une valeur entière (p. ex.
batch=16), qui spécifie directement le nombre d’images par lot. L’entraînement multi-GPU répartit cette taille de lot globale de manière égale entre les GPU ; elle doit donc être au moins égale au nombre de GPU, et le reste est ignoré (p. ex.batch=15sur 2 GPU entraîne 7 images par GPU). - Mode automatique (60 % de la mémoire GPU) : utilise
batch=-1pour ajuster automatiquement la taille de lot afin qu’elle corresponde à environ 60 % de la mémoire CUDA disponible pour l’entraînement. - Mode automatique avec fraction d’utilisation : définis une valeur fractionnaire (p. ex.
batch=0.70) pour ajuster la taille de lot en fonction de la fraction spécifiée de la mémoire GPU disponible. - Nouvelle tentative automatique en cas de mémoire insuffisante : si une erreur de mémoire CUDA insuffisante survient pendant la première époque, l’entraîneur réduit automatiquement de moitié la taille de lot et réessaie (jusqu’à 3 fois). Cette option s’applique uniquement à l’entraînement sur un seul GPU ; l’entraînement multi-GPU (DDP) déclenche immédiatement l’erreur.
- Aucune taille adaptée trouvée : si aucune taille de lot candidate ne produit un profil exploitable, AutoBatch renvoie une erreur
RuntimeErrorexplicite au lieu de revenir silencieusement à une valeur par défaut sans rapport.
Paramètres et hyperparamètres d’augmentation#
Les techniques d’augmentation des données sont essentielles pour améliorer la robustesse et les performances des modèles YOLO : elles introduisent de la variabilité dans les données d’entraînement et aident le modèle à mieux généraliser à des données inédites. Le tableau suivant décrit le rôle et l’effet de chaque argument d’augmentation :
| Argument | Type | Valeur par défaut | Tâches prises en charge | Plage | Description |
|---|---|---|---|---|---|
hsv_h | float | 0.015 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Ajuste la teinte de l’image d’une fraction de la roue chromatique, en introduisant une variabilité des couleurs. Aide le modèle à généraliser dans différentes conditions d’éclairage. Pour classify, cette option s’applique uniquement lorsque auto_augment=None. |
hsv_s | float | 0.7 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Modifie la saturation de l’image d’une fraction, ce qui influe sur l’intensité des couleurs. Utile pour simuler différentes conditions environnementales. Pour classify, cette option s’applique uniquement lorsque auto_augment=None. |
hsv_v | float | 0.4 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Modifie la valeur (luminosité) de l’image d’une fraction, ce qui aide le modèle à fonctionner correctement dans diverses conditions d’éclairage. Pour classify, cette option s’applique uniquement lorsque auto_augment=None. |
degrees | float | 0 | detect, segment, semantic, depth, pose, obb | 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 des objets selon différentes orientations. |
translate | float | 0.1 | detect, segment, semantic, depth, pose, obb | 0.0 - 1.0 | Déplace l’image horizontalement et verticalement d’une fraction de sa taille, ce qui aide le modèle à apprendre à détecter les objets partiellement visibles. |
scale | float | tuple | 0.5 | detect, segment, semantic, depth, classify, pose, obb | 0 - 1, ou un tuple (min, max) explicite (pas pour classify) | Met l’image à l’échelle selon un facteur de gain, simulant des objets situés à différentes distances de la caméra. |
shear | float | 0 | detect, segment, semantic, depth, pose, obb | -180 - +180 | Cisaille l’image selon un degré spécifié, imitant l’effet d’objets observés sous différents angles. |
perspective | float | 0 | detect, segment, semantic, depth, pose, obb | 0.0 - 0.001 | Applique une transformation de perspective aléatoire à l’image, améliorant la capacité du modèle à comprendre les objets dans un espace 3D. |
flipud | float | 0 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Retourne l’image de haut en bas avec la probabilité spécifiée, augmentant la variabilité des données sans modifier les caractéristiques de l’objet. |
fliplr | float | 0.5 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Retourne l’image de gauche à droite avec la probabilité spécifiée, ce qui est utile pour apprendre à reconnaître les objets symétriques et accroître la diversité du jeu de données. |
bgr | float | 0 | detect, segment, semantic, depth, pose, obb | 0.0 - 1.0 | Inverse les canaux de l’image de RGB à BGR avec la probabilité spécifiée, ce qui est utile pour améliorer la robustesse face à un ordre de canaux incorrect. |
mosaic | float | 1 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Combine quatre images d’entraînement en une seule, en simulant différentes compositions de scènes et interactions entre objets. Efficace pour comprendre des scènes complexes. |
mixup | float | 0 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Mélange deux images et leurs étiquettes pour créer une image composite. Améliore la capacité de généralisation du modèle en introduisant du bruit dans les étiquettes et une variabilité visuelle. |
cutmix | float | 0 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Combine des portions de deux images pour créer un mélange partiel tout en conservant des régions distinctes. Améliore la robustesse du modèle en créant des situations d’occlusion. |
copy_paste | float | 0 | segment, semantic, obb | 0.0 - 1.0 | Fraction des objets admissibles qui sont copiés-collés ; flip les met en miroir dans l’image, tandis que mixup utilise aussi cette valeur comme probabilité d’application entre images. |
copy_paste_mode | str | flip | segment, semantic, obb | - | Indique la stratégie copy-paste à utiliser. Les options comprennent 'flip' et 'mixup'. |
auto_augment | str | randaugment | classify | - | 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 | classify | 0.0 - 1.0 | Efface aléatoirement des régions de l’image pendant l’entraînement afin d’inciter le modèle à se concentrer sur des caractéristiques moins évidentes. |
augmentations | list | None | detect, segment, semantic, depth, pose, obb | - | Transformations Albumentations personnalisées pour l’augmentation avancée des données (API Python uniquement). Accepte une liste d’objets de transformation pour des besoins d’augmentation spécifiques. |
Tu peux ajuster ces paramètres en fonction des exigences propres au jeu de données et à la tâche. Essayer différentes valeurs peut aider à trouver la meilleure stratégie d’augmentation.
Pour en savoir plus sur les opérations d’augmentation de l’entraînement, consulte la section de référence.
Journalisation#
Les métriques d’entraînement, les graphiques et les points de contrôle sont toujours enregistrés dans le répertoire de l’exécution. Ultralytics les envoie également à tout outil de suivi d’expériences installé et activé : Comet, ClearML, TensorBoard, MLflow, Weights & Biases et DVCLive. Tu peux activer ou désactiver chaque outil via les paramètres Ultralytics, par exemple yolo settings tensorboard=True. Les trois configurations les plus courantes sont présentées ci-dessous.
Comet#
Comet est une plateforme qui permet aux scientifiques des données et aux développeurs de suivre, comparer, expliquer et optimiser leurs expériences et leurs modèles. Elle fournit des métriques en temps réel, des différences de code et le suivi des hyperparamètres.
Pour utiliser Comet :
# pip install comet_ml
import comet_ml
comet_ml.login()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 journaliser tes 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 en 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 dans le navigateur et authentifier ta session.
TensorBoard#
TensorBoard est une boîte à outils de visualisation pour TensorFlow. Elle te permet de visualiser le graphe TensorFlow, de tracer des métriques quantitatives sur l’exécution du 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' directoryPour utiliser TensorBoard localement, exécute la commande ci-dessous et consulte les résultats à l’adresse localhost:6006.
tensorboard --logdir ultralytics/runs # replace with 'runs' directoryCette commande chargera TensorBoard et l’orientera vers le répertoire où sont enregistrés tes journaux d’entraînement.
Après avoir configuré ton outil de suivi, lance l’entraînement comme d’habitude. Les métriques d’entraînement sont automatiquement enregistrées sur la plateforme choisie. Tu peux ainsi suivre les performances au fil du temps, comparer les modèles et repérer les points à améliorer.
Et ensuite ?#
Évalue ton modèle entraîné sur des données mises de côté pour vérifier sa précision en conditions réelles, puis exporte-le au format ONNX, TensorRT ou dans un autre format de déploiement. Tu entraînes ton modèle sur tes propres données plutôt que sur COCO8 ? Commence par les formater à l’aide du guide des jeux de données.
FAQ#
Oui. L’entraînement dans le cloud Ultralytics Platform inclut des crédits gratuits pour commencer. Charge ton jeu de données, sélectionne un modèle et un GPU, puis entraîne directement depuis le navigateur.
Pour entraîner un modèle de détection d’objets avec Ultralytics YOLO26, tu peux utiliser l’API Python ou la CLI. Voici un exemple pour chacune des méthodes :
Exemple d’entraînement sur un seul GPU et sur CPUfrom ultralytics import YOLO # Charger un modèle model = YOLO("yolo26n.pt") # charger un modèle préentraîné (recommandé pour l’entraînement) # Entraîner le modèle results = model.train(data="coco8.yaml", epochs=100, imgsz=640)Pour plus de détails, consulte la section Paramètres d’entraînement.
Les principales fonctionnalités du mode Train d’Ultralytics YOLO26 comprennent :
- Téléchargement automatique des jeux de données : télécharge automatiquement des jeux de données standard comme COCO, VOC et ImageNet.
- Prise en charge multi-GPU : répartis l’entraînement sur plusieurs GPU pour accélérer le traitement.
- Configuration des hyperparamètres : personnalise les hyperparamètres à l’aide de fichiers YAML ou d’arguments CLI.
- Visualisation et suivi : suis les métriques d’entraînement en temps réel pour obtenir de meilleures informations.
Ces fonctionnalités rendent l’entraînement efficace et adaptable à tes besoins. Pour plus de détails, consulte la section Principales fonctionnalités du mode Train.
Pour reprendre l’entraînement après une interruption de session, définis l’argument
resumesurTrueet indique le chemin du dernier point de reprise enregistré.Exemple de reprise de l’entraînementfrom ultralytics import YOLO # Charger le modèle partiellement entraîné model = YOLO("path/to/last.pt") # Reprendre l’entraînement results = model.train(resume=True)Consulte la section sur la reprise des entraînements interrompus pour en savoir plus.
Un déséquilibre des classes se produit lorsque certaines classes comptent beaucoup moins d’exemples que d’autres dans tes données d’entraînement. Cela peut entraîner de mauvaises performances du modèle sur les classes rares. Ultralytics YOLO prend en charge la pondération des classes via l’argument
cls_pwpour remédier à ce problème. La pondération de la loss donne les meilleurs résultats en dernière étape, après avoir collecté et suréchantillonné les classes rares, comme décrit dans Gérer le déséquilibre des classes.L’argument
cls_pwcontrôle le degré de pondération des classes en fonction de l’inverse de leur fréquence :cls_pw=0.0(par défaut) : désactive la pondération des classescls_pw=1.0: applique une pondération complète selon l’inverse de la fréquence- Les valeurs entre
0.0et1.0: appliquent une pondération partielle en cas de déséquilibre modéré
Les poids des classes sont calculés comme
(1.0 / class_counts) ^ cls_pwet normalisés de sorte que leur moyenne soit égale à 1.0.class_countscorrespond au nombre d'objets annotés par classe, ou au nombre d'images d'entraînement par classe pour la classification, et les classes sans annotations d'entraînement, comme celles exclues parclasses=, reçoivent un poids de 1.0. La segmentation sémantique calcule plutôt ses poids à partir de la fréquence des pixels, comme(1.0 / ln(1.02 + p)) ^ cls_pw, oùpreprésente la proportion de pixels d'entraînement annotés dans chaque classe ; une classe sans pixel annoté reçoit donc le poids le plus élevé.Entraînement sur un jeu de données déséquilibréfrom ultralytics import YOLO # Charger un modèle préentraîné model = YOLO("yolo26n.pt") # Entraîner avec une pondération complète des classes pour des données fortement déséquilibrées results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0) # Ou utiliser une pondération partielle (0.25) en cas de déséquilibre modéré results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)ConseilCommence avec
cls_pw=0.25pour les jeux de données modérément déséquilibrés et augmente cette valeur à1.0si les performances des classes rares restent insuffisantes. Tu peux vérifier les poids des classes calculés dans les journaux d’entraînement pour contrôler leur distribution.Oui, Ultralytics YOLO26 prend en charge l’entraînement sur les puces Apple grâce au framework Metal Performance Shaders (MPS). Spécifie
mpscomme périphérique d’entraînement.Exemple d’entraînement MPSfrom ultralytics import YOLO # Charger un modèle préentraîné model = YOLO("yolo26n.pt") # Entraîner le modèle sur une puce Apple silicon (M1/M2/M3/M4) results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")Pour plus de détails, consulte la section Entraînement MPS sur Apple silicon.
Ultralytics YOLO26 te permet de configurer différents paramètres d’entraînement, comme la taille de lot, le taux d’apprentissage, le nombre d’époques et bien d’autres, à l’aide d’arguments. Voici un bref aperçu :
Argument Valeur par défaut Description modelNoneChemin du fichier du modèle à entraîner. dataNoneChemin du fichier YAML du jeu de données (par exemple, coco8.yaml), ou répertoire ou nom de jeu de données (par exemple,imagenet10) pour la classification.epochs100Nombre total d’époques d’entraînement. batch16Taille de lot, réglable sous forme d’entier ou en mode automatique. imgsz640Taille d’image cible pour l’entraînement. deviceNonePériphérique(s) de calcul pour l’entraînement, comme cpu,0,0,1oumps.saveTrueActive l’enregistrement des points de reprise de l’entraînement et des poids finaux du modèle. Pour un guide détaillé sur les paramètres d’entraînement, consulte la section Paramètres d’entraînement.
Commentaires1 074
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
drcosimo
Hi there, I' m new to this field and I'm trying to train a YOLO model for detection and tracking of video streams for security.
Until now I have managed to create my pipeline for training and I want to understand if it's a correct/possible approach:
-
Load a pretrained model from yolo
-
transfer learning with my custom dataset that possibly can focus on just some classes(person,car,truck,bus,bycicle)
-
Validate model to see how it performs
-
Operate a tuning with the custom best model and using my custom dataset
-
Retrain the initial pretrained model with my custom dataset and the best hyperparameters found in the tuning process.
-
Validate final model
The questions are several:
- The above approach is logically correct or it has flaws?
- Is it correct to narrow the detected classes? Or it isn't crucial to the precision of the model?
- When tuning(if its a correct approach) should i use my dataset or try the coco dataset to keep generalization?
- When tuning should i specify the classes to detect?
- When retraining should I use the first pretrained model or it is better to use my custom trained model?
- In the final training am I using the correct parameters?
Here the code of the pipeline:
from ultralytics import YOLO import yaml
load pretrained model from coco dataset
model:YOLO = YOLO('yolov8n.yaml').load('yolov8n.pt')
train_classes = []
NOTE if you're using COCO format, the new dataset should also be in COCO format.
operate transfer learning with my custom dataset, narrowing the classes to the ones I want to detect
model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,optimizer='AdamW',device=[0,1],augment=True,name='custom_model')
load custom model
custom_model = YOLO('path/to/best.pt')
validate custom model
custom_model.val()
try tuning to find the best hyperparameters for my custom model
custom_model.tune(data='custom_data.yaml', epochs=50, iterations=100,optimizer="AdamW", plots=True,save=True,val=True)
load best hyperparameters
cfg = yaml.load(open('path/to/best_hyperparameters.yaml'))
retrain custom model from pretrained on coco with best hyperparameters
model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,device=[0,1],name='custom_model',exist_ok=True,optimizer='AdamW',**cfg)
load and validate
tuned_custom_model = YOLO('path/to/best.pt')
tuned_custom_model.val()
Thank you for your effort and time in this project!
3
Paula DerrengerUltralytics(modifié)Hello,
Your approach to training a YOLO model for detection and tracking is well-thought-out and mostly aligns with best practices. Here are some insights and answers to your questions:
-
Approach Validity: Your steps are logically sound. Starting with a pretrained model and applying transfer learning to your specific classes is a recommended strategy. Validating and tuning based on the performance helps refine the model further.
-
Narrowing Detected Classes: It's perfectly fine to focus on specific classes if those are the only ones relevant to your use case. This can help improve the model's performance by reducing the complexity of the problem it needs to solve.
-
Dataset for Tuning: Use your custom dataset for tuning. This ensures that the hyperparameters are optimized for the specific characteristics of your data rather than the general characteristics of the COCO dataset.
-
Specifying Classes During Tuning: When tuning, you should specify the classes if your dataset is a subset of the original classes used in the pretrained model. This helps in focusing the model’s learning and evaluation on relevant classes.
-
Model for Retraining: Tuning only finds hyperparameters, so the usual practice is to train again from the original pretrained model with the best hyperparameters, as in your step 5. Continuing from the already fine-tuned model is also possible, but then it effectively trains for longer, which makes the result harder to compare with the tuning runs.
-
Parameters for Final Training: The parameters should be chosen based on the results of your tuning. Ensure that they are the ones that gave the best validation performance during the tuning phase.
Keep up the great work, and don't hesitate to reach out if you have more questions!
-
drcosimo
Thank you very much for you response. I adjusted my script to follow your insights. I have another question regarding transfer learning. The normal approach in transfer learning is to freeze the first n layers to preserve the more generic feature extraction properties of an already trained model and then it is retrained letting only the remaining layers update. I found the callback function to achieve this. My question is, applying the fine-tuning as specified by ultralytics documentation has the same effect? What I mean is: executing the train method again on a pretrained model changing the dataset causes the underlying library to execute the freeze automatically? If it isn't the case it is not clear to me why the fine-tuning is said to have the same effect as applying transfer learning.
Another question is: it is useful to take a pretrained model from ultralytics and train it with the coco dataset? Because from what I know the pretrained model is already trained using coco dataset. Doing such a thing following the logic you provide for fine-tuning would be essentially the same as resuming a training / do the same train with more epochs?
Thank you again for your time.
Paula DerrengerUltralyticsHello,
Thank you for your follow-up questions. Let's address each of them:
-
Freezing Layers in Transfer Learning: The Ultralytics YOLO framework does not automatically freeze any layers when you initiate training, even if you're using a pretrained model. If you want to freeze the first N layers (common in transfer learning to preserve learned features), you must explicitly specify this in your training script. This is different from some other frameworks that might automate this aspect of transfer learning.
-
Training on COCO Dataset with a Pretrained Model: If the pretrained model you are using was already trained on the COCO dataset, retraining it on the same dataset without significant changes or additional data might not yield substantial improvements. It could be beneficial for fine-tuning if you've made modifications to the model architecture or if you're using a significantly altered version of the dataset. However, generally, this approach would indeed be akin to simply extending the training duration.
For fine-tuning and transfer learning, it's crucial to tailor the approach based on what changes you've made to the dataset or model and your specific goals (e.g., improving accuracy, adapting to new classes, etc.).
I hope this clarifies your queries! If you have more questions or need further assistance, feel free to ask.
-
-
wangztao
这个翻译太那啥了吧, train翻译成火车?
3
Paula DerrengerUltralytics哈哈,确实,“train”翻译成“火车”听起来很有趣 😄。这里的“train”应该翻译为“训练”,指的是在机器学习中对模型进行训练,以提高其准确性和效率。感谢您指出这个问题,我们会尽快修正翻译错误。如果您有任何其他建议或问题,欢迎随时告诉我们!🚀
2
Syedshajib55
Hi, does platform.ultralytics currently support using custom PyTorch modules directly via a YAML configuration without modifying tasks.py or the core source code? We are attempting to train a custom architecture (e.g., YOLO26) and want to know if there is an existing feature for dynamic module registration.
1Muh-7
Hi, As far as I know, not at the moment. Ultralytics doesn't seem to have a built-in dynamic registration system where you can define a custom PyTorch module outside the repo and then use it directly in the YAML.
Usually, the custom module still needs to be imported/registered in
tasks.pyso thatparse_model()can resolve it from the YAML.It would be really useful if Ultralytics added something like a
register_module()API for this, though.
Murat Raimbekov@Syedshajib55 @Muh-7 Platform can train any model that the
ultralyticsPython package can build, including custom architectures from a modified package or fork. The custom code runs on your own hardware; Platform receives real-time metrics, console and system logs, plots, and the final weights.There is no dynamic registration API.
parse_model()resolves layer names from theultralytics.nn.tasksnamespace, so a name in your YAML must exist there. You don't need to edittasks.pyfor that — expose the class from your own package before building the model:import ultralytics.nn.tasks as tasks from my_custom_package import MyBlock tasks.MyBlock = MyBlock # now `[-1, 1, MyBlock, [...]]` resolves in the YAMLFull local training with metric streaming to Platform:
pip install "ultralytics>=8.4.120" export ULTRALYTICS_API_KEY="YOUR_API_KEY"import ultralytics.nn.tasks as tasks from my_custom_package import MyBlock from ultralytics import YOLO tasks.MyBlock = MyBlock model = YOLO("custom-model.yaml") # YAML referencing MyBlock model.train( data="ul://username/datasets/my-dataset", epochs=100, project="username/my-project", name="custom-architecture", )projectandnameenable the Platform integration automatically; nothing else is required. Verified on 8.4.157 with a customnn.Moduleinserted into a YOLO26n YAML: the model builds, trains, and appears on Platform as a completed run with weights and train args.One caveat: the saved
.ptpickles the class by import path (my_custom_package.MyBlock), so any environment that loads it needs that package importable — otherwise loading fails withModuleNotFoundError. That includes Platform-side features that load the uploaded weights with the stock package (Predict, Export, Deploy); local training and streaming are unaffected. Setup details: https://docs.ultralytics.com/platform/train/cloud-training/#remote-training
RussellLee12345
Hello all,
I want my training images to rotate 360 degrees randomly. How do I set the hyper-parameter: degrees?
Thanks a lot.
1
Glenn JocherUltralytics@RussellLee12345 to rotate your training images randomly up to 360 degrees, set the
degreesparameter to180in your training configuration. This allows for rotations within the range of -180 to +180 degrees. For more details, see the augmentation settings in the Train Settings documentation.
GKYoffice
Please tell me how to set imgsz when I use the yolo11 model for training. Can it only be an integer (this means that the final input is a square)? After I modify this parameter, will the input interface of the network change the input of data? There are corresponding transformations, such as imgsz=1280, does it mean that my input data will be resized to 1280*1280 and input into the network for training?
Thanks!
1
Glenn JocherUltralytics@GKYoffice when using the YOLO11 model,
imgszcan be set as an integer, which resizes the input data to a square of that size (e.g.,1280x1280). This parameter adjusts the input dimensions for training. For more details, please visit the training documentation.
IruhDegSet
hi, I'm just wondering if yolov8 accepts class weights, in the data.yaml file:
names: ['class 1', 'class 2', 'class 3'] classes_weights: [c1_weight, c2_weight, c3_weight]if no how to incorpoorate wighted loss in yolov8 THX
1IruhDegSet
I forgot to mention that the task is segmentation not bb detection
1
Glenn JocherUltralytics@IruhDegSet yOLOv8 does not directly support class weights in the
data.yamlfile. To incorporate weighted loss, you can modify the loss function in the training script to apply different weights to each class. For more details, you might explore custom loss implementations in PyTorch.IruhDegSet
@glenn-jocher thank you for your reply, does this apply on yolo v 11 too?
Glenn JocherUltralytics(modifié)Yes, YOLO11 supports similar features, including training and hyperparameter customization. For specific details on YOLO11, please refer to the documentation or the relevant sections in the repository.
UserDear author, how are the weights of these three losses set: box: 7.5, cls: 0.5, dfl: 1.5? Are they adjusted on the COCO validation, manually adjusted, or obtained through hyperparameter search? For the model I trained, the output confidence scores are very low. I directly increased the weight of cls by 10 times, but the effect did not improve. What other methods can I take?
1
Glenn JocherUltralytics@Stephen-Hao the weights for the
box,cls, anddfllosses in YOLOv8 are typically set based on empirical results and fine-tuning on standard datasets like COCO. These values are chosen to balance the contributions of each loss component to the overall training process. If increasing theclsweight did not improve your model's performance, consider the following approaches:- Hyperparameter Tuning: Experiment with other hyperparameters such as learning rate, batch size, and augmentation settings.
- Data Quality: Ensure your dataset is well-labeled and balanced. Poor quality data can significantly affect model performance.
- Training Duration: Increase the number of epochs to allow the model more time to learn.
- Validation: Regularly validate your model to monitor overfitting and adjust training strategies accordingly.
For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.
UserThank you a lot!
Glenn JocherUltralytics@Stephen-Hao thank you for your question! The weights for
box,cls, anddfllosses are typically set based on empirical results and fine-tuning on standard datasets like COCO. If increasing theclsweight didn't improve your model's performance, consider experimenting with other hyperparameters such as learning rate, batch size, and augmentation settings. Additionally, ensure your dataset is well-labeled and balanced. For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.
karthikUthaman
how to train a trained model again with new dataset
1
Glenn JocherUltralytics(modifié)Hey there! 🙌 It's awesome that you're looking to further improve your model with new data. To re-train a pre-trained model on a new dataset, you can simply follow these steps:
-
Make sure your new dataset is prepared in the same YOLO format as your initial training (a dataset YAML plus one
.txtlabel file per image). -
Load your pre-trained model using the
YOLOloading method, then specify your new dataset in thetrainmethod. Here's a quick code snippet for clarity:from ultralytics import YOLO # Load your pre-trained model model = YOLO('path/to/your/pretrained/model.pt') # Start training on the new dataset results = model.train(data='path/to/your/new/dataset.yaml', epochs=50, imgsz=640)
Just replace
'path/to/your/pretrained/model.pt'and'path/to/your/new/dataset.yaml'with the actual paths to your model and new dataset config file, respectively. Adjust theepochsandimgsz(image size) to suit your needs. 🛠️That's it! Your model will now continue training on the new dataset. If you have any further questions or run into issues, feel free to ask. Happy training! 🚀
-
songziang182
谢谢你们开发了这么完善的 yolov8🙏, 我想问一下,这两种训练方式的区别 model = YOLO('yolov8n.pt') model = YOLO('yolov8n.yaml').load('yolov8n.pt') model.train(.........)
1
Paula DerrengerUltralyticsHello there! 😊
The main difference between the two training methods you've mentioned:
-
model = YOLO('yolov8n.pt'): This directly loads a pretrained YOLOv8n model. It's the simplest way to load a model that has already been trained, making it ready for further training, evaluation, or inference right away. -
model = YOLO('yolov8n.yaml').load('yolov8n.pt'): This approach builds a new model from the YAML configuration file and then transfers the weights from the pretrained.ptmodel. It's a two-step process, where the model is first constructed based on the architecture defined in the YAML file, and then the weights from a pretrained model are loaded. This method is useful when you want to customize the model architecture before loading the weights.
Both methods ultimately get you to a similar starting point for continuing training or making predictions. The choice depends on whether you need to customize the model architecture as defined in the YAML file before applying the pretrained weights.
Let me know if this helps or if you have more questions!
-
songziang182
Thank you for answering me. I find it very useful. I have another question, which is the configuration file yolov8n.yaml. I didn’t find where it is. Can I adjust the scale of the model, for example, n, s, m, l, etc., is this the case?
Paula DerrengerUltralytics(modifié)Hey! 😊 Thank you for your kind words, and I'm glad the information was helpful to you!
Regarding the
yolov8n.yamlconfiguration file, it defines the architecture for YOLOv8 models. All scales share one model file (yolov8.yaml) that contains ascalessection mapping each letter to[depth, width, max_channels]; the letter in the name you load (yolov8n.yaml,yolov8s.yaml, ...) selects the scale:scales: n: [0.33, 0.25, 1024] s: [0.33, 0.50, 1024]To create or modify a model, copy the YAML from the Ultralytics GitHub repository, edit the layers or scales, then load it together with the pretrained weights as you mentioned:
model = YOLO('path/to/custom_yolov8.yaml').load('yolov8n.pt') model.train(.........)Model changes can require a solid understanding of the network architecture to be effective.
I hope this clarifies your question! Feel free to reach out if you have further queries or need more examples. 😊
vonzo
So, imgsz works different when training than when predicting?
For train: if it's an
intthe ratio will be kept and the train function will take care of that (can't be atuple). For predict: if it's anintthe image will be resized as a square of sizeimgsz x imgsz, if it's atuplethe image will be resized usingHxWand the user has to take care of the ratio andstride.Is this right? I would add a comment in the doc to avoid confusions
1
Paula DerrengerUltralytics(modifié)You've got it mostly right! 👍 For training (
train),imgszis anint, the aspect ratio is maintained and resizing is handled internally. It can't be atuple. For prediction (predict), anintimgszresizes the longest side toimgszwhile keeping the aspect ratio, with padding only up to a multiple of the model stride (so the image is not forced into a square), and a[h, w]list sets the size explicitly.Great suggestion on the documentation comment – clarity is key! If you have any more questions or need further examples, feel free to ask. 😊
