Hugging Face's logo

timm documentation

Optimisation

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.0.31).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Optimisation

Cette page contient la documentation de référence de l'API des optimiseurs inclus dans timm, ainsi qu'un aperçu de la manière dont ils sont sélectionnés et configurés via l'usine à optimiseurs.

Utilisation

Les optimiseurs sont créés par leur nom à l'aide de create_optimizer_v2. À partir d'un modèle, la fabrique construit les groupes de paramètres (exclusions du weight decay, décroissance optionnelle du taux d'apprentissage par couche) avant de construire l'optimiseur. Les arguments spécifiques à l'optimiseur sont transmis en tant qu'arguments nommés.

import timm
from timm.optim import create_optimizer_v2, list_optimizers

model = timm.create_model('vit_base_patch16_224')

# AdamW. 1D params (biases, norm scales) and params in model.no_weight_decay() are excluded from weight decay.
optimizer = create_optimizer_v2(model, opt='adamw', lr=1e-3, weight_decay=0.05)

# Layer-wise learning rate decay (fine-tuning), per-layer lr scales from the model's group_matcher().
optimizer = create_optimizer_v2(model, opt='adamw', lr=1e-3, weight_decay=0.05, layer_decay=0.75)

# Optimizer specific arguments are passed through.
optimizer = create_optimizer_v2(model, opt='lamb', lr=5e-3, weight_decay=0.02, trust_clip=True)

# A list of params or param groups can be passed instead of a model, weight decay grouping is then up to the caller.
optimizer = create_optimizer_v2(model.parameters(), opt='sgd', lr=0.1, momentum=0.9)

# All registered names, optionally with a description.
print(list_optimizers(with_description=True))

Le script d'entraînement (train.py) expose les mêmes éléments via ces drapeaux :

  • --opt sélectionne l'optimiseur.
  • --lr définit le taux d'apprentissage.
  • --weight-decay définit le weight decay.
  • --momentum définit la quantité de mouvement.
  • --opt-eps définit epsilon (eps).
  • --opt-betas définit les coefficients bêta (betas).
  • --layer-decay définit le décroissement du taux d'apprentissage par couche.
  • --opt-kwargs key=value ... transmet d'autres arguments de l'optimiseur.

Conventions de nommage

Les noms enregistrés sont en minuscules, un nom d’optimiseur de base suivi de modificateurs :

ModifierSignificationExemples
préfixe cVariante prudente, la mise à jour est masquée là où son signe diffère de celui du gradient (Cautious Optimizers)cadamw, clion, cmars, cadopt
suffixe wDécouplage de la décroissance du poids (style AdamW), pour les optimiseurs qui utilisent par défaut une décroissance L2 coupléesgdw, lambw, adoptw, novogradw, rmsproptfw
suffixe cDécroissance des poids corrigée, la décroissance est mise à l'échelle par lr² / max_lr au lieu de lr (Pourquoi les gradients augmentent-ils rapidement vers la fin de l'entraînement)adamc, nadamc, sgdc, lionc, adoptc, kronc
préfixe nÉlan de Nesterov (familles SGD, LARS et Muon)nesterov, nlars, nmuon, nadamuon
préfixe lookahead_Envelopper l'optimiseur dans Lookaheadlookahead_adamw
préfixe fusedImplémentation fusionnée NVIDIA Apex (nécessite apex)fusedadamw, fusedlamb
préfixe bnbimplémentation bitsandbytes, suffixe 8bit pour l'état 8 bits (nécessite bitsandbytes)bnbadamw, bnbadamw8bit

Quelques noms précèdent les conventions : lambc et larc sont LAMB / LARS avec élagage du ratio de confiance (la variante corrigée de LAMB est lambcd), momentum est SGD avec élan classique et sgd est SGD avec élan de Nesterov. Les implémentations legacy du tableau ci-dessous précèdent leur intégration dans PyTorch.

Familles d'optimiseurs

NomsImplémentationNotes
adamw, adam, nadam, radam, radamw, adamax, adadelta, adagrad, rmsprop, sgd, momentum, nesterovtorch.optim
adamwlegacy, adamc, cadamw, cadamcAdamWLegacyAdamW avec prudence, décroissance corrigée, rognage des mises à jour, capturable
nadamw, nadamc, cnadamw, cnadamcNAdamWAdamW avec élan de Nesterov (forme d'efficacité algorithmique de MLCommons)
adopt, adoptw, adoptc, cadopt, cadoptw, cadoptcAdoptVariante d'Adam qui converge pour tout β2
adan, adanw, cadan, cadanwAdanÉlan adaptatif de Nesterov
adabelief, radabeliefAdaBeliefradabelief ajoute une rectification de type RAdam
adafactor, cadafactorAdafactorfairseq Adafactor, taille de pas relative lorsque lr=None
adafactorbv, adafactorbvc, cadafactorbv, cadafactorbvcAdafactorBigVisionBig Vision Adafactor, moments du second ordre factorisés, élan à basse précision, rognage des mises à jour
adamp, cadamp, sgdp, csgdpAdamP, SGDPProjection de la mise à jour pour les poids invariants à l'échelle
adahessianAdahessianDe second ordre, nécessite une fermeture (is_second_order)
kron, kronw, kroncKronPSGD avec un préconditionneur factorisé de Kronecker
lamb, lambc, lambw, lambcw, lambcd, clamb, clambwLambMoments adaptatifs par couche, variantes trust_clip (lambc, lambcw)
laprop, lapropc, clapropLaPropSéparation de la quantité de mouvement et de l’adaptativité
lars, larc, nlars, nlarcLarsMise à l'échelle adaptative du taux d'apprentissage par couche, variantes trust_clip (larc, nlarc)
lion, lionc, clion, clioncLionÉlan de signe évolué
madgrad, madgradwMADGRADMoyennage dual basé sur l'élan
mars, cmarsMarsRéduction de la variance, mise à jour de type AdamW ou Lion
muon, nmuon, adamuon, nadamuonMuonÉlan orthogonalisé par Newton-Schulz pour les poids 2D+, repli sur AdamW / NAdamW pour les paramètres 1D
novograd, novogradw, novogradcNvNovoGradMoments normalisés par couche
rmsproptf, rmsproptfw, rmsproptfc, crmsproptfRMSpropTFOrdre des opérations et gestion de eps dans TensorFlow, lr intégré au tampon de momentum
sgdw, nesterovw, sgdc, csgdw, csgdcSGDWSGD avec décroissance du poids découplée
nadamlegacy, radamlegacyNAdamLegacy, RAdamLegacyImplémentations de référence, remplacées par torch.optim
fused*, bnb*NVIDIA Apex, bitsandbytesEnregistré lors de l'installation du package

Options courantes

La plupart des optimiseurs timm partagent un ensemble d'options en plus des habituels lr, weight_decay, betas et eps. Les optimiseurs qui acceptent chacune de ces options peuvent être vérifiés dans les signatures de classes ci-dessous ; la fabrique lève une exception pour les arguments non pris en charge.

  • caution applique le masque de mise à jour prudente, équivalent aux noms de registre préfixés par c.
  • corrected_weight_decay met à l’échelle la décroissance de poids découplée par lr² / max_lr au lieu de lr (les noms avec le suffixe c), de sorte que la décroissance effective suit le planning du taux d’apprentissage. max_lr est le taux d’apprentissage avec lequel l’optimiseur a été construit ; construisez-le avec le lr de pic du planning (comme le fait train.py). Il est conservé dans chaque groupe de paramètres (max_lr_snapshot) et sauvegardé / restauré avec l’état de l’optimiseur.
  • decoupled_decay (ou decoupled) bascule les optimiseurs qui utilisent par défaut une décroissance L2 couplée vers une décroissance de type AdamW (les noms suffixés par w).
  • foreach sélectionne l’implémentation multi-tenseurs. Par défaut (None), elle est utilisée sur CUDA et sur les autres périphériques disposant de noyaux foreach, conformément à torch.optim, sauf si la configuration ne la prend pas en charge (un tenseur lr sans capturable, ou caution sur une version de PyTorch dépourvue de la surcharge _foreach_maximum_ requise). L’étape multi-tenseurs est exécutée par lots de paramètres dont la taille est ajustée pour que l’ensemble de travail de chaque lot reste dans le cache L2 du GPU, ce qui est plus rapide que de faire transiter chaque paramètre par la mémoire une fois par opération pour les grands modèles. La taille des lots est dérivée de la taille du cache L2 du périphérique (PyTorch >= 2.5) et le découpage en lots est ignoré sur les périphériques où le lot résultant serait inférieur à 4M d’éléments. TIMM_FOREACH_CHUNK_SIZE=<elements> permet de définir la taille des lots, et 0 désactive le découpage.
  • capturable (AdamWLegacy, NAdamW, Adopt, Muon) conserve le nombre d'étapes sur l'appareil afin que l'étape puisse être capturée dans un graphe CUDA. Tous les optimiseurs acceptent un lr fourni sous forme de tenseur de dimension 0, mis à jour sur place par un planning, pour une utilisation avec torch.compile et les graphes CUDA.
  • clipping_threshold (AdamWLegacy, NAdamW, AdafactorBigVision) applique un écrêtage de la mise à jour par son RMS, update / max(1, rms / threshold) où rms est le RMS du gradient normalisé par le second moment, par tenseur (StableAdamW, Adafactor). 1.0 comme dans les articles. Comme dans Adafactor, le décroissement de poids (découplé) n'est pas écrêté, StableAdamW met également à l'échelle le décroissement par le taux d'apprentissage écrêté.
  • maximize maximise l'objectif au lieu de le minimiser.

Les paramètres de faible précision (bfloat16, float16) sont pris en charge de bout en bout :

  • AdaBelief, RAdamLegacy and Adafactor conservent leur état en float32 pour les paramètres de basse précision.
  • AdafactorBigVision conserve son élan dans une précision réduite (momentum_dtype).
  • Kron dispose d'options distinctes mu_dtype / precond_dtype.

Ces dtypes d’état sont conservés par load_state_dict (le chargeur par défaut de PyTorch convertit l’état vers le dtype du paramètre). Les fonctions d’étape évitent les synchronisations hôte (branches Python dépendantes des données sur des tenseurs de l’appareil), la vérification de projection d’AdamP / SGDP faisant exception.

Groupes de paramètres

Lorsqu’un modèle est fourni, create_optimizer_v2 regroupe les paramètres avec param_groups_weight_decay (aucune décroissance pour les paramètres 1D et l’ensemble no_weight_decay() du modèle) ou, si layer_decay est défini, avec param_groups_layer_decay, qui attribue un facteur d’échelle du taux d’apprentissage de layer_decay ** (num_layers - layer_id) par couche en utilisant group_matcher() du modèle. Les modèles sans group_matcher() basculent sur auto_group_layers, qui nécessite pretrained_cfg['classifier'] du modèle pour séparer la tête. Pour les optimiseurs hybrides (Muon), les arguments fallback_list et fallback_no_weight_decay acheminent les paramètres vers l’optimiseur de secours (AdamW).

API

Fonctions d'usine

timm.optim.create_optimizer_v2

< >

( model_or_params: typing.Union[torch.nn.Module, torch.optim.optimizer.ParamsT]opt: str = 'sgd'lr: typing.Optional[float] = Noneweight_decay: float = 0.0momentum: float = 0.9foreach: typing.Optional[bool] = Nonefilter_bias_and_bn: bool = Truefallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = Falselayer_decay: typing.Optional[float] = Nonelayer_decay_min_scale: float = 0.0layer_decay_no_opt_scale: typing.Optional[float] = Noneparam_group_fn: typing.Optional[typing.Callable[[torch.nn.Module], torch.optim.optimizer.ParamsT]] = None**kwargs: typing.Any )

Paramètres

  • model_or_params — Un modèle PyTorch ou un itérable de paramètres/groupes de paramètres. Si un modèle est fourni, les paramètres seront extraits et groupés automatiquement en fonction des autres arguments.
  • opt — Nom de l’optimiseur à créer (par ex. ‘adam’, ‘adamw’, ‘sgd’). Utilisez list_optimizers() pour voir les options disponibles.
  • lr — Taux d'apprentissage. Si None, la valeur par défaut de l'optimiseur sera utilisée.
  • weight_decay — Facteur de décroissance du poids. Sera utilisé pour créer des groupes de paramètres si model_or_params est un modèle.
  • momentum — Facteur de momentum pour les optimiseurs qui le prennent en charge. Utilisé uniquement si l’optimiseur choisi accepte ce paramètre.
  • foreach — Active/désactive l’implémentation foreach (multi-tenseur) si disponible. Si None, les valeurs par défaut spécifiques à l’optimiseur seront utilisées.
  • filter_bias_and_bn — Si True, les paramètres des couches de biais et de normalisation (tous les paramètres 1d) ne se verront pas appliquer de décroissance de poids. Utilisé uniquement lorsque model_or_params est un modèle et weight_decay > 0.
  • fallback_list — Collection of motifs de noms de paramètres pour utiliser l’optimiseur de secours avec les optimiseurs hybrides (par ex. AdamW pour Muon). Prend en charge la correspondance avec des caractères jokers.
  • fallback_no_weight_decay — Si True, les paramètres de la liste no_weight_decay() du modèle utiliseront l’optimiseur de secours pour les optimiseurs hybrides (par ex. AdamW pour Muon).
  • layer_decay — Facteur de décroissance du taux d'apprentissage par couche, facultatif. S'il est fourni, les taux d'apprentissage seront mis à l'échelle par layer_decay^(max_depth - layer_depth). Utilisé uniquement lorsque model_or_params est un modèle.
  • param_group_fn — Fonction facultative pour créer des groupes de paramètres personnalisés. Si elle est fournie, les autres options de regroupement des paramètres seront ignorées.
  • **kwargs — Arguments supplémentaires spécifiques à l'optimiseur (par exemple, betas pour Adam).

Créer une instance d'optimiseur via le registre timm.

Crée et configure un optimiseur avec des groupes de paramètres et des réglages appropriés. Prend en charge la création automatique de groupes de paramètres pour le déclin du poids (weight decay) et les taux d'apprentissage par couche, ainsi que le regroupement personnalisé des paramètres.

Exemples :

Lors de l’utilisation d’AdamW à partir d’un modèle, les groupes de paramètres sont créés automatiquement :

optimizer = create_optimizer_v2(model, 'adamw', lr=1e-3)

SGD avec élan et décroissance du poids :

optimizer = create_optimizer_v2(model, 'sgd', lr=0.1, momentum=0.9, weight_decay=1e-4)

Adam avec décroissance du taux d'apprentissage par couche :

optimizer = create_optimizer_v2(model, 'adam', lr=1e-3, layer_decay=0.7)

Groupes de paramètres personnalisés :

def group_fn(model):
    return [
        {'params': model.backbone.parameters(), 'lr': 1e-4},
        {'params': model.head.parameters(), 'lr': 1e-3},
    ]

optimizer = create_optimizer_v2(model, 'sgd', param_group_fn=group_fn)

Note : Priorité de la gestion des groupes de paramètres :

  1. Si param_group_fn est fourni, il sera utilisé exclusivement
  2. Si layer_decay est fourni, des groupes par couche seront créés
  3. Si weight_decay > 0 et filter_bias_and_bn est True, des groupes de weight decay seront créés
  4. Sinon, tous les paramètres seront regroupés dans un seul groupe

timm.optim.list_optimizers

< >

( filter: typing.Union[str, typing.List[str]] = ''exclude_filters: typing.Optional[typing.List[str]] = Nonewith_description: bool = False ) → If with_description is False

Paramètres

  • filter — Chaîne de filtre au format joker ou liste de chaînes de filtre (par exemple, ‘adam’ pour toutes les variantes d’Adam, ou [‘adam’, ‘*8bit’] pour les variantes d’Adam et les optimiseurs 8 bits). Une chaîne vide signifie qu’aucun filtre n’est appliqué.
  • exclude_filters — Liste facultative de motifs génériques à exclure. Par exemple, [’8bit’, ‘fused’] exclurait les implémentations 8 bits et fusionnées.
  • with_description — Si True, renvoie des tuples de (name, description) au lieu de seulement des noms. Les descriptions fournissent de brèves explications sur les caractéristiques de l'optimiseur.

Retourne

Si with_description est False

Liste de noms d’optimisateurs sous forme de chaînes (par ex. [‘adam’, ‘adamw’, …]) Si with_description est True : Liste de tuples de la forme (nom, description) (par ex. [(‘adam’, ‘Adaptive Moment…’), …])

Liste les noms d’optimisateurs disponibles, éventuellement filtrés.

Liste tous les optimiseurs enregistrés, avec un filtrage facultatif à l'aide de motifs génériques. Les optimiseurs peuvent être filtrés à l'aide de motifs d'inclusion et d'exclusion, et peuvent éventuellement retourner des descriptions avec chaque nom d'optimiseur.

Exemples :

>>> list_optimizers()
['adam', 'adamw', 'sgd', ...]

>>> list_optimizers(['la*', 'nla*'])  # List lamb & lars
['lamb', 'lambc', 'larc', 'lars', 'nlarc', 'nlars']

>>> list_optimizers('*adam*', exclude_filters=['bnb*', 'fused*'])  # Exclude bnb & apex adam optimizers
['adam', 'adamax', 'adamp', 'adamw', 'nadam', 'nadamw', 'radam']

>>> list_optimizers(with_description=True)  # Get descriptions
[('adabelief', 'Adapts learning rate based on gradient prediction error'),
 ('adadelta', 'torch.optim Adadelta, Adapts learning rates based on running windows of gradients'),
 ('adafactor', 'Memory-efficient implementation of Adam with factored gradients'),
...]

timm.optim.get_optimizer_class

< >

( name: strbind_defaults: bool = True ) → If bind_defaults is False

Paramètres

  • name — Nom de l'optimiseur à récupérer (par exemple, ‘adam’, ‘sgd’)
  • bind_defaults — Si True, renvoie une fonction partielle avec les arguments par défaut de OptimInfo liés. Si False, renvoie la classe d'optimiseur brute.

Retourne

Si bind_defaults est False

La classe d'optimiseur (par exemple, torch.optim.Adam) Si bind_defaults est True : Une fonction partielle avec des arguments par défaut liés

Lève

ValueError

  • ValueError — Si le nom de l'optimiseur n'est pas trouvé dans le registre

Obtenir la classe d’optimiseur par nom avec l’option de lier des arguments par défaut.

Récupère la classe d'optimiseur ou une fonction partielle avec des arguments par défaut liés. Cela permet l'instantiation directe des optimiseurs avec leurs configurations par défaut sans passer par l'usine complète.

Exemples :

Avec les valeurs par défaut du registre liées, sgd a la quantité de mouvement de Nesterov activée :

SGD = get_optimizer_class('sgd')
opt = SGD(model.parameters(), lr=0.1, momentum=0.9)

La classe d'optimiseur brute :

SGD = get_optimizer_class('sgd', bind_defaults=False)
opt = SGD(model.parameters(), lr=1e-3, momentum=0.9, nesterov=True)

timm.optim.get_optimizer_info

< >

( name: str )

Paramètres

  • name — Nom de l'optimiseur

Lève

ValueError

  • ValueError — Si l'optimiseur n'est pas trouvé

Obtenir l'OptimInfo pour un optimiseur.

Fonctions de groupes de paramètres

timm.optim.param_groups_weight_decay

< >

( model: Moduleweight_decay: typing.Optional[float] = 1e-05weight_decay_exclude_1d: bool = Trueno_weight_decay_list: typing.Collection[str] = ()fallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = False )

timm.optim.param_groups_layer_decay

< >

( model: Moduleweight_decay: float = 0.05no_weight_decay_list: typing.Collection[str] = ()fallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = Falseweight_decay_exclude_1d: bool = Truelayer_decay: float = 0.75min_scale: float = 0.0no_opt_scale: typing.Optional[float] = Noneverbose: bool = False )

Groupes de paramètres pour la décroissance du taux d'apprentissage par couche & la décroissance du poids Basé sur BEiT : https://github.com/microsoft/unilm/blob/master/beit/optim_factory.py#L58

timm.optim.auto_group_layers

< >

( modellayers_per_group = 12num_groups = None )

Classes d'optimiseur

classe timm.optim.AdaBelief

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-16weight_decay = 0amsgrad = Falsedecoupled_decay = Truefixed_decay = Falserectify = Truedegenerated_to_sgd = Trueforeach: typing.Optional[bool] = None )

Paramètres

  • params (iterable) — itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres
  • lr (float, optionnel) — taux d'apprentissage (par défaut : 1e-3)
  • betas (Tuple[float, float], optionnel) — coefficients utilisés pour le calcul des moyennes mobiles du gradient et de son carré (par défaut : (0.9, 0.999))
  • eps (float, facultatif) — terme ajouté au dénominateur pour améliorer la stabilité numérique (par défaut : 1e-16)
  • weight_decay (float, optionnel) — décroissance du poids (pénalité L2) (par défaut : 0)
  • amsgrad (booléen, facultatif) — indique s'il faut utiliser la variante AMSGrad de cet algorithme issue de l'article On the Convergence of Adam and Beyond_ (valeur par défaut : False)
  • decoupled_decay (booléen, facultatif) — (par défaut : True) Si défini à True, l’optimiseur utilise une décroissance du poids découplée, comme dans AdamW
  • fixed_decay (booléen, facultatif) — (par défaut : False) Utilisé lorsque weightdecouple est défini sur True. Lorsque fixed_decay == True, le décroissement du poids est effectué selon $W{new} = W{old} - W{old} \times decay$. Lorsque fixeddecay == False, le décroissement du poids est effectué selon $W{new} = W{old} - W{old} \times decay \times lr$. Notez que dans ce cas, le taux de décroissement du poids diminue avec le taux d'apprentissage (lr).
  • rectify (booléen, facultatif) — (par défaut : True) Si défini sur True, effectue une mise à jour rectifiée similaire à RAdam
  • degenerated_to_sgd (booléen, facultatif) (par défaut —True) Si défini à True, effectue une mise à jour SGD lorsque la variance du gradient est élevée
  • foreach (booléen, facultatif) — utiliser l'implémentation foreach (multi-tenseurs), utilisée par défaut (None) sauf si non prise en charge

Implémente l'algorithme AdaBelief. Modifié à partir d'Adam dans PyTorch

référence : AdaBelief Optimizer, adapting stepsizes by the belief in observed gradients, NeurIPS 2020

Pour un tableau complet des hyperparamètres recommandés, consultez https://github.com/juntang-zhuang/Adabelief-Optimizer’ Par exemple, pour les arguments d’entraînement d’EfficientNet, consultez ces gists

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.Adafactor

< >

( params: ParamsTlr: typing.Optional[float] = Noneeps: float = 1e-30eps_scale: float = 0.001clip_threshold: float = 1.0decay_rate: float = -0.8betas: typing.Optional[typing.Tuple[float, float]] = Noneweight_decay: float = 0.0scale_parameter: bool = Truewarmup_init: bool = Falsemin_dim_size_to_factor: int = 16caution: bool = False )

Implémente l'algorithme Adafactor.

Cette implémentation est basée sur : Adafactor: Adaptive Learning Rates with Sublinear Memory Cost (voir https://arxiv.org/abs/1804.04235)

Notez que cet optimiseur ajuste en interne le taux d'apprentissage en fonction des options scale_parameter, relative_step et warmup_init.

Un calendrier de taux d'apprentissage manuel (externe) est utilisé lorsque lr est défini (relative_step est alors False). Notez que dans cette implémentation, scale_parameter et warmup_init ne s'appliquent qu'au taux d'apprentissage de la étape relative (lr=None), contrairement à fairseq / HF Transformers, l'échelle du RMS des paramètres n'est pas appliquée à un taux d'apprentissage externe.

Ags: params: itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres lr: taux d'apprentissage externe eps: constantes de régularisation pour le gradient au carré et l'échelle des paramètres, respectivement eps_scale: constantes de régularisation pour l'échelle des paramètres, respectivement clip_threshold: seuil de la racine carrée de la moyenne des carrés de la mise à jour finale du gradient decay_rate: coefficient utilisé pour calculer les moyennes mobiles du gradient au carré beta1: coefficient utilisé pour le calcul des moyennes mobiles du gradient weight_decay: décroissance du poids scale_parameter: si True, le taux d'apprentissage de la pas relative est mis à l'échelle par la racine carrée de la moyenne des carrés du paramètre warmup_init: le calcul du taux d'apprentissage dépendant du temps dépend de l'utilisation ou non d'une initialisation de mise en route

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.AdafactorBigVision

< >

( params: ParamsTlr: float = 1.0min_dim_size_to_factor: int = 16decay_rate: float = 0.8decay_offset: int = 0beta2_cap: float = 0.999momentum: typing.Optional[float] = 0.9momentum_dtype: typing.Union[str, torch.dtype] = torch.bfloat16eps: typing.Optional[float] = Noneweight_decay: float = 0.0clipping_threshold: typing.Optional[float] = Noneunscaled_wd: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = False )

Implémentation PyTorch de la variante Adafactor de BigVision, avec des implémentations mono-tenseur et multi-tenseurs.

Adapté de https://github.com/google-research/big_vision par Ross Wightman

classe timm.optim.Adahessian

< >

( paramslr = 0.1betas = (0.9, 0.999)eps = 1e-08weight_decay = 0.0hessian_power = 1.0update_each = 1n_samples = 1avg_conv_kernel = False )

Paramètres

  • params (iterable) — itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres
  • lr (float, facultatif) — taux d'apprentissage (par défaut : 0.1)
  • betas ((float, float), optionnel) — coefficients utilisés pour le calcul des moyennes mobiles du gradient et de la trace du hessien au carré (par défaut : (0.9, 0.999))
  • eps (float, facultatif) — terme ajouté au dénominateur pour améliorer la stabilité numérique (par défaut : 1e-8)
  • weight_decay (float, facultatif) — décroissance du poids (pénalité L2) (par défaut : 0.0)
  • hessian_power (float, facultatif) — exposant de la trace de la hessienne (par défaut : 1.0)
  • update_each (int, optionnel) — ne calculer l'approximation de la trace de la hessienne qu'après ce nombre d'étapes (pour gagner du temps) (par défaut : 1)
  • n_samples (int, facultatif) — nombre de fois à échantillonner z pour l'approximation de la trace du hessien (par défaut : 1)

Implémente l'algorithme AdaHessian issu de « ADAHESSIAN: An Adaptive Second OrderOptimizer for Machine Learning »

get_params

< >

( )

Récupère tous les paramètres de tous les param_groups ayant des gradients

set_hessian

< >

( )

Calcule l'approximation de Hutchinson de la trace du hessien et l'accumule pour chaque paramètre entraînable.

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — une fermeture qui réévalue le modèle et renvoie la perte (par défaut — None)

Effectue une étape d'optimisation unique.

zero_hessian

< >

( )

Met à zéro les traces hessiennes accumulées.

classe timm.optim.AdamP

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-08weight_decay = 0delta = 0.1wd_ratio = 0.1nesterov = Falsecaution = False )

classe timm.optim.AdamWLegacy

< >

( params: ParamsTlr: float = 0.001betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-08weight_decay: float = 0.01amsgrad: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonecapturable: bool = Falseclipping_threshold: typing.Optional[float] = None )

Paramètres

  • params — itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres
  • lr — taux d'apprentissage
  • betas — coefficients utilisés pour le calcul des moyennes mobiles du gradient et de son carré
  • eps — terme ajouté au dénominateur pour améliorer la stabilité numérique
  • weight_decay — coefficient de décroissance du poids
  • amsgrad — indique s'il faut utiliser la variante AMSGrad de cet algorithme de l'article On the Convergence of Adam and Beyond
  • caution — faites preuve de prudence lors de l'utilisation d'AdamW
  • corrected_weight_decay — appliquer une décroissance de poids corrigée (lr**2 / max_lr)
  • maximize — maximiser les paramètres en fonction de l'objectif, au lieu de les minimiser
  • foreach — indique si l’implémentation foreach de l’optimiseur est utilisée. Si l’utilisateur ne le précise pas (donc si foreach est None), nous essaierons d’utiliser foreach plutôt que l’implémentation par boucle for sur CUDA, car elle est plus rapide en général.
  • capturable — indique si cette instance peut être capturée en toute sécurité dans un graphe CUDA. Passer True peut dégrader les performances non graphées, donc si vous ne prévoyez pas de capturer cette instance dans un graphe, laissez-la à False
  • clipping_threshold — seuil de rognage de la mise à jour RMS (StableAdamW, https://arxiv.org/abs/2304.13013), la mise à jour est mise à l’échelle par 1 / max(1, rms / clipping_threshold) où rms est le RMS de grad / (sqrt(v_hat) + eps). Atténue la mise à jour des paramètres en cas d’augmentation soudaine du gradient par rapport à leur estimation du second moment. 1.0 conformément à l’article, None (par défaut) désactive. Comme dans Adafactor, la décroissance de poids découplée n’est pas rognée (StableAdamW met également à l’échelle la décroissance par le lr rogné).

Implémente l'algorithme AdamW.

NOTE : Cette impl a été dépréciée au profit de torch.optim.AdamW et reste en tant que référence

Références :

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.Adan

< >

( paramslr: float = 0.001betas: typing.Tuple[float, float, float] = (0.98, 0.92, 0.99)eps: float = 1e-08weight_decay: float = 0.0no_prox: bool = Falsecaution: bool = Falseforeach: typing.Optional[bool] = None )

Paramètres

  • params — Itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres.
  • lr — Taux d'apprentissage.
  • betas — Coefficients utilisés pour les moments d'ordre premier et second.
  • eps — Terme ajouté au dénominateur pour améliorer la stabilité numérique.
  • weight_decay — Décroissance du poids découplée (pénalité L2)
  • no_prox — Comment effectuer le déclin du poids
  • caution — Activer la prudence depuis « Cautious Optimizers »
  • foreach — Si True, utilise l'implémentation torch._foreach. Plus rapide, mais utilise légèrement plus de mémoire.

Implémente une variante pytorch de Adan.

Adan a été proposé dans Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models https://arxiv.org/abs/2208.06677

étape

< >

( closure = None )

Effectue une étape d'optimisation unique.

classe timm.optim.Adopt

< >

( params: ParamsTlr: typing.Union[float, torch.Tensor] = 0.001betas: typing.Tuple[float, float] = (0.9, 0.9999)eps: float = 1e-06clip_exp: typing.Optional[float] = 0.333weight_decay: float = 0.0decoupled: bool = Falsecorrected_weight_decay: bool = Falsecaution: bool = Falseforeach: typing.Optional[bool] = Nonemaximize: bool = Falsecapturable: bool = Falsedifferentiable: bool = False )

ADOPT : Adam modifié peut converger avec n'importe quel β2 au taux optimal : https://arxiv.org/abs/2411.02853

étape

< >

( closure = None )

Paramètres

  • closure (Callable, optionnel) — Une closure qui réévalue le modèle et renvoie la perte.

Effectuer une étape d'optimisation unique.

classe timm.optim.kron.Kron

< >

( params: ParamsTlr: float = 0.001momentum: float = 0.9weight_decay: float = 0.0preconditioner_update_probability: typing.Union[typing.Callable, float, NoneType] = Nonemax_size_triangular: int = 2048min_ndim_triangular: int = 2memory_save_mode: typing.Optional[str] = Nonemomentum_into_precond_update: bool = Trueprecond_lr: float = 0.1precond_init_scale: float = 1.0mu_dtype: typing.Optional[torch.dtype] = Noneprecond_dtype: typing.Optional[torch.dtype] = Nonedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falseflatten: bool = Falseflatten_start_dim: int = 2flatten_end_dim: int = -1stochastic_weight_decay: bool = Falsedeterministic: bool = False )

Paramètres

  • params — Itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres.
  • lr — Taux d'apprentissage.
  • momentum — Momentum parameter.
  • weight_decay — Décroissance du poids.
  • preconditioner_update_probability — Probabilité de mise à jour du préconditionneur. Si None, la valeur par défaut est un planning qui effectue un recuit de 1.0 à 0.03 sur 4000 étapes.
  • max_size_triangular — Taille maximale pour que le préconditionneur de dim soit triangulaire.
  • min_ndim_triangular — Nombre minimal de dimensions qu'une couche doit avoir pour utiliser des préconditionneurs triangulaires.
  • memory_save_mode — ‘one_diag’, ‘smart_one_diag’ ou ‘all_diag’, la valeur par défaut est None pour définir tous les préconditionneurs comme triangulaires, ‘one_diag’ définit la plus grande ou dernière dimension comme diagonale par couche, et ‘all_diag’ définit tous les préconditionneurs comme diagonaux.
  • momentum_into_precond_update — indique s'il faut envoyer la quantité de mouvement dans la mise à jour du préconditionneur plutôt que dans les gradients bruts.
  • mu_dtype — Dtype de l'accumulateur de momentum.
  • precond_dtype — Dtype du préconditionneur.
  • decoupled_decay — décroissance du poids découplée de type AdamW
  • corrected_weight_decay — applique une correction du weight decay lors de l'utilisation de decoupled_decay (lr**2 / max_lr)
  • flatten — Aplatissement des dimensions au lieu de s'appuyer entièrement sur les expressions pour les paramètres de rang supérieur
  • flatten_start_dim — Début de la plage d’aplatissement, valeur par défaut : 2. Semble être un bon compromis pour les ConvNets.
  • flatten_end_dim — Fin de la plage de mise à plat, valeur par défaut : -1.
  • stochastic_weight_decay — Active la modulation aléatoire de l'atténuation des poids
  • deterministic — Comportement déterministe lors de l'enregistrement / du chargement (reprise). À corriger : lent, nécessite des travaux

Implémente PSGD Kron à partir de https://github.com/lixilinx/psgd_torch.

classe timm.optim.Lamb

< >

( params: ParamsTlr: float = 0.001bias_correction: bool = Truebetas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-06weight_decay: float = 0.01grad_averaging: bool = Truemax_grad_norm: typing.Optional[float] = 1.0trust_clip: bool = Falsealways_adapt: bool = Falsecaution: bool = Falsedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falseforeach: typing.Optional[bool] = None )

Paramètres

  • params — Itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres.
  • lr — Taux d'apprentissage
  • betas — Coefficients utilisés pour le calcul des moyennes mobiles du gradient et de sa norme.
  • eps — Terme ajouté au dénominateur pour améliorer la stabilité numérique.
  • weight_decay — Décroissance du poids
  • grad_averaging — Indique s'il faut appliquer (1-beta2) au gradient lors du calcul des moyennes mobiles du gradient.
  • max_grad_norm — Valeur utilisée pour limiter la norme globale des gradients.
  • trust_clip — Active le rognage du ratio de confiance LAMBC.
  • always_adapt — Applique un taux d'apprentissage adaptatif au paramètre de weight decay 0.0.
  • caution — Faites preuve de prudence.
  • decoupled — appliquer une décroissance de poids découplée
  • corrected_weight_decay — applique une correction du weight decay (lr**2 / max_lr) lors de l'utilisation de decoupled_decay
  • foreach — utiliser l’implémentation foreach (multi-tenseurs), utilisée par défaut (None) sauf si non prise en charge

Implémente une variante pure PyTorch de l’optimiseur FuseLAMB (variante NvLamb) de apex.optimizers.FusedLAMB référence : https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py

LAMB a été proposé dans :

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.LaProp

< >

( params: ParamsTlr: float = 0.0004betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-15weight_decay: float = 0.0caution: bool = Falsecorrected_weight_decay: bool = Falseforeach: typing.Optional[bool] = None )

Paramètres

  • foreach — utiliser l’implémentation foreach (multi-tenseurs), utilisée par défaut (None) sauf si non prise en charge (voir laprop())

LaProp Optimizer

Article : LaProp: Separating Momentum and Adaptivity in Adam, https://arxiv.org/abs/2002.04839

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.Lars

< >

( paramslr = 1.0momentum = 0dampening = 0weight_decay = 0nesterov = Falsetrust_coeff = 0.001eps = 1e-08trust_clip = Falsealways_adapt = Falseforeach: typing.Optional[bool] = None )

Paramètres

  • params (iterable) — itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres.
  • lr (float, facultatif) — taux d'apprentissage (par défaut : 1.0).
  • momentum (float, facultatif) — facteur d'élan (par défaut : 0)
  • weight_decay (float, optionnel) — décroissance du poids (pénalité L2) (par défaut : 0)
  • dampening (float, facultatif) — amortissement pour la quantité de mouvement (par défaut : 0)
  • nesterov (bool, facultatif) — active la quantité de mouvement de Nesterov (par défaut : False)
  • trust_coeff (float) — coefficient de confiance pour le calcul du lr adaptatif / trust_ratio (par défaut : 0.001)
  • eps (float) — eps pour le dénominateur de la division (par défaut : 1e-8)
  • trust_clip (bool) — active le rognage du ratio de confiance LARC (par défaut : False)
  • always_adapt (bool) — applique toujours l'adaptation du taux d'apprentissage LARS, sinon uniquement lorsque group weight_decay != 0 (par défaut : False)
  • foreach (bool, optionnel) — utiliser l'implémentation foreach (multi-tenseurs), utilisée par défaut (None) sauf si non prise en charge

LARS pour PyTorch

Article : Large batch training of Convolutional Networks - https://arxiv.org/pdf/1708.03888.pdf

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.Lion

< >

( params: ParamsTlr: float = 0.0001betas: typing.Tuple[float, float] = (0.9, 0.99)weight_decay: float = 0.0caution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = None )

Implémente l'algorithme Lion.

étape

< >

( closure = None )

Paramètres

  • closure — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.Lookahead

< >

( base_optimizeralpha = 0.5k = 6 )

classe timm.optim.MADGRAD

< >

( params: typing.Anylr: float = 0.01momentum: float = 0.9weight_decay: float = 0eps: float = 1e-06decoupled_decay: bool = False )

Paramètres

  • params (iterable) — Itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres.
  • lr (float) — Taux d'apprentissage (par défaut : 1e-2).
  • momentum (float) — Valeur de l'élan dans l'intervalle [0,1) (par défaut : 0,9).
  • weight_decay (float) — Décroissance du poids, c'est-à-dire une pénalité L2 (par défaut : 0).
  • eps (float) — Terme ajouté au dénominateur, en dehors de l'opération de racine, pour améliorer la stabilité numérique. (défaut : 1e-6).

MADGRAD_: A Momentumized, Adaptive, Dual Averaged Gradient Method for Stochastic Optimization.

.. _MADGRAD: https://arxiv.org/abs/2101.11075

MADGRAD est un optimiseur à usage général qui peut être utilisé à la place de SGD ou Adam et qui peut converger plus rapidement et généraliser mieux. Actuellement, il est uniquement compatible avec les GPU. En général, le même calendrier de taux d'apprentissage utilisé pour SGD ou Adam peut être utilisé. Le taux d'apprentissage global n'est pas comparable à celui des deux méthodes et doit être déterminé par un balayage d'hyperparamètres.

MADGRAD nécessite moins de décroissance de poids que les autres méthodes, souvent aussi peu que zéro. Les valeurs d'élan utilisées pour SGD ou beta1 d'Adam devraient également fonctionner ici.

Pour les problèmes creux, weight_decay et momentum doivent être définis à 0.

étape

< >

( closure: typing.Optional[typing.Callable[[], float]] = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.Mars

< >

( params: ParamsTlr: float = 0.003betas: typing.Tuple[float, float] = (0.9, 0.99)eps: float = 1e-08weight_decay: float = 0.0gamma: float = 0.025mars_type: str = 'adamw'optimize_1d: bool = Falselr_1d_factor: float = 1.0betas_1d: typing.Optional[typing.Tuple[float, float]] = Nonecaution: bool = False )

Optimiseur MARS

Article : MARS : Déchaîner le pouvoir de la réduction de variance pour l’entraînement de grands modèles https://arxiv.org/abs/2411.10438

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.Muon

< >

( params: ParamsTlr: float = 0.02weight_decay: float = 0momentum: float = 0.95nesterov: bool = Falsens_steps: int = 5ns_coefficients: typing.Union[str, typing.Tuple[float, float, float], typing.List[typing.Tuple[float, float, float]]] = 'quintic'eps: float = 1e-07safety_factor: float = 1.0adjust_lr_fn: typing.Optional[str] = 'match_rms_adamw'conv_mode: str = 'flatten'normalize_spatial: bool = Trueadamw_lr: typing.Optional[float] = Nonefallback_lr_scale: float = 1.0betas: typing.Tuple[float, float] = (0.9, 0.95)algo: str = 'muon'scale_eps: bool = Falsecapturable: bool = Falseverbose: bool = False )

Muon - MomentUm Orthogonalisé par Newton-schulz

Combine Muon pour les paramètres de dimension 2D et supérieure (matrices de poids) avec AdamW pour les paramètres de dimension 1D (biais, normes) et les groupes de paramètres avec ‘use_fallback=True’ défini (ou ‘use_muon=False’ pour la compatibilité).

Prend en charge deux algorithmes :

  • “muon” : Algorithme Muon standard avec élan + orthogonalisation
  • “adamuon” : algorithme AdaMuon qui ajoute une estimation du second moment élément par élément aux directions orthogonales pour un ajustement adaptatif de type Adam

étape

< >

( closure = None )

Effectue une étape d'optimisation unique.

classe timm.optim.NAdamLegacy

< >

( paramslr = 0.002betas = (0.9, 0.999)eps = 1e-08weight_decay = 0schedule_decay = 0.004 )

Paramètres

  • params (iterable) — itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres
  • lr (float, optionnel) — taux d'apprentissage (par défaut : 2e-3)
  • betas (Tuple[float, float], optionnel) — coefficients utilisés pour le calcul des moyennes mobiles du gradient et de son carré
  • eps (float, facultatif) — terme ajouté au dénominateur pour améliorer la stabilité numérique (par défaut : 1e-8)
  • weight_decay (float, optionnel) — décroissance du poids (pénalité L2) (par défaut : 0)
  • schedule_decay (float, facultatif) — décroissance du plan de momentum (par défaut : 4e-3)

Implémente l'algorithme Nadam (une variante d'Adam basée sur l'élan de Nesterov).

NOTE : Cette implémentation a été dépréciée au profit de torch.optim.NAdam et reste en tant que référence

Cela a été proposé dans Incorporating Nesterov Momentum into Adam__.

http://cs229.stanford.edu/proj2015/054_report.pdf http://www.cs.toronto.edu/~fritz/absps/momentum.pdf

Initialement repris de : https://github.com/pytorch/pytorch/pull/1408 REMARQUE : Présente des problèmes potentiels mais fonctionne bien sur certains problèmes.

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.NAdamW

< >

( params: ParamsTlr: float = 0.001betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-08weight_decay: float = 0.01caution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonecapturable: bool = Falseclipping_threshold: typing.Optional[float] = None )

Paramètres

  • params — itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres
  • lr — taux d'apprentissage
  • betas — coefficients utilisés pour le calcul des moyennes mobiles du gradient et de son carré
  • eps — terme ajouté au dénominateur pour améliorer la stabilité numérique
  • weight_decay — coefficient de décroissance du poids
  • caution — activer la prudence
  • corrected_weight_decay — appliquer une décroissance de poids corrigée (lr**2 / max_lr)
  • maximize — maximiser les paramètres en fonction de l'objectif, au lieu de les minimiser
  • foreach — indique si l’implémentation foreach de l’optimiseur est utilisée. Si non spécifié (None), l’implémentation foreach est utilisée sur CUDA (appareils disposant de noyaux foreach) car elle est plus rapide en général.
  • capturable — indique si cette instance peut être capturée en toute sécurité dans un graphe CUDA
  • clipping_threshold — seuil de rognage de la mise à jour RMS (StableAdamW, https://arxiv.org/abs/2304.13013), la mise à jour est mise à l’échelle par 1 / max(1, rms / clipping_threshold) où rms est le RMS de grad / (sqrt(v_hat) + eps). Atténue la mise à jour des paramètres en cas d’augmentation soudaine du gradient par rapport à leur estimation du second moment. 1.0 conformément à l’article, None (par défaut) désactive. Comme dans Adafactor, la décroissance de poids découplée n’est pas rognée (StableAdamW met également à l’échelle la décroissance par le lr rogné).

Implémente l'algorithme NAdamW.

Voir le tableau 1 dans https://arxiv.org/abs/1910.05446 pour l’implémentation de l’algorithme NAdam (il y a également un commentaire dans le code qui met en évidence la seule différence entre NAdamW et AdamW).

Pour plus de détails sur l'algorithme, nous renvoyons vers

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.NvNovoGrad

< >

( paramslr = 0.001betas = (0.95, 0.98)eps = 1e-08weight_decay = 0grad_averaging = Falseamsgrad = Falsedecoupled_decay = Falsecorrected_weight_decay = False )

Paramètres

  • params (iterable) — itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres
  • lr (float, optionnel) — taux d'apprentissage (par défaut : 1e-3)
  • betas (Tuple[float, float], optionnel) — coefficients utilisés pour le calcul des moyennes mobiles du gradient et de son carré (par défaut : (0.95, 0.98))
  • eps (float, facultatif) — terme ajouté au dénominateur pour améliorer la stabilité numérique (par défaut : 1e-8)
  • weight_decay (float, optionnel) — décroissance du poids (pénalité L2) (par défaut : 0)
  • grad_averaging — moyenne des gradients
  • amsgrad (booléen, facultatif) — indique s'il faut utiliser la variante AMSGrad de cet algorithme issue de l'article On the Convergence of Adam and Beyond_ (valeur par défaut : False)
  • decoupled_decay — applique le weight decay directement aux poids (lr * weight_decay à chaque étape) au lieu de l’ajouter au gradient normalisé avant la mise à jour de l’élan (comme dans l’article)
  • corrected_weight_decay — applique une décroissance de poids corrigée (lr**2 / max_lr) lorsque decoupled_decay est True

Implémente l'algorithme Novograd.

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle
  • and renvoie la perte. —

Effectue une étape d'optimisation unique.

classe timm.optim.RAdamLegacy

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-08weight_decay = 0 )

Optimiseur RAdam de PyTorch

NOTE : Cette impl a été dépréciée au profit de torch.optim.AdamW et reste en tant que référence

classe timm.optim.RMSpropTF

< >

( params: ParamsTlr: float = 0.01alpha: float = 0.9eps: float = 1e-10weight_decay: float = 0momentum: float = 0.0centered: bool = Falsedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falselr_in_momentum: bool = Truecaution: bool = Falseforeach: typing.Optional[bool] = None )

Paramètres

  • params — itérable de paramètres à optimiser ou dictionnaires définissant des groupes de paramètres
  • lr — taux d'apprentissage
  • momentum — facteur d'élan
  • alpha — constante de lissage (décroissance)
  • eps — terme ajouté au dénominateur pour améliorer la stabilité numérique
  • centered — si True, calcule le RMSProp centré, le gradient est normalisé par une estimation de sa variance
  • weight_decay — décroissance du poids (pénalité L2) (par défaut : 0)
  • decoupled_decay — décroissance du poids découplée selon https://arxiv.org/abs/1711.05101
  • corrected_weight_decay — applique une décroissance de poids corrigée (lr**2 / max_lr) lorsque decoupled_decay est True
  • lr_in_momentum — le facteur d'échelle du taux d'apprentissage est inclus dans la mise à jour du tampon de momentum, conformément aux valeurs par défaut de Tensorflow
  • caution — faites preuve de prudence
  • foreach — utiliser l’implémentation foreach (multi-tenseurs), utilisée par défaut (None) sauf si non prise en charge (voir rmsprop_tf())

Implémente l'algorithme RMSprop (epsilon de style TensorFlow)

NOTE : Il s'agit d'une copie directe de RMSprop de PyTorch avec eps appliqué avant la racine carrée et quelques autres modifications pour correspondre plus étroitement à Tensorflow lors de l'ajustement des hyperparamètres.

Les modifications notables incluent :

  1. Epsilon appliqué à l'intérieur de la racine carrée
  2. square_avg initialisé à des uns
  3. Mise à l'échelle du LR de la mise à jour accumulée dans le tampon de momentum

Proposé par G. Hinton dans son cours.

La version centrée apparaît pour la première fois dans Génération de séquences avec des réseaux de neurones récurrents.

étape

< >

( closure = None )

Paramètres

  • closure (appelable, facultatif) — Une fermeture qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

classe timm.optim.SGDP

< >

( paramslr = torch.optim.optimizer.requiredmomentum = 0dampening = 0weight_decay = 0nesterov = Falseeps = 1e-08delta = 0.1wd_ratio = 0.1caution = False )

classe timm.optim.SGDW

< >

( params: ParamsTlr: float = 0.001momentum: float = 0.0dampening: float = 0.0weight_decay: float = 0.0nesterov: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonedifferentiable: bool = False )

étape

< >

( closure = None )

Paramètres

  • closure (Callable, optionnel) — Une closure qui réévalue le modèle et renvoie la perte.

Effectue une étape d'optimisation unique.

Update on GitHub

←Pertes Planificateurs de taux d'apprentissage→