Link to this sectionRecette d'entraînement YOLO26#

Link to this sectionIntroduction#

Ce guide documente la recette d'entraînement exacte 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é dans les poids .pt publiés et peut être inspecté par programmation.

Savoir ce qui a servi à créer les points de contrôle officiels — pas seulement l'architecture, mais aussi les planifications de 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 fine-tuning : 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.

Link to this sectionPrésentation de l'entraînement#

Tous les modèles de base YOLO26 ont été entraînés sur COCO à une résolution de 640x640 en utilisant l'optimiseur MuSGD avec une taille de lot de 128. Plutôt que de commencer avec des poids aléatoires en une seule exécution, les modèles ont été initialisés à partir de poids pré-entraînés intermédiaires et affinés avec des hyperparamètres trouvés via recherche évolutionnaire. Les journaux d'entraînement 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 tête un-à-un sans NMS
• Optimiseur MuSGD combinant SGD avec des mises à jour orthogonalisées de style Muon pour les matrices de poids (paramètres avec ndim >= 2, tels que les poids de convolution et linéaires)
• Augmentation mosaïque intensive (probabilité ~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

Link to this sectionInspection 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 :

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 des versions officielles ou de tes propres modèles fine-tunés. Pour la liste complète des arguments d'entraînement configurables, consulte la référence de configuration d'entraînement.

Link to this sectionHyperparamè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 des train_args intégrés dans les points de contrôle publiés.

Link to this sectionOptimiseur 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 :

Link to this sectionPoids de perte#

Les poids de perte équilibrent les trois composantes de la perte de détection — régression IoU de boîte englobante (box), 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îte normalisées plutôt que la perte focale de distribution :

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 cohérente sur toutes les tailles.

Link to this sectionPipeline d'augmentation#

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

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 une augmentation globalement plus agressive (mixup, copy-paste et échelle plus élevés), car ils ont plus de capacité et bénéficient d'une régularisation plus forte. Le modèle N est la seule taille avec une augmentation significative de rotation, de cisaillement et de BGR.

Link to this sectionParamètres d'entraînement internes#

Link to this sectionFine-tuning de YOLO26 sur ton propre jeu de données#

Lorsque tu effectues un fine-tuning 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 en matière d'augmentation et d'optimisation issues de l'entraînement sur COCO. Pour des meilleures pratiques de formation plus générales, consulte les Conseils pour l'entraînement des modèles.

Link to this sectionFine-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.

Link to this sectionQuand ajuster les hyperparamètres de 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
• Diminue le taux d'apprentissage : lr0=0.001
• Utilise moins d'époques avec patience : epochs=50, patience=20
• Envisage 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
• Envisage optimizer=MuSGD pour les entraînements plus longs
• Augmente l'augmentation : mosaic=1.0, mixup=0.3, scale=0.9

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

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

Pour une optimisation automatisée des hyperparamètres, consulte le guide de réglage des hyperparamètres.

Link to this sectionChoisis une taille de modèle#

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

Link to this sectionConclusion#

Les checkpoints YOLO26 sont livrés avec leur recette d'entraînement complète intégrée, donc les hyperparamètres exacts derrière chaque taille de modèle sont toujours accessibles via une simple recherche train_args. Commence le fine-tuning avec les paramètres par défaut, ajuste délibérément en utilisant les tableaux de cette page, et vérifie chaque changement par rapport à ton propre jeu de validation. Si des questions surviennent en cours de route, demande à la communauté sur le dépôt GitHub Ultralytics ou sur le serveur Discord Ultralytics.

Link to this sectionFAQ#

Link to this sectionComment voir les hyperparamètres exacts utilisés pour n'importe quel checkpoint ?#

Charge le checkpoint avec torch.load() et accède à la clé train_args, ou utilise model.ckpt["train_args"] avec l'API Ultralytics. Consulte Inspecting YOLO26 Checkpoint Training Args pour des exemples complets.

Link to this sectionPourquoi le nombre d'époques est-il différent pour chaque taille de modèle ?#

Les modèles plus grands ont généralement eu besoin de moins d'époques sur COCO car leur plus grande capacité accélère la convergence — le modèle X a été entraîné pendant 40 époques contre 245 pour le N — bien que les nombres ne soient pas strictement monotones (S a utilisé 70, M a utilisé 80). Lors du fine-tuning 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.

Link to this sectionDois-je utiliser MuSGD pour le fine-tuning ?#

Habituellement, 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 explicitement définir optimizer=MuSGD si tu préfères. Pour en savoir plus sur le fonctionnement de MuSGD, consulte la documentation d'entraînement.

Link to this sectionQue sont muon_w, sgd_w, cls_w, o2m et topk dans le checkpoint ?#

Ce sont des paramètres internes issus du pipeline d'entraînement qui a généré les checkpoints de base, enregistrés dans train_args pour des raisons de reproductibilité. Ce ne sont pas des paramètres configurables par l'utilisateur dans default.yaml, et les transmettre à model.train() provoquera une erreur d'argument invalide — le package public ne les lit pas. Tu n'as pas besoin de les définir lors du fine-tuning ; consulte Paramètres d'entraînement internes pour leurs valeurs par taille de modèle.

Link to this sectionPuis-je reproduire exactement le pré-entraînement à partir de zéro ?#

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