Formation Cloud
Ultralytics Platform Cloud Training propose un entraînement en un clic sur des GPU cloud, rendant l'entraînement de modèles accessible sans configuration complexe. Entraînez des modèles YOLO avec un streaming de métriques en temps réel et une sauvegarde automatique des points de contrôle.
graph LR
A[Configure] --> B[Start Training]
B --> C[Provision GPU]
C --> D[Download Dataset]
D --> E[Train]
E --> F[Stream Metrics]
F --> G[Save Checkpoints]
G --> H[Complete]
style A fill:#2196F3,color:#fff
style B fill:#FF9800,color:#fff
style E fill:#9C27B0,color:#fff
style H fill:#4CAF50,color:#fff
Dialogue de formation
Commencez la formation à partir de l'interface utilisateur de la plateforme en cliquant sur Nouveau modèle sur n'importe quelle page de projet (ou sur Former à partir d'une page de jeu de données). La boîte de dialogue de formation comporte deux onglets : Formation dans le cloud et Formation locale.

Étape 1 : Sélectionnez le modèle de base
Choisissez parmi les modèles officiels YOLO26 ou vos propres modèles entraînés :
| Catégorie | Description |
|---|---|
| Officiel | Les 25 modèles YOLO26 (5 tailles x 5 tâches) |
| Vos modèles | Vos modèles finalisés pour le réglage fin |
Les modèles officiels sont classés par type de tâche (détection, segmentation, pose, OBB, classification) et par taille, de nano à xlarge.
Étape 2 : Sélectionnez l'ensemble de données
Choisissez un jeu de données pour l'entraînement (voir Jeux de données):
| Option | Description |
|---|---|
| Officiel | Ensembles de données organisés par Ultralytics |
| Vos jeux de données | Jeux de données que vous avez téléchargés |
Prérequis du jeu de données
Les jeux de données doivent être au format ready statut avec au moins 1 image dans la partition d'entraînement, 1 image dans la partition de validation ou de test, et au moins 1 image étiquetée.
Inadéquation des tâches
Un avertissement d'incompatibilité de tâche apparaît si la tâche du modèle (par exemple, detect) ne correspond pas à la tâche du jeu de données (par exemple, segment). L'entraînement échouera si vous continuez avec des tâches incompatibles. Assurez-vous que le modèle et le jeu de données utilisent le même type de tâche, comme décrit dans les guides de tâches.
Étape 3 : Configurer les paramètres
Définir les paramètres de base de l'entraînement :
| Paramètre | Description | Par défaut |
|---|---|---|
| Époques | Nombre d'itérations d'entraînement | 100 |
| Taille du lot | Échantillons par itération | 16 |
| Taille de l'image | Résolution d'entrée (menu déroulant 320/416/512/640/1280, ou 32-4096 dans l'éditeur YAML) | 640 |
| Nom de l'exécution | Nom facultatif pour la course d'entraînement | auto |
Étape 4 : Paramètres avancés (facultatif)
Développez les paramètres avancés pour accéder à l'éditeur de paramètres complet basé sur YAML, qui comprend plus de 40 paramètres d'entraînement organisés par groupe (voir la référence de configuration) :
| Groupe | Paramètres |
|---|---|
| Taux d'apprentissage | lr0, lrf, momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
| Optimiseur | SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Poids perdus | boîte, cls, dfl, pose, kobj, lissage d'étiquettes |
| Augmentation colorimétrique | hsv_h, hsv_s, hsv_v |
| Augmentation géométrique. | degrés, translation, échelle, cisaillement, perspective |
| Flip & Mix Augment. | flipud, fliplr, mosaïque, mixup, copier-coller |
| Contrôle de la formation | patience, graine, déterministe, amp, cos_lr, close_mosaic, save_period |
| Ensemble de données | fraction, gel, single_cls, rect, multi_scale, reprise |
Les paramètres sont adaptés à la tâche (par exemple, copy_paste s'affiche uniquement pour segment , pose/kobj uniquement pour les tâches de pose). A Modifié un badge apparaît lorsque les valeurs diffèrent des valeurs par défaut, et vous pouvez tout réinitialiser aux valeurs par défaut avec le bouton de réinitialisation.
Exemple : augmentation de l'ajustement pour les petits ensembles de données
For small datasets (<1000 images), increase augmentation to reduce overfitting:
mosaic: 1.0 # Keep mosaic on
mixup: 0.3 # Add mixup blending
copy_paste: 0.3 # Add copy-paste (segment only)
fliplr: 0.5 # Horizontal flip
degrees: 10.0 # Slight rotation
scale: 0.9 # Aggressive scaling
Étape 5 : Sélectionnez GPU onglet Cloud)
Choisissez votre GPU depuis Ultralytics Cloud :

| GPU | Génération | VRAM | Coût/Heure | Idéal pour |
|---|---|---|---|---|
| RTX 2000 Ada | Ada | 16 Go | $0.24 | Petits jeux de données, tests |
| RTX A4500 | Ampere | 20 Go | $0.25 | Jeux de données petits et moyens |
| RTX 4000 Ada | Ada | 20 Go | $0.26 | Jeux de données moyens |
| RTX A5000 | Ampere | 24 Go | $0.27 | Jeux de données moyens |
| L4 | Ada | 24 Go | $0.39 | Optimisé pour l'inférence |
| A40 | Ampere | 48 Go | $0.40 | Tailles de lot plus grandes |
| RTX 3090 | Ampere | 24 Go | $0.46 | Entraînement général |
| RTX A6000 | Ampere | 48 Go | $0.49 | Grands modèles |
| RTX PRO 4500 | Blackwell | 32 Go | $0.54 | Excellent rapport qualité/prix |
| RTX 4090 | Ada | 24 Go | $0.59 | Meilleur rapport performance/prix |
| RTX 6000 Ada | Ada | 48 Go | $0.77 | Entraînement par grands lots |
| L40S | Ada | 48 Go | $0.86 | Entraînement par grands lots |
| RTX 5090 | Blackwell | 32 Go | $0.89 | Dernière génération grand public |
| L40 | Ada | 48 Go | $0.99 | Grands modèles |
| A100 PCIe | Ampere | 80 Go | $1.39 | Entraînement pour la production |
| A100 SXM | Ampere | 80 Go | $1.49 | Entraînement pour la production |
| RTX PRO 6000 | Blackwell | 96 Go | $1.69 | Par défaut recommandé |
| H100 PCIe | Hopper | 80 Go | $2.39 | Entraînement haute performance |
| H100 SXM | Hopper | 80 Go | $2.69 | Entraînement le plus rapide |
| H100 NVL | Hopper | 94 Go | $3.07 | Performances maximales |
| H200 NVL | Hopper | 143 Go | $3.39 | Mémoire maximale (Pro+) |
| H200 SXM | Hopper | 141 Go | $3.59 | Performances maximales (Pro+) |
| B200 | Blackwell | 180 Go | $4.99 | Modèles les plus grands (Pro+) |
Sélection du GPU
- RTX PRO 6000 : Génération Blackwell 96 Go, par défaut recommandé pour la plupart des tâches
- A100 SXM: Requis pour les grandes tailles de lot ou les grands modèles.
- H100/H200: Performances optimales pour les entraînements où le temps est un facteur déterminant (le modèle H200 nécessite la version Pro ou Enterprise)
- B200: Architecture NVIDIA Blackwell pour les charges de travail de pointe (nécessite Pro ou Enterprise)
La boîte de dialogue affiche votre solde actuel et un bouton Recharger. Le coût et la durée estimés sont calculés en fonction de votre configuration (taille du modèle, images de l'ensemble de données, époques, GPU ).
Étape 6 : Commencez l'entraînement
Cliquez sur Démarrer l'entraînement pour lancer votre tâche. La plateforme :
- Provisionne une instance GPU
- Télécharge votre jeu de données
- Démarre l'entraînement
- Diffuse les métriques en temps réel
Cycle de vie des formations
Les tâches de formation passent par les statuts suivants :
| Statut | Description |
|---|---|
| En attente | Tâche soumise, en attente GPU |
| Début | GPU , téléchargement de l'ensemble de données et du modèle en cours |
| Course à pied | Formation en cours, mesures en temps réel |
| Terminé | Formation terminée avec succès |
| Échec | Échec de la formation (voir les journaux de la console pour plus de détails) |
| Annulé | La formation a été annulée par l'utilisateur. |
Crédits gratuits
Les nouveaux comptes reçoivent des crédits d'inscription : 5 $ pour les e-mails personnels et 25 $ pour les e-mails professionnels. Vérifiez votre solde dans Paramètres > Facturation.

Surveiller l'entraînement
Consultez la progression de la formation en temps réel dans l'onglet « Train » (Former) de la page du modèle :
Sous-onglet Graphiques

| Métrique | Description |
|---|---|
| Perte | Perte d'entraînement et de validation |
| mAP | Précision moyenne |
| Précision | Prédictions positives correctes |
| Rappel | Vérités terrain détectées |
Sous-onglet Console
Sortie console en direct avec prise en charge des couleurs ANSI, barres de progression et détection des erreurs.
Sous-onglet Système
GPU en temps réel GPU , de la mémoire, de la température, CPU et du disque.
Points de contrôle
Les points de contrôle sont enregistrés automatiquement :
- À chaque époque : Poids les plus récents sauvegardés
- Meilleur modèle : Point de contrôle avec le mAP le plus élevé conservé
- Modèle final : Poids à la fin de l'entraînement
Annuler l'entraînement
Cliquez sur Annuler l'entraînement sur la page du modèle pour arrêter une tâche en cours d'exécution :
- L'instance de calcul est terminée.
- Les crédits cessent d'être facturés
- Les points de contrôle enregistrés jusqu'à ce moment sont conservés
Entraînement à distance
graph LR
A[Local GPU] --> B[Train]
B --> C[ultralytics Package]
C --> D[Stream Metrics]
D --> E[Platform Dashboard]
style A fill:#FF9800,color:#fff
style C fill:#2196F3,color:#fff
style E fill:#4CAF50,color:#fff
Entraînez-vous sur votre propre matériel tout en transmettant les métriques à la plateforme.
Version de package requise
L'intégration de la plateforme nécessite ultralytics>=8.4.14. Les versions antérieures NE fonctionneront PAS avec la plateforme.
pip install -U ultralytics
Configurer la clé API
- Aller à
Settings > Profile(section Clés API) - Créer une nouvelle clé (ou la plateforme en crée une automatiquement lorsque vous ouvrez l'onglet Entraînement Local)
- Définissez la variable d'environnement :
export ULTRALYTICS_API_KEY="YOUR_API_KEY"
Entraîner avec le streaming
Utilisez la project et name paramètres pour diffuser les métriques :
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="coco.yaml",
epochs=100,
project="username/my-project",
name="experiment-1",
)
L'onglet Formation locale dans la boîte de dialogue Formation affiche une commande préconfigurée avec votre clé API, les paramètres sélectionnés et les arguments avancés inclus.
Utilisation des jeux de données de la plateforme
Entraînez-vous avec les ensembles de données stockés sur la plateforme à l'aide du ul:// Format URI:
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100 \
project=username/my-project name=exp1
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="ul://username/datasets/my-dataset",
epochs=100,
project="username/my-project",
name="exp1",
)
L'argument ul:// Le format URI télécharge et configure automatiquement votre ensemble de données. Le modèle est automatiquement lié à l'ensemble de données sur la plateforme (voir Utilisation des jeux de données de la plateforme).
Facturation
Les coûts d'entraînement sont basés sur l'utilisation du GPU :
Estimation des coûts
Avant le début de l'entraînement, la plateforme estime le coût total en :
- Estimation des secondes par époque à partir de la taille du jeu de données, de la complexité du modèle, de la taille de l'image, de la taille du lot et de la vitesse du GPU
- Calcul du temps d'entraînement total en multipliant les secondes par époque par le nombre d'époques, puis en ajoutant la surcharge de démarrage.
- Calcul du coût estimé à partir du nombre total d'heures d'entraînement multiplié par le tarif horaire du GPU
Facteurs influant sur le coût :
| Facteur | Impact |
|---|---|
| Taille de l'ensemble de données | Plus d'images = temps d'entraînement plus long (référence : environ 2,8 secondes de calcul pour 1 000 images sur RTX 4090) |
| Taille du modèle | Les modèles plus grands (m, l, x) s'entraînent plus lentement que les modèles (n, s). |
| Nombre d'époques | Multiplicateur direct sur le temps de formation |
| Taille de l'image | Une taille d'image plus grande augmente la puissance de calcul requise : 320 px = 0,25x, 640 px = 1,0x (valeur de référence), 1280 px = 4,0x. |
| Taille du lot | Les lots plus importants sont plus efficaces (lot 32 = environ 0,85 fois plus rapide, lot 8 = environ 1,2 fois plus rapide par rapport au lot 16 de référence). |
| GPU | Les GPU plus rapides réduisent le temps de formation (par exemple, H100 SXM = environ 3,4 fois plus rapide que RTX 4090) |
| Frais généraux de démarrage | Jusqu'à 5 minutes pour l'initialisation de l'exemple, le téléchargement des données et la préchauffage (en fonction de la taille de l'ensemble de données) |
Exemples de coûts
Estimations
Les estimations de coûts sont approximatives et dépendent de nombreux facteurs. La boîte de dialogue d'entraînement affiche une estimation en temps réel avant de commencer l'entraînement.
| Scénario | GPU | Coût estimé |
|---|---|---|
| 500 images, YOLO26n, 50 époques | RTX 4090 | ~0,50 $ |
| 1000 images, YOLO26n, 100 époques | RTX PRO 6000 | ~5 $ |
| 5000 images, YOLO26s, 100 époques | H100 SXM | ~23 $ |
Flux de facturation
graph LR
A[Estimate Cost] --> B[Balance Check]
B --> C[Train]
C --> D[Charge Actual Runtime]
style A fill:#2196F3,color:#fff
style B fill:#FF9800,color:#fff
style C fill:#9C27B0,color:#fff
style D fill:#4CAF50,color:#fff
Flux de facturation de l'entraînement cloud :
- Estimation: coût calculé avant le début de la formation
- Vérification du solde: Les crédits disponibles sont vérifiés avant le lancement
- Entraîner : La tâche s'exécute sur le calcul sélectionné
- Facturation : Le coût final est basé sur le temps d'exécution réel.
Protection des consommateurs
La facturation suit l'utilisation réelle du calcul, y compris les exécutions partielles annulées. Vous n'êtes jamais facturé pour les exécutions d'entraînement échouées.
Facturation par statut de tâche
| Statut | Facturé ? |
|---|---|
| Terminé | Oui — GPU de traitement réel GPU |
| Annulé | Oui — GPU , du début jusqu'à l'annulation |
| Échec | Non — les tentatives infructueuses ne sont pas facturées |
| Coincé | Partiel — facturation du temps de formation effectif uniquement |
Pas de frais en cas d'erreur
Si une session d'entraînement échoue en raison d'une erreur de configuration, d'un problème de mémoire insuffisante ou de toute autre défaillance, vous ne serez pas facturé. Seul le temps de calcul effectif est facturé. Les tâches bloquées (aucune activité pendant plus de 4 heures) sont automatiquement interrompues et facturées uniquement pour le temps pendant lequel le GPU activement en train d'effectuer l'entraînement, et non pour le temps d'inactivité.
Méthodes de paiement
| Méthode | Description |
|---|---|
| Solde du compte | Crédits préchargés |
| Paiement à la tâche | Facturation à la fin de la tâche |
Solde minimum
Le début de la formation nécessite un solde disponible positif et suffisamment de crédits pour couvrir le coût estimé du travail.
Afficher les coûts d'entraînement
Après l'entraînement, consultez les coûts détaillés dans l'onglet Facturation :
- Répartition des coûts par époque
- Temps GPU total
- Télécharger le rapport de coûts

Conseils d'entraînement
Choisir la bonne taille de modèle
| Modèle | Paramètres | Idéal pour |
|---|---|---|
| YOLO26n | 2.4M | Appareils de périphérie en temps réel |
| YOLO26s | 9.5M | Équilibre vitesse/précision |
| YOLO26m | 20.4M | Précision supérieure |
| YOLO26l | 24.8M | Précision de production |
| YOLO26x | 55.7M | Précision maximale |
Optimiser le temps d'entraînement
Stratégies d'économie de coûts
- Commencer modestement: Testez avec 10 à 20 époques sur un GPU économique pour vérifier que votre jeu de données et votre configuration fonctionnent.
- Utiliser le GPU approprié : La RTX PRO 6000 gère bien la plupart des charges de travail.
- Valider le jeu de données : Corrigez les problèmes d'étiquetage avant de dépenser pour l'entraînement.
- Surveiller tôt : Annulez l'entraînement si la perte stagne — vous ne payez que pour le temps de calcul utilisé.
Dépannage
| Problème | Solution |
|---|---|
| Entraînement bloqué à 0 % | Vérifiez le format du jeu de données, réessayez |
| Mémoire insuffisante | Réduire la taille du lot ou utiliser un GPU plus puissant |
| Faible précision | Augmenter le nombre d'époques, vérifier la qualité des données |
| Entraînement lent | Envisager un GPU plus rapide |
| Erreur d'inadéquation des tâches | S'assurer que les tâches du modèle et de l'ensemble de données correspondent |
FAQ
Combien de temps dure l'entraînement ?
Le temps de formation dépend de :
- Taille du jeu de données
- Taille du modèle
- Nombre d'époques
- GPU sélectionné
Temps typiques (1000 images, 100 époques) :
| Modèle | RTX PRO 6000 | A100 SXM |
|---|---|---|
| YOLO26n | ~20 min | environ 15 min |
| YOLO26m | environ 40 min | environ 30 min |
| YOLO26x | environ 80 min | environ 60 min |
Durées approximatives
Les durées d'entraînement sont approximatives et varient en fonction de la complexité de l'ensemble de données, des paramètres d'augmentation et de la taille des lots. Pour obtenir des estimations plus précises, consultez l'estimation des coûts dans la boîte de dialogue d'entraînement.
Puis-je entraîner pendant la nuit ?
Oui, l'entraînement se poursuit jusqu'à la fin. Vous recevrez une notification lorsque l'entraînement sera terminé. Assurez-vous que votre compte dispose d'un solde suffisant pour l'entraînement basé sur les époques.
Que se passe-t-il si je n'ai plus de crédits ?
Si votre solde de crédits atteint zéro pendant une session d'entraînement, celle-ci se poursuit jusqu'à son terme et votre solde devient négatif. Cela garantit que votre session d'entraînement ne soit jamais interrompue en cours de route.
Une fois l'entraînement terminé, vous devrez ajouter des crédits pour ramener votre solde à un niveau positif avant de démarrer de nouvelles tâches d'entraînement. Votre modèle complété, vos points de contrôle et tous les artefacts d'entraînement sont entièrement préservés, quel que soit le solde.
Solde négatif
Un solde négatif empêche uniquement le démarrage de nouvelles tâches d'entraînement. Les déploiements existants et les autres fonctionnalités de la plateforme continuent de fonctionner normalement. Ajoutez des crédits via Paramètres > Facturation ou activez le rechargement automatique pour éviter les interruptions.
Que se passe-t-il si ma formation coûte plus cher que prévu ?
Les estimations de coûts sont approximatives — le temps d'entraînement réel peut varier en raison de facteurs tels que la vitesse de chargement des données, le préchauffage du GPU et le comportement de convergence du modèle. Si le coût réel dépasse l'estimation, votre solde peut devenir négatif (voir ci-dessus). La plateforme n'arrête pas l'entraînement en fonction de l'estimation.
Pour maîtriser les coûts :
- Suivez les progrès de la formation en temps réel et interrompez-la rapidement si nécessaire
- Activer la recharge automatique pour réapprovisionner automatiquement votre crédit
- Commencez par des exécutions plus courtes (moins d'époques) pour ajuster vos attentes
Puis-je utiliser des arguments d'entraînement personnalisés ?
Oui, développez la section Paramètres avancés dans la boîte de dialogue de formation pour accéder à un éditeur YAML avec plus de 40 paramètres configurables. Les valeurs non par défaut sont incluses dans les commandes de formation cloud et locale.
L'éditeur YAML permet également d'importer des configurations issues de sessions d'entraînement précédentes:
- Copier à partir d'un modèle existant : Sur la page de tout modèle terminé, la carte Configuration d'entraînement dispose d'un bouton Copier en JSON. Copiez le JSON et collez-le directement dans l'éditeur yaml — il détecte automatiquement le format JSON et importe tous les paramètres.
- Coller YAML ou JSON : Collez toute configuration d'entraînement YAML ou JSON valide dans l'éditeur. Les paramètres sont validés automatiquement, les valeurs hors limites sont ajustées et des avertissements sont affichés.
- Glissez et déposez les fichiers: Faites glisser un
.yamlou.jsonfichier directement dans l'éditeur pour en importer les paramètres.

Cela permet de reproduire ou de modifier facilement les configurations d'entraînement précédentes sans avoir à saisir manuellement chaque paramètre.
Puis-je entraîner à partir d'une page de jeu de données ?
Oui, le bouton Train (Entraîner ) sur les pages de jeux de données ouvre la boîte de dialogue d'entraînement avec le jeu de données présélectionné et verrouillé. Vous sélectionnez ensuite un projet et un modèle pour commencer l'entraînement.
Référence des paramètres d'entraînement
| Paramètre | Type | Par défaut | Plage | Description |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Nombre d'époques d'entraînement |
batch | int | 16 | 1-512 | Taille du lot |
imgsz | int | 640 | 32-4096 | Taille de l'image d'entrée |
patience | int | 100 | 1-1000 | Patience pour l'arrêt anticipé |
seed | int | 0 | 0-2147483647 | Graine aléatoire pour la reproductibilité |
deterministic | bool | Vrai | - | Mode d'entraînement déterministe |
amp | bool | Vrai | - | Précision mixte automatique |
close_mosaic | int | 10 | 0-50 | Désactiver la mosaïque lors des N dernières époques |
save_period | int | -1 | -1-100 | Enregistrer le point de contrôle toutes les N époques |
workers | int | 8 | 0-64 | Workers du dataloader |
cache | sélectionner | faux | ram/disque/faux | Mettre en cache les images |
| Paramètre | Type | Par défaut | Plage | Description |
|---|---|---|---|---|
lr0 | flottant | 0.01 | 0.0001-0.1 | Taux d'apprentissage initial |
lrf | flottant | 0.01 | 0.01-1.0 | Facteur LR final |
momentum | flottant | 0.937 | 0.6-0.98 | Momentum SGD |
weight_decay | flottant | 0.0005 | 0.0-0.001 | Régularisation L2 |
warmup_epochs | flottant | 3.0 | 0-5 | Nombre d'epochs de Warmup |
warmup_momentum | flottant | 0.8 | 0.5-0.95 | Élan de réchauffement |
warmup_bias_lr | flottant | 0.1 | 0.0-0.2 | Biais de préchauffage LR |
cos_lr | bool | Faux | - | Scheduler LR cosinus |
| Paramètre | Type | Par défaut | Plage | Description |
|---|---|---|---|---|
hsv_h | flottant | 0.015 | 0.0-0.1 | Augmentation de la teinte HSV |
hsv_s | flottant | 0.7 | 0.0-1.0 | Saturation HSV |
hsv_v | flottant | 0.4 | 0.0-1.0 | Valeur HSV |
degrees | flottant | 0.0 | -45-45 | Degrés de rotation |
translate | flottant | 0.1 | 0.0-1.0 | Fraction de translation |
scale | flottant | 0.5 | 0.0-1.0 | Facteur d'échelle |
shear | flottant | 0.0 | -10-10 | Degrés de cisaillement |
perspective | flottant | 0.0 | 0.0-0.001 | Transformation de perspective |
fliplr | flottant | 0.5 | 0.0-1.0 | Probabilité de retournement horizontal |
flipud | flottant | 0.0 | 0.0-1.0 | Probabilité de retournement vertical |
mosaic | flottant | 1.0 | 0.0-1.0 | Augmentation Mosaic |
mixup | flottant | 0.0 | 0.0-1.0 | Augmentation MixUp |
copy_paste | flottant | 0.0 | 0.0-1.0 | Copier-coller (segment) |
| Paramètre | Type | Par défaut | Plage | Description |
|---|---|---|---|---|
fraction | flottant | 1.0 | 0.1-1.0 | Fraction de l'ensemble de données à utiliser |
freeze | int | null | 0-100 | Nombre de couches à congeler |
single_cls | bool | Faux | - | Traiter toutes les classes comme une seule classe |
rect | bool | Faux | - | Entraînement rectangulaire |
multi_scale | flottant | 0.0 | 0.0-1.0 | Gamme d'entraînement multi-échelle |
val | bool | Vrai | - | Exécuter la validation pendant l'entraînement |
resume | bool | Faux | - | Reprendre l'entraînement à partir du point de contrôle |
| Valeur | Description |
|---|---|
auto | Sélection automatique (par défaut) |
SGD | Descente de gradient stochastique |
MuSGD | SGD Muon SGD |
Adam | Optimiseur Adam |
AdamW | Adam avec décroissance du poids |
NAdam | Optimiseur NAdam |
RAdam | Optimiseur RAdam |
RMSProp | Optimiseur RMSProp |
Adamax | Optimiseur Adamax |
| Paramètre | Type | Par défaut | Plage | Description |
|---|---|---|---|---|
box | flottant | 7.5 | 1-50 | Poids de la perte Box |
cls | flottant | 0.5 | 0.2-4 | Poids de la perte de classification |
dfl | flottant | 1.5 | 0.4-6 | Perte focale de distribution |
pose | flottant | 12.0 | 1-50 | Pose perte de poids (pose uniquement) |
kobj | flottant | 1.0 | 0.5-10 | Objet clé (pose) |
label_smoothing | flottant | 0.0 | 0.0-0.1 | Facteur de lissage des étiquettes |
Paramètres spécifiques à la tâche
Certains paramètres ne s'appliquent qu'à des tâches spécifiques :
- Tâches de détection uniquement (detect, segment, pose, OBB — pas classify) :
box,dfl,degrees,translate,shear,perspective,mosaic,mixup,close_mosaic - Segment uniquement:
copy_paste - Pose uniquement:
pose(poids de la perte),kobj(objectness des points clés)