Recette d’entraînement de YOLO26#

Introduction#

Ce guide documente la recette exacte d’entraînement utilisée pour produire les points de contrôle préentraînés officiels de YOLO26 sur COCO. Chaque hyperparamètre présenté ici est déjà intégré aux poids .pt publiés, avec le journal d’entraînement par époque et la révision du code utilisée, et tout cela peut être examiné par programmation.

Savoir ce qui a servi à créer les points de contrôle officiels — pas seulement l’architecture, mais aussi les programmes de taux d’apprentissage, les pipelines d’augmentation et les poids des fonctions de perte qui ont façonné leurs performances — t’aide à prendre de meilleures décisions lors de l’ajustement fin : quelles augmentations de données conserver, quels poids de la fonction de perte ajuster et quels réglages d’optimiseur conviennent le mieux à la taille de ton jeu de données.

Aperçu de l’entraînement#

Tous les modèles de base YOLO26 ont été entraînés en deux étapes : préentraînement sur Objects365v1 pendant 150 époques, suivi d’un ajustement fin sur COCO. Les deux étapes ont utilisé une résolution de 640x640, l’optimiseur MuSGD et une taille de lot de 128. Aucun point de contrôle YOLO26 n’a été entraîné sur COCO à partir de poids aléatoires, ce qui explique la brièveté de l’étape COCO pour la plupart des tailles. Les hyperparamètres de l’étape COCO ont été déterminés par recherche évolutionnaire. Les journaux d’entraînement et les métriques complets de chaque taille de modèle sont stockés dans les points de contrôle publiés et affichés sous forme de graphiques sur Ultralytics Platform.

Principaux choix de conception pour toutes les tailles :

• Préentraînement sur Objects365 pour chaque taille avant l’étape COCO
• Entraînement à double tête avec supervision one-to-many et one-to-one ; l’inférence utilise NMS par défaut, tandis que nms=False sélectionne la tête sans NMS
• Optimiseur MuSGD combinant SGD et des mises à jour orthogonalisées de type Muon pour les matrices de poids (poids linéaires 2D et filtres convolutifs 4D, remodelés en 2D)
• Augmentation mosaic intensive (~0.9-1.0 de probabilité), désactivée lors des dernières époques (close_mosaic=8 pendant le préentraînement, close_mosaic=10 sur COCO)
• Augmentation d’échelle agressive (0.5-0.95) pour traiter des objets de tailles différentes
• Rotation et cisaillement minimaux pour la plupart des tailles, afin de limiter la distorsion géométrique

Étape 1 : préentraînement sur Objects365#

Chaque point de contrôle YOLO26 sur COCO a été ajusté à partir d’un point de contrôle Objects365v1 de même taille. Ces poids préentraînés sont également publiés et décrits sur la page du jeu de données Objects365. Le fichier .pt de chaque point de contrôle COCO indique les poids de départ dans sa configuration d’entraînement intégrée ; la section Inspection des paramètres d’entraînement des points de contrôle YOLO26 ci-dessous explique comment les lire :

Le préentraînement utilisait principalement les paramètres par défaut plutôt que des valeurs issues d’une recherche. lr0, lrf, momentum, weight_decay, box et cls correspondent à default.yaml, tandis que warmup_epochs, close_mosaic et dfl ont été remplacés. Les paramètres sont communs à toutes les tailles, à l’exception de warmup_epochs pour X, des intensités d’augmentation et des poids internes de MuSGD et de la tête indiqués après les tableaux :

Ces tableaux présentent les paramètres qui influencent le préentraînement, et non la configuration complète. Les points de contrôle enregistrent plus de 100 arguments ; affiche train_args comme indiqué ci-dessous pour obtenir la liste de référence.

from ultralytics import YOLO

model = YOLO("yolo26s-objv1-150.pt")
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)

Inspecter les arguments d’entraînement du point de contrôle YOLO26#

Chaque point de contrôle Ultralytics stocke la configuration d’entraînement complète utilisée pour le produire, tu peux donc vérifier toi-même chaque valeur de cette page :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
print(model.ckpt["train_args"])

La sortie répertorie la configuration complète, qui compte plus de 100 entrées, notamment chaque valeur de recette documentée sur cette page. Voici un extrait pour yolo26n.pt :

batch: 128
...
box: 5.62767
...
close_mosaic: 10
cls: 0.56099
...
dfl: 9.03871
...
epochs: 245
...
lr0: 0.0054
lrf: 0.04952
...
optimizer: MuSGD

Cette méthode fonctionne avec n’importe quel point de contrôle .pt — qu’il s’agisse de versions officielles ou de tes propres modèles affinés. Pour consulter la liste complète des arguments d’entraînement configurables, reporte-toi à la référence de configuration de l’entraînement.

Afficher les courbes d’entraînement#

train_args n'est pas la seule chose stockée. Chaque point de contrôle contient aussi les données complètes de results.csv pour chaque époque de l'entraînement qui l'a produit, ainsi que ses métriques finales de validation. Les courbes des points de contrôle officiels YOLO26 sont publiées sur Ultralytics Platform, et n'importe quel fichier .pt peut être glissé-déposé dans un projet pour tracer les mêmes données, les métadonnées étant automatiquement extraites du fichier.

Chaque point de contrôle couvre l’étape qui l’a produit : les courbes COCO se trouvent donc dans yolo26s.pt et les courbes Objects365 sur 150 époques dans yolo26s-objv1-150.pt.

