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 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.

Comprendre comment les modèles de base ont été entraînés 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 sectionInspection des arguments d'entraînement#

Chaque point de contrôle Ultralytics stocke la configuration d'entraînement complète utilisée pour le produire. Tu peux inspecter ces paramètres à tout moment :

from ultralytics import YOLO

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

Cela fonctionne pour n'importe quel point de contrôle .pt — aussi bien pour les versions officielles que pour tes propres modèles affiné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 sectionVue d'ensemble 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. 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 une recherche évolutive. Les journaux d'entraînement complets et les métriques pour chaque taille de modèle sont disponibles sur Ultralytics Platform :

Principaux choix de conception 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 orthogonales de style Muon pour les poids de convolution
• Augmentation mosaic 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 de différentes tailles
• Rotation/cisaillement minimal pour la plupart des tailles, maintenant une faible distorsion géométrique

Link to this sectionHyperparamètres par taille de modèle#

Link to this sectionOptimiseur et taux d'apprentissage#

Link to this sectionPoids de perte#

Le modèle N donne la priorité à la perte DFL, tandis que les modèles S/M/L/X mettent l'accent sur la régression des boîtes englobantes. La perte de classification reste relativement cohérente pour 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 modèles plus grands utilisent une augmentation globalement plus agressive (plus de mixup, copy-paste et scale), 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, cisaillement et BGR.

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

Link to this sectionConseils pour le réglage fin#

Lors du réglage fin de YOLO26 sur ton propre jeu de données, tu n'as pas besoin de reproduire entièrement 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 d'entraînement plus générales, consulte les Conseils pour l'entraînement de modèles.

Link to this sectionCommencer simplement#

from ultralytics import YOLO

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

Le réglage fin avec les paramètres par défaut constitue une base solide. Ne modifie les hyperparamètres que si tu as une raison spécifique de le faire.

Link to this sectionQuand effectuer des ajustements#

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

• Réduis la force 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 de base : 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 exécutions plus longues
• Augmente l'augmentation : mosaic=1.0, mixup=0.3, scale=0.9

Imagerie spécifique à un 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 considérablement de celles de COCO

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

Link to this sectionChoisir 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 sectionFAQ#

Link to this sectionComment voir les hyperparamètres exacts utilisés pour n'importe quel point de contrôle ?#

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 Inspecter les arguments d'entraînement pour des exemples complets.

Link to this sectionPourquoi les nombres d'époques sont-ils différents pour chaque taille de modèle ?#

Les modèles plus grands convergent plus rapidement sur COCO car ils ont une plus grande capacité. Le modèle N avait besoin de 245 époques tandis que le modèle X n'en avait besoin que de 40. 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.

Link to this sectionDois-je utiliser MuSGD pour le réglage fin ?#

Lorsque optimizer=auto (le réglage par défaut), Ultralytics sélectionne automatiquement MuSGD pour les entraînements longs (>10 000 itérations) et AdamW pour les entraînements plus courts. Tu peux explicitement définir optimizer=MuSGD si tu préfères. Pour en savoir plus sur la sélection de l'optimiseur, consulte la documentation sur l'entraînement.

Link to this sectionQue sont muon_w, sgd_w, cls_w, o2m et topk dans le point de contrôle ?#

Ce sont des paramètres internes du pipeline d'entraînement qui ont produit les points de contrôle de base. Ils sont stockés pour la reproductibilité mais ne sont pas des paramètres configurables par l'utilisateur dans default.yaml. Tu n'as pas besoin de les définir lors du réglage fin. Consulte Paramètres d'entraînement internes pour plus de détails.

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

Les points de contrôle ont été produits à l'aide d'une branche d'entraînement interne avec des fonctionnalités supplémentaires absentes de la base de code publique (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 package public Ultralytics, mais une reproduction exacte nécessite la branche interne.