HParams

Au fil des années, de nombreux modèles timm ont été entraînés avec divers hyperparamètres au fur et à mesure que les bibliothèques et les modèles évoluaient. Je ne dispose pas d’un registre de chaque instance, mais j’ai consigné de nombreux exemples qui peuvent servir de point de départ très pertinent.

Commencez par les gists de fichiers de configuration pour les exécutions enregistrées, ou par les recettes sélectionnées ci-dessous pour des configurations que vous pouvez copier dans un fichier YAML. Les exemples de scripts d’entraînement montrent leurs équivalents en ligne de commande.

Tags

La plupart des modèles entraînés avec timm possèdent un identifiant dans leur balise de pré-entraînement qui les rattache (approximativement) à une famille ou une version d’hyperparamètres que j’ai utilisés au fil des années.

La famille de recette est un indice, pas une configuration complète. Faites correspondre le nom complet du point de contrôle, le jeu de données d’entraînement et la résolution lors du choix d’une configuration. Par exemple, vit_medium_patch16_reg4_gap_256.sbb_in1k a été entraîné sur ImageNet-1k, tandis que .sbb_in12k_ft_in1k identifie un pré-entraînement sur ImageNet-12k suivi d’un fine-tuning sur ImageNet-1k. Certains tags encodent un planning et une résolution au lieu d’un nom de famille : le e500_r256_in1k de MobileNetV4 appartient à la famille ra4 même si ra4 est absent du tag.

Gists de fichiers de configuration

Ces collections contiennent les configurations YAML enregistrées, y compris les paramètres spécifiques aux machines d’origine et à la version du script d’entraînement. Ouvrez un gist, choisissez le fichier YAML d’un modèle et utilisez Raw pour l’enregistrer localement.

Adaptation d'une configuration enregistrée

Passez un fichier local avec --config hparams.yaml ; les arguments de ligne de commande écrasent ses valeurs. Consultez les fichiers de configuration pour plus de détails.

• Définissez --data-dir pour votre machine. Pour un jeu de données ImageFolder, remplacez également un jeu de données TFDS enregistré avec --dataset imagefolder/. L’entraînement s’attend à ce que les sous-dossiers de classes soient situés sous train/ et validation/ (ou choisissez le répertoire de validation avec --val-split).
• Vérifiez model, pretrained, num_classes et les chemins de points de contrôle. Une configuration de fine-tuning nécessite son point de contrôle pré-entraîné d’origine ; un simple nom d’architecture peut aujourd’hui sélectionner des poids par défaut différents.
• Les anciens fichiers peuvent contenir des options supprimées telles que apex_amp, native_amp, amp_impl ou force_cpu. L’actuel train.py émet un avertissement pour les clés inconnues. Les configurations en ligne ci-dessous utilisent les options actuelles. Les anciens noms d’optimiseurs fusedadamw / fusedsgd renvoient aux implémentations Apex ; le passage à adamw / sgd constitue une adaptation de cette exécution.

Pour l'entraînement de taille fixe, la taille de lot globale effective est :

batch_size × number of training processes × grad_accum_steps

batch_size is per process (normally one GPU). A nonzero lr is used directly and is not automatically rescaled. With lr unset (null in YAML), lr_base is scaled relative to lr_base_size. Set lr_base_scale: sqrt for the AdamW/NAdamW recipes below; linear scaling is commonly used for SGD/RMSProp. Large batch-size changes still need tuning. Gradient accumulation preserves the effective batch size but does not enlarge the batch seen by BatchNorm.

Pour les calendriers en cosinus, warmup_prefix: true ajoute une phase de montée en charge avant le calendrier epochs ; cooldown_epochs ajoute une période finale au taux d'apprentissage minimal. Conservez ces paramètres lors de l'adaptation d'une ancienne exécution.

Recettes sélectionnées

Ces exemples conservent les paramètres d’entraînement issus de fichiers gist spécifiques et omettent les chemins machine et les options inutilisées. Les balises de modèle fixent la configuration de prétraitement ; les poids ne sont chargés que lorsque pretrained: true. Les précisions de référence ci-dessous sont des évaluations des points de contrôle publiés dans results-imagenet.csv, et non des mesures issues de la réexécution de ces exemples. La résolution et le recadrage de validation sont déterminants lors de la comparaison des résultats.

MobileNetV4 Conv Medium

Source : mnv4_cm_r256_e500_gpu2.yaml. L’exécution d’origine utilisait 2 GPU × 512 images = 1024 batch global, avec un LR fixe de 0.002. Le planning est de 20 epochs de warmup suivis de 500 epochs en cosine (520 au total). Enregistrer sous mobilenetv4.yaml :

model: mobilenetv4_conv_medium.e500_r256_in1k
pretrained: false
img_size: 256
crop_pct: 0.95
batch_size: 512
opt: adamw
lr: 0.002
weight_decay: 0.1
clip_grad: 5.0
sched: cosine
sched_on_updates: true
epochs: 500
warmup_epochs: 20
warmup_prefix: true
warmup_lr: 0.0
min_lr: 0.0
cooldown_epochs: 0
aa: rand-m8-inc1-mstd1.0
mixup: 0.2
mixup_prob: 0.8
smoothing: 0.1
reprob: 0.25
remode: pixel
drop: 0.2
drop_path: 0.1
model_ema: true
model_ema_decay: 0.9998
model_ema_warmup: true
dist_bn: reduce
amp: true
amp_dtype: bfloat16
torchcompile: inductor

Cet exemple utilise l’AMP bfloat16, comme dans l’exécution source ; utilisez --amp-dtype float16 sur les GPU sans prise en charge de bfloat16. torchcompile peut être omis si la compilation n’est pas souhaitée.

ViT Medium avec registres

Source : train-vit_medium_reg4-4gpu-in1k.yaml, également disponible en tant que train_hparams.yaml du checkpoint. Cette exécution SBB a utilisé 4 GPU × 256 images = 1024 batch global. Le scaling par racine carrée donne 0.0008 × sqrt(1024 / 512) ≈ 0.001131. Ses 600 epochs incluent le warmup, avec 10 epochs de cooldown ajoutées. Enregistrer sous vit-medium.yaml :

model: vit_medium_patch16_reg4_gap_256.sbb_in1k
pretrained: false
model_kwargs:
  fix_init: true
head_init_scale: 0.0
img_size: 256
crop_pct: 0.95
batch_size: 256
opt: adamw
opt_eps: 1.0e-8
lr: null
lr_base: 0.0008
lr_base_size: 512
lr_base_scale: sqrt
weight_decay: 0.07
clip_grad: 5.0
sched: cosine
sched_on_updates: true
epochs: 600
warmup_epochs: 20
warmup_prefix: false
warmup_lr: 5.0e-7
min_lr: 5.0e-7
cooldown_epochs: 10
aa: rand-m7-inc1-mstd1.0-n3
aug_repeats: 3
color_jitter: 0.0
mixup: 0.8
cutmix: 1.0
smoothing: 0.1
reprob: 0.2
remode: pixel
drop_path: 0.2
model_ema: false
seed: 0
amp: true
amp_dtype: float16
torchcompile: inductor

Les paramètres d’initialisation (fix_init et un classifieur initialisé à zéro) font partie de cette recette. Cette exécution particulière a utilisé AdamW sans EMA ; d’autres fichiers SBB utilisent NAdamW ou des paramètres de pré-entraînement différents.

Fine-tuning de ConvNeXt Tiny

Source : hparams_84_00-convnext_tiny.in12k-args.yaml. Partez de convnext_tiny.in12k, remplacez son classifieur par 1000 classes et effectuez un fine-tuning sur ImageNet-1k. L’exécution d’origine utilisait 8 GPU × 512 images = 4096 batch global et un LR fixe de 0.0001. Elle comporte 75 époques incluant le warmup, plus 10 époques de cooldown. La source évalue avec un crop de 1.0 ; les résultats de benchmark du checkpoint ci-dessus utilisent les crops d’évaluation indiqués. Enregistrez sous convnext-tiny-ft.yaml :

model: convnext_tiny.in12k
pretrained: true
num_classes: 1000
img_size: 224
crop_pct: 1.0
batch_size: 512
grad_checkpointing: true
opt: adamw
lr: 0.0001
weight_decay: 0.05
layer_decay: 0.75
clip_grad: 3.0
sched: cosine
sched_on_updates: false
epochs: 75
warmup_epochs: 10
warmup_prefix: false
warmup_lr: 1.0e-6
min_lr: 5.0e-7
cooldown_epochs: 10
lr_noise: [0.1, 1.0]
aa: rand-m8-inc1-mstd101
mixup: 0.8
cutmix: 1.0
smoothing: 0.1
reprob: 0.3
remode: pixel
drop_path: 0.1
model_ema: true
model_ema_decay: 0.9998
amp: true
amp_dtype: float16

Par exemple, lancez la configuration MobileNetV4 enregistrée avec :

torchrun --standalone --nproc_per_node=2 train.py \
  --config mobilenetv4.yaml --data-dir /data/imagenet --experiment mobilenetv4-cm

Utilisez 4 processus pour vit-medium.yaml ou 8 pour convnext-tiny-ft.yaml afin de correspondre aux tailles de lot globales d’origine, ou ajustez la taille de lot, l’accumulation et le taux d’apprentissage en fonction de votre matériel.