Vérifier la révision du code#

ckpt["git"] indique le commit qui a produit le point de contrôle, et ces commits se trouvent sur les branches expérimentales publiques du dépôt Ultralytics ; tu peux donc extraire la version exacte du code d’entraînement :

from ultralytics import YOLO

print(YOLO("yolo26n.pt").ckpt["git"])
# {'root': ..., 'branch': 'exp-main', 'commit': 'cb13d5f9cfbd6f299da3620c625f81d721dc2849', ...}

git fetch origin cb13d5f9cfbd6f299da3620c625f81d721dc2849
git checkout cb13d5f9cfbd6f299da3620c625f81d721dc2849

Les branches expérimentales contiennent des travaux qui n’ont jamais été intégrés à main, comme les éléments o2m et cls_w configurables. L’entraînement sur main avec les hyperparamètres documentés ci-dessous ne sera pas identique bit à bit, mais les résultats seront pratiquement équivalents aux métriques publiées.

Hyperparamètres d’entraînement YOLO26 par taille de modèle#

Voici les valeurs de l’étape 2, appliquées aux poids Objects365 ci-dessus. Les tableaux ci-dessous regroupent la recette par catégorie : optimiseur et calendrier, coefficients de perte et augmentation. Chaque valeur provient directement de train_args, intégré aux points de contrôle publiés.

Optimiseur et taux d’apprentissage#

Ces paramètres d’optimiseur et de calendrier ont servi à l’affinage sur COCO pour chaque taille ; note que le modèle N se distingue des autres :

Coefficients de perte#

Les coefficients de perte équilibrent les trois composantes de la perte de détection : la régression IoU des boîtes englobantes (box), la classification (cls) et un terme de régression de la distance des boîtes (dfl). Note que YOLO26, qui n’utilise pas DFL, réaffecte le coefficient dfl à une perte L1 sur les distances normalisées des boîtes plutôt qu’à une perte focale de distribution :

Le modèle N privilégie le terme de régression de distance dfl, tandis que les modèles S/M/L/X mettent davantage l’accent sur la régression des boîtes fondée sur l’IoU. La perte de classification reste relativement constante pour toutes les tailles.

Pipeline d’augmentation#

Pour une explication détaillée de chaque technique, consulte le guide sur l’augmentation des données YOLO.

Les valeurs indiquées comme ~0 sont inférieures à 0,01 dans les points de contrôle réels (par exemple, degrees=0.00012 pour le modèle S) : l’augmentation est de fait désactivée.

Les grands modèles utilisent globalement des augmentations plus agressives (mixup et échelle plus élevés), car ils ont une plus grande capacité et tirent parti d’une régularisation plus forte. Le modèle N est le seul à utiliser des augmentations significatives de rotation, de cisaillement et de BGR.

Paramètres d’entraînement internes#

Affiner YOLO26 sur ton propre jeu de données#

Lorsque tu affines YOLO26 sur ton propre jeu de données, tu n’as pas besoin de reproduire toute la recette de préentraînement. Les poids préentraînés intègrent déjà les connaissances d’augmentation et d’optimisation acquises pendant l’entraînement sur COCO. Pour connaître les bonnes pratiques générales d’entraînement, consulte les Conseils pour l’entraînement des modèles.

Affiner avec les paramètres par défaut#

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)

L’affinage avec les paramètres par défaut constitue une excellente base. Ne modifie les hyperparamètres que si tu as une raison précise de le faire.

Quand ajuster les hyperparamètres YOLO26#

Petits jeux de données (< 1 000 images) :

• Réduis l’intensité de l’augmentation : mosaic=0.5, mixup=0.0, copy_paste=0.0
• Réduis le taux d’apprentissage et indique explicitement un optimiseur : optimizer=AdamW, lr0=0.001
• Utilise moins d’époques avec une patience définie : epochs=50, patience=20
• Envisage de geler les couches du backbone : freeze=10

Grands jeux de données (> 50 000 images) :

• Reprends plus fidèlement la recette de préentraînement
• Envisage optimizer=MuSGD pour les entraînements plus longs
• Augmente l’augmentation : mosaic=1.0, mixup=0.3, scale=0.9

Images propres à un domaine (aériennes, médicales, sous-marines) :

• Augmente flipud=0.5 si l’orientation verticale varie
• Augmente degrees si les objets apparaissent avec des rotations quelconques
• Ajuste hsv_s et hsv_v si les conditions d’éclairage diffèrent fortement de celles de COCO

Pour optimiser automatiquement les hyperparamètres, consulte le guide de réglage des hyperparamètres.

Choisir une taille de modèle#

Pour connaître les options d’exportation et de déploiement, consulte le guide d’exportation et les options de déploiement des modèles.

Conclusion#

Les points de contrôle YOLO26 incluent leur recette d’entraînement complète ; les hyperparamètres exacts de chaque taille de modèle sont donc toujours accessibles en recherchant train_args. Commence l’affinage avec les paramètres par défaut, ajuste-les de façon réfléchie à l’aide des tableaux de cette page et vérifie chaque modification sur ton propre jeu de validation. Si tu as des questions en cours de route, adresse-toi à la communauté sur le dépôt GitHub d’Ultralytics ou le serveur Discord d’Ultralytics.

FAQ#