Planificateurs de taux d'apprentissage

Cette page contient la documentation de référence de l’API des planificateurs de taux d’apprentissage inclus dans timm, ainsi qu’un aperçu de leur création et de leur progression.

Utilisation

Les planificateurs sont créés par leur nom à l'aide de create_scheduler_v2, qui renvoie le planificateur et le nombre total d'époques d'entraînement (y compris tout préfixe de montée en charge, cycles et refroidissement, voir ci-dessous). Contrairement à torch.optim.lr_scheduler, les planificateurs de timm ne comptent pas eux-mêmes les étapes. Ils sont conçus pour être sans état : le taux d'apprentissage est une fonction de la configuration du planificateur et d'un nombre explicite d'époques ou de mises à jour, de sorte que la reprise d'une exécution n'a besoin que de l'époque, et aucun état de planificateur n'est stocké dans les points de contrôle. La boucle d'entraînement transmet explicitement l'époque ou le nombre de mises à jour :

• scheduler.step(epoch) à la fin de chaque époque, avec l'index de l'époque suivante (epoch + 1)
• scheduler.step_update(num_updates) après chaque mise à jour de l’optimiseur, avec le nombre de mises à jour effectuées jusqu’à présent

Un planificateur est incrémenté par époque ou par mise à jour (step_on_epochs) ; l'autre appel est un no-op, de sorte qu'une boucle d'entraînement peut effectuer les deux appels et prendre en charge les deux modes.

import timm
from timm.optim import create_optimizer_v2
from timm.scheduler import create_scheduler_v2

model = timm.create_model('resnet50')
optimizer = create_optimizer_v2(model, opt='adamw', lr=1e-3, weight_decay=0.05)
updates_per_epoch = len(loader)  # optimizer updates per epoch

# Cosine decay w/ 5 epochs of linear warmup, stepped per update for a smooth schedule.
scheduler, num_epochs = create_scheduler_v2(
    optimizer,
    sched='cosine',
    num_epochs=100,
    warmup_epochs=5,
    min_lr=1e-6,
    step_on_epochs=False,
    updates_per_epoch=updates_per_epoch,
)

num_updates = 0
for epoch in range(num_epochs):
    for batch in loader:
        ...  # forward, backward, optimizer.step()
        num_updates += 1
        scheduler.step_update(num_updates=num_updates)
    scheduler.step(epoch + 1)  # pass the eval metric too for 'plateau', scheduler.step(epoch + 1, metric)

Les durées (num_epochs, warmup_epochs, decay_epochs, …) sont toujours exprimées en époques ; la fabrique les convertit en mises à jour lorsque step_on_epochs=False. Les planificateurs peuvent également être construits directement à partir de leurs classes, les durées étant alors exprimées dans l’unité dans laquelle ils sont incrémentés (t_in_epochs).

Le script d’entraînement (train.py) expose les arguments de la fabrique via ces drapeaux :

• --sched sélectionne le planning.
• --epochs définit la durée du planning.
• --sched-on-updates étapes par mise à jour au lieu de par époque.
• --warmup-epochs définit la durée du warmup.
• --warmup-lr définit le taux d'apprentissage initial de la phase de montée en charge.
• --warmup-prefix ajoute un échauffement avant le planning au lieu de superposer son début.
• --min-lr définit le taux d'apprentissage minimal.
• --decay-epochs définit l'intervalle de décroissance par étape ou la durée finale de la décroissance pour WSD / rsqrt.
• --decay-milestones définit les époques de décroissance pour le planning multistep.
• --decay-rate définit le facteur d'atténuation, ou l'exposant pour le plan polynomial.
• --cooldown-epochs ajoute des époques au taux d'apprentissage minimal après la fin du planning.
• --patience-epochs définit la patience du planificateur plateau.
• --lr-noise sélectionne la partie du calendrier avec du bruit sur le taux d'apprentissage.
• --lr-noise-pct limite l'amplitude du bruit.
• --lr-noise-std définit l'écart-type du bruit.
• --lr-cycle-mul définit le multiplicateur de la longueur du cycle.
• --lr-cycle-decay définit le multiplicateur du taux d'apprentissage de pointe entre les cycles.
• --lr-cycle-limit définit le nombre de cycles.
• --lr-k-decay définit le k-decay pour les calendriers cosinus / polynomiaux.
• --lr-decay-fn sélectionne la fonction de décroissance finale pour WSD / rsqrt.
• --lr-stable-timescale définit l'échelle de temps de la phase stable rsqrt.

Planifications

Options courantes

• Warmup. warmup_epochs de réchauffement linéaire depuis warmup_lr jusqu'au taux d'apprentissage de base, pris en charge par tous les plans de progression.
  • warmup_prefix : par défaut, le warmup chevauche le début du planning (le planning est calculé à partir de l'époque 0, le warmup remplace ses premières époques), de sorte que num_epochs est la longueur totale. Avec warmup_prefix=True, le planning commence après le warmup et le warmup est ajouté au total.
  • Pour wsd et rsqrt, la phase stable commence toujours après le warmup, sans warmup_prefix les phases stable et de décroissance sont ajustées sur num_epochs - warmup_epochs de sorte que num_epochs reste le total.
• min_lr : le taux d'apprentissage auquel les calendriers de décroissance (cosine, tanh, poly, wsd, rsqrt) parviennent à la fin, et une borne inférieure pour plateau.

Le planificateur plateau est obsolète et sera supprimé dans une future version. Il ne correspondait jamais à la conception sans état décrite ci-dessus : son lr dépend de l’historique de la métrique d’évaluation plutôt que de l’époque, et cet historique (meilleure métrique, compteurs de patience et de refroidissement) n’est pas sauvegardé dans les points de contrôle, si bien qu’une exécution reprise redémarre la logique de plateau. La prise en charge des points de contrôle ne sera pas ajoutée. Un plateau de validation est également un signal faible pour déterminer quand effectuer l’annealing ; un planificateur fixe tel que cosine ou wsd est reproductible et se reprend exactement, et un balayage WSD (voir Balayages d’hyperparamètres) compare les périodes de refroidissement à plusieurs budgets à partir d’une seule exécution stable.

• cooldown_epochs : nombre d’époques maintenues à min_lr après la fin du planning (cosine, tanh, poly, wsd, rsqrt), ajouté au num_epochs retourné. Comme le planning atteint min_lr une étape après sa dernière étape, une époque de refroidissement est également un moyen d’entraîner à min_lr lors d’un pas par époque.
• Cycles (cosine, tanh, poly) : cycle_limit > 1 redémarre le planning, chaque cycle étant cycle_mul fois plus long et son pic de lr étant multiplié par cycle_decay par rapport au précédent. Le num_epochs retourné couvre tous les cycles.
• k_decay (cosine, poly) : k-decay modifie la forme du déclin (t ** k), k > 1 maintient le taux d'apprentissage élevé plus longtemps.
• Bruit : noise ajoute un bruit multiplicatif aléatoire au taux d'apprentissage sur une plage du planning, définie par des fractions de num_epochs (un début, ou un début et une fin), limitée par noise_pct.

WSD et rsqrt

Le WSDLRScheduler comporte trois phases : un réchauffement linéaire, une phase stable et un déclin jusqu'à min_lr.

• decay_epochs définit la durée finale du déclin. Une valeur comprise entre 0 et 1 représente une fraction de la longueur stable + déclin, 20 % par défaut.
• decay_fn (--lr-decay-fn) sélectionne 1-sqrt (par défaut pour wsd), linear (par défaut pour rsqrt), cosine, power ou exp.
• stable_timescale (--lr-stable-timescale, en époques) contrôle la phase stable rsqrt, qui décroît selon (1 + t / timescale) ** -0.5 à partir de la fin du warmup. Sa valeur par défaut est la durée du warmup et elle doit être définie lorsqu'il n'y a pas de warmup.

La classe prend également en charge une phase stable power généralisée et des fonctions de décroissance personnalisées.

L’anneal final est l’étape où les calendriers WSD tirent le plus de bénéfice. Utilisez donc un pas par mise à jour (--sched-on-updates) ou ajoutez une époque de refroidissement lorsque la phase de décroissance ne dure que quelques époques. Avec un pas par époque, la dernière époque d’une courte décroissance est nettement supérieure à min_lr (environ 10 % du taux d’apprentissage de base pour la dernière des 5 époques de décroissance avec 1-sqrt).

# 300 epochs, 5 epoch warmup, constant lr, then a 1-sqrt decay over the final 20%
scheduler, num_epochs = create_scheduler_v2(
    optimizer, sched='wsd', num_epochs=300, warmup_epochs=5, decay_epochs=0.2,
    step_on_epochs=False, updates_per_epoch=updates_per_epoch,
)

Échelles de lr des groupes de paramètres

Les groupes de paramètres avec un champ lr_scale (par exemple, les groupes de décroissance du taux d'apprentissage par couche issus de param_groups_layer_decay) voient leur taux d'apprentissage planifié multiplié par leur échelle. Le taux d'apprentissage de base de chaque groupe est enregistré en tant que initial_lr dans le groupe lors de la création du planificateur.

Reprise

À mesure que les nombres d’étapes sont transmis, un planificateur pour une exécution reprise est mis en place en le créant comme pour l’exécution d’origine puis en l’avançant jusqu’au point de reprise, scheduler.step(start_epoch) ou scheduler.step_update(start_epoch * updates_per_epoch). state_dict() / load_state_dict() sauvegardent et restaurent les attributs du planificateur.

API

Fonctions d'usine

Classes de planificateur