YOLO Vision 2026 :

Recette d'entraînement YOLO26#

Introduction#

Ce guide documente la recette d'entraînement exacte utilisée pour produire les points de contrôle pré-entraînés officiels YOLO26 sur COCO. Chaque hyperparamètre présenté ici est déjà intégré dans les poids publiés de .pt et peut être inspecté par programmation.

Savoir ce qui a entré dans la composition des points de contrôle officiels — non seulement l'architecture, mais aussi les planifications du taux d'apprentissage, les pipelines d'augmentation et les poids de perte qui ont façonné leurs performances — t'aide à prendre de meilleures décisions lors du réglage fin : quelles augmentations de données conserver, quels poids de fonction de perte ajuster et quels paramètres d'optimiseur fonctionnent le mieux pour la taille de ton jeu de données.

Présentation de l'entraînement#

Tous les modèles de base YOLO26 ont été entra&eetés sur COCO à la résolution 640x640 en utilisant l'optimiseur MuSGD avec une taille de lot de 128. Plut&442;t que de partir de poids aléatoires en un seul exécution, les modèles ont été initialisés à partir de poids préentra&eetés intermédiaires et affinés avec des hyperparamètres trouvés par recherche évolutionnaire. Les journaux d'entra&eetement complets et les métriques pour chaque taille de modèle sont disponibles sur Ultralytics Platform.

Choix de conception clés pour toutes les tailles :

  • Entraînement de bout en bout (end2end=True) avec une tête bi-univoque sans NMS
  • Optimiseur MuSGD combinant SGD avec des mises à jour orthogonalisées de style Muon pour les matrices de poids (poids linéaires 2D et filtres de conv 4D, qui sont remodelés en 2D)
  • Forte augmentation de type mosaïque (probabilité de ~0,9-1,0) désactivée lors des 10 dernières époques (close_mosaic=10)
  • Augmentation d'échelle agressive (0.56-0.95) pour gérer les objets à différentes tailles
  • Rotation/cisaillement minimal pour la plupart des tailles, maintenant une faible distorsion géométrique

Inspection des arguments d'entraînement des points de contrôle YOLO26#

Chaque point de contrôle Ultralytics stocke la configuration d'entraînement complète utilisée pour le produire, afin que tu puisses vérifier chaque chiffre sur cette page toi-même :

Inspecter les arguments d'entraînement du point de contrôle
from ultralytics import YOLO

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

La sortie liste la configuration complète de plus de 100 entrées, incluant chaque valeur de recette documentée sur cette page. 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

Cela fonctionne pour n'importe quel point de contrôle .pt — qu'il s'agisse de versions officielles ou de tes propres modèles affinés. Pour obtenir la liste complète des arguments d'entraînement configurables, consulte la référence de configuration d'entraînement.

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

Les tableaux ci-dessous regroupent la recette par catégorie — optimiseur et planification, poids de perte et augmentation. Chaque valeur provient directement de train_args intégré dans les points de contrôle publiés.

Optimiseur et taux d'apprentissage#

Ces paramètres d'optimiseur et de planification ont conduit le pré-entraînement COCO pour chaque taille ; remarque comment le modèle N se distingue des autres :

ParamètreNSMLX
optimizerMuSGDMuSGDMuSGDMuSGDMuSGD
lr00.00540.000380.000380.000380.00038
lrf0.04950.8820.8820.8820.882
momentum0.9470.9480.9480.9480.948
weight_decay0.000640.000270.000270.000270.00027
warmup_epochs0.980.990.990.990.99
epochs24570806040
batch128128128128128
imgsz640640640640640
Stratégie de taux d'apprentissage

Le modèle N a utilisé un taux d'apprentissage initial plus élevé avec une décroissance prononcée (lrf=0.0495), tandis que les modèles S/M/L/X ont utilisé un taux d'apprentissage initial beaucoup plus bas avec une planification plus douce (lrf=0.882). Cela reflète les dynamiques de convergence différentes entre les petits et les grands modèles — les petits modèles nécessitent des mises à jour plus agressives pour apprendre efficacement.

Poids de perte#

Les poids de perte équilibrent les trois composantes de la perte de détection — la régression IoU de boîte englobante (box), la classification (cls) et un terme de régression de distance de boîte (dfl). Note que YOLO26 sans DFL réutilise le gain dfl pour pondérer une perte L1 sur les distances de boîtes normalisées plutôt que la perte focale de distribution :

ParamètreNSMLX
box5.639.839.839.839.83
cls0.560.650.650.650.65
dfl9.040.960.960.960.96

Le modèle N donne la priorité au terme de régression de distance dfl, tandis que les modèles S/M/L/X déplacent l'accent vers la régression de boîte basée sur l'IoU. La perte de classification reste relativement constante à travers toutes les tailles.

Pipeline d'augmentation#

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

ParamètreNSMLX
mosaic0.9090.9920.9920.9920.992
mixup0.0120.050.4270.4270.427
copy_paste0.0750.4040.3040.4040.404
scale0.5620.90.950.950.95
fliplr0.6060.3040.3040.3040.304
degrees1.11~0~0~0~0
shear1.46~0~0~0~0
translate0.0710.2750.2750.2750.275
hsv_h0.0140.0130.0130.0130.013
hsv_s0.6450.3530.3530.3530.353
hsv_v0.5660.1940.1940.1940.194
bgr0.1060.00.00.00.0

Les valeurs affiché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 effectivement désactivée.

Les modèles plus grands utilisent globalement une augmentation plus agressive (mixup, copy-paste et échelle plus élevés), car ils disposent d'une plus grande capacité et bénéficient d'une régularisation plus forte. Le modèle N est la seule taille dotée d'une augmentation significative de rotation, de cisaillement et BGR.

Paramètres d'entraînement internes#

Avancé : paramètres de pipeline internes

Les points de contrôle contiennent également des paramètres qui ont été utilisés dans le pipeline d'entraînement interne mais qui ne sont pas exposés en tant que paramètres configurables par l'utilisateur dans default.yaml :

ParamètreDescriptionNSMLX
muon_wPoids de mise à jour Muon dans MuSGD0.5280.4360.4360.4360.436
sgd_wPoids de mise à jour SGD dans MuSGD0.6740.4790.4790.4790.479
cls_wPoids de classification interne2.743.483.483.483.48
o2mPoids de la perte de la tête one-to-many1.00.7050.7050.7050.705
topkAssignation d'étiquettes Top-k85555

Consulte l'entrée de la FAQ sur ces paramètres pour comprendre ce qu'ils signifient lors du réglage fin.

Fine-tuning de YOLO26 sur ton propre jeu de données#

Lors du réglage fin de YOLO26 sur ton propre jeu de données, tu n'as pas besoin de reproduire l'intégralité de la recette de pré-entraînement. Les poids pré-entraînés encodent déjà les connaissances d'augmentation et d'optimisation issues de l'entraînement sur COCO. Pour de meilleures pratiques d'entraînement plus générales, consulte les conseils pour l'entraînement de modèles.

Fine-tuning avec les paramètres par défaut#

Fine-tuning 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)

Le fine-tuning avec les paramètres par défaut constitue une excellente base. N'ajuste les hyperparamètres que si tu as une raison spécifique de le faire.

Quand ajuster les hyperparamètres de YOLO26#

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

  • Réduire la force de l'augmentation : mosaic=0.5, mixup=0.0, copy_paste=0.0
  • Diminuer le taux d'apprentissage : lr0=0.001
  • Utiliser moins d'époques avec la patience : epochs=50, patience=20
  • Envisager de geler les couches du backbone : freeze=10

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

  • Respecte plus fidèlement la recette de pré-entraînement
  • Envisager optimizer=MuSGD pour les entraînements plus longs
  • Augmenter l'augmentation : mosaic=1.0, mixup=0.3, scale=0.9

Imagerie spécifique au domaine (aérienne, médicale, sous-marine) :

  • Augmenter flipud=0.5 si l'orientation verticale varie
  • Augmenter degrees si les objets apparaissent à des rotations arbitraires
  • Ajuster hsv_s et hsv_v si les conditions d'éclairage diffèrent considérablement de COCO

Pour l'optimisation automatisée des hyperparamètres, consulte le guide d'optimisation des hyperparamètres.

Choisis une taille de modèle#

ModèleIdéal pourConseils sur la taille des lots
YOLO26nAppareils Edge, mobile, temps réel sur CPUGrands lots (64-128) sur GPU grand public
YOLO26sVitesse et précision équilibréesLots moyens (32-64)
YOLO26mMeilleure précision avec un calcul modéréPetits lots (16-32)
YOLO26lHaute précision lorsque le GPU est disponiblePetits lots (8-16) ou multi-GPU
YOLO26xPrécision maximale, déploiement serveurPetits lots (4-8) ou multi-GPU

Pour les options d'exportation et de déploiement, consulte le guide d'exportation et les options de déploiement de modèles.

Conclusion#

Les points de contrôle YOLO26 sont livrés avec leur recette d'entraînement complète intégrée, de sorte que les hyperparamètres exacts derrière chaque taille de modèle ne sont toujours qu'à une recherche train_args près. Commence le réglage fin à partir des valeurs par défaut, ajuste délibérément en utilisant les tableaux de cette page et vérifie chaque modification par rapport à ton propre jeu de validation. Si des questions se posent en chemin, pose les questions à la communauté sur le dépôt GitHub d'Ultralytics ou sur le serveur Discord d'Ultralytics.

FAQ#

  • Charge le point de contrôle avec torch.load() et accède à la clé train_args, ou utilise model.ckpt["train_args"] avec l'API Ultralytics. Consulte Inspection des arguments d'entraînement du point de contrôle YOLO26 pour des exemples complets.

  • Les modèles plus grands ont généralement nécessité moins d'époques sur COCO parce que leur plus grande capacité accélère la convergence — le modèle X a été entraîné pendant 40 époques contre 245 pour le modèle N — bien que les nombres ne soient pas strictement monotones (S a utilisé 70, M a utilisé 80). Lors du réglage fin sur ton propre jeu de données, le nombre optimal d'époques dépend de la taille et de la complexité de ton jeu de données, et non de la taille du modèle. Utilise l'arrêt précoce (patience) pour trouver automatiquement le bon point d'arrêt.

  • Généralement, tu n'as pas besoin de choisir : avec le paramètre par défaut optimizer=auto, Ultralytics sélectionne automatiquement MuSGD pour les entraînements plus longs (>10 000 itérations) et AdamW pour les plus courts. Tu peux définir explicitement optimizer=MuSGD si tu préfères. Pour en savoir plus sur le fonctionnement de MuSGD, consulte la documentation sur l'entraînement.

  • Ce sont des paramètres internes du pipeline d'entraînement qui a produit les points de contrôle de base, enregistrés dans train_args pour la reproductibilité. Ce ne sont pas des paramètres configurables par l'utilisateur dans default.yaml, et les passer à model.train() déclenche une erreur d'argument invalide — le paquet public ne les lit pas. Tu n'as pas besoin de les définir lors du réglage fin ; consulte les paramètres d'entraînement internes pour connaître leurs valeurs par taille de modèle.

  • Pas exactement — les points de contrôle ont été produits en utilisant une branche d'entraînement interne avec des fonctionnalités supplémentaires absentes du code source public (comme les poids configurables o2m et cls_w). Tu peux obtenir des résultats très proches en utilisant les hyperparamètres documentés sur cette page avec le paquet public Ultralytics, mais une reproduction exacte nécessite la branche interne.

Commentaires