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 :
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: MuSGDCela 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ètre | N | S | M | L | X |
|---|---|---|---|---|---|
optimizer | MuSGD | MuSGD | MuSGD | MuSGD | MuSGD |
lr0 | 0.0054 | 0.00038 | 0.00038 | 0.00038 | 0.00038 |
lrf | 0.0495 | 0.882 | 0.882 | 0.882 | 0.882 |
momentum | 0.947 | 0.948 | 0.948 | 0.948 | 0.948 |
weight_decay | 0.00064 | 0.00027 | 0.00027 | 0.00027 | 0.00027 |
warmup_epochs | 0.98 | 0.99 | 0.99 | 0.99 | 0.99 |
epochs | 245 | 70 | 80 | 60 | 40 |
batch | 128 | 128 | 128 | 128 | 128 |
imgsz | 640 | 640 | 640 | 640 | 640 |
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ètre | N | S | M | L | X |
|---|---|---|---|---|---|
box | 5.63 | 9.83 | 9.83 | 9.83 | 9.83 |
cls | 0.56 | 0.65 | 0.65 | 0.65 | 0.65 |
dfl | 9.04 | 0.96 | 0.96 | 0.96 | 0.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ètre | N | S | M | L | X |
|---|---|---|---|---|---|
mosaic | 0.909 | 0.992 | 0.992 | 0.992 | 0.992 |
mixup | 0.012 | 0.05 | 0.427 | 0.427 | 0.427 |
copy_paste | 0.075 | 0.404 | 0.304 | 0.404 | 0.404 |
scale | 0.562 | 0.9 | 0.95 | 0.95 | 0.95 |
fliplr | 0.606 | 0.304 | 0.304 | 0.304 | 0.304 |
degrees | 1.11 | ~0 | ~0 | ~0 | ~0 |
shear | 1.46 | ~0 | ~0 | ~0 | ~0 |
translate | 0.071 | 0.275 | 0.275 | 0.275 | 0.275 |
hsv_h | 0.014 | 0.013 | 0.013 | 0.013 | 0.013 |
hsv_s | 0.645 | 0.353 | 0.353 | 0.353 | 0.353 |
hsv_v | 0.566 | 0.194 | 0.194 | 0.194 | 0.194 |
bgr | 0.106 | 0.0 | 0.0 | 0.0 | 0.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ètre | Description | N | S | M | L | X |
|---|---|---|---|---|---|---|
muon_w | Poids de mise à jour Muon dans MuSGD | 0.528 | 0.436 | 0.436 | 0.436 | 0.436 |
sgd_w | Poids de mise à jour SGD dans MuSGD | 0.674 | 0.479 | 0.479 | 0.479 | 0.479 |
cls_w | Poids de classification interne | 2.74 | 3.48 | 3.48 | 3.48 | 3.48 |
o2m | Poids de la perte de la tête one-to-many | 1.0 | 0.705 | 0.705 | 0.705 | 0.705 |
topk | Assignation d'étiquettes Top-k | 8 | 5 | 5 | 5 | 5 |
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#
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=MuSGDpour 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.5si l'orientation verticale varie - Augmenter
degreessi les objets apparaissent à des rotations arbitraires - Ajuster
hsv_sethsv_vsi 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èle | Idéal pour | Conseils sur la taille des lots |
|---|---|---|
| YOLO26n | Appareils Edge, mobile, temps réel sur CPU | Grands lots (64-128) sur GPU grand public |
| YOLO26s | Vitesse et précision équilibrées | Lots moyens (32-64) |
| YOLO26m | Meilleure précision avec un calcul modéré | Petits lots (16-32) |
| YOLO26l | Haute précision lorsque le GPU est disponible | Petits lots (8-16) ou multi-GPU |
| YOLO26x | Précision maximale, déploiement serveur | Petits 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#
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 explicitementoptimizer=MuSGDsi 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_argspour la reproductibilité. Ce ne sont pas des paramètres configurables par l'utilisateur dansdefault.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
o2metcls_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.
Charge le point de contrôle avec
torch.load()et accède à la clétrain_args, ou utilisemodel.ckpt["train_args"]avec l'API Ultralytics. Consulte Inspection des arguments d'entraînement du point de contrôle YOLO26 pour des exemples complets.