Hugging Face's logo

timm documentation

Optimización

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

Optimización

Esta página contiene la documentación de referencia de la API de los optimizadores incluidos en timm, y una descripción general de cómo se seleccionan y configuran a través de la fábrica de optimizadores.

Uso

Los optimizadores se crean por nombre con create_optimizer_v2. Dado un modelo, la fábrica construye los grupos de parámetros (exclusiones de decaimiento de peso, decaimiento opcional de la tasa de aprendizaje por capa) antes de construir el optimizador. Los argumentos específicos del optimizador se pasan como argumentos de palabra clave.

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))

El script de entrenamiento (train.py) expone lo mismo a través de estas banderas:

  • --opt selecciona el optimizador.
  • --lr establece la tasa de aprendizaje.
  • --weight-decay establece el decaimiento de pesos.
  • --momentum establece el momento.
  • --opt-eps establece epsilon (eps).
  • --opt-betas establece los coeficientes beta (betas).
  • --layer-decay establece el decaimiento de la tasa de aprendizaje por capa.
  • --opt-kwargs key=value ... pasa cualquier otro argumento del optimizador.

Convenciones de nomenclatura

Los nombres registrados están en minúsculas, un nombre de optimizador base más modificadores:

ModificadorSignificadoEjemplos
prefijo cVariante cautelosa, la actualización se enmascara donde su signo no coincide con el gradiente (Cautious Optimizers)cadamw, clion, cmars, cadopt
sufijo wDecaimiento de peso desacoplado (estilo AdamW), para optimizadores que por defecto utilizan decaimiento L2 acopladosgdw, lambw, adoptw, novogradw, rmsproptfw
sufijo cDecaimiento de pesos corregido: el decaimiento se escala por lr² / max_lr en lugar de lr (Por qué los gradientes aumentan rápidamente cerca del final del entrenamiento)adamc, nadamc, sgdc, lionc, adoptc, kronc
prefijo nMomentum de Nesterov (familias SGD, LARS y Muon)nesterov, nlars, nmuon, nadamuon
prefijo lookahead_Envuelve el optimizador en Lookaheadlookahead_adamw
prefijo fusedImplementación fusionada de NVIDIA Apex (requiere apex)fusedadamw, fusedlamb
prefijo bnbimplementación de bitsandbytes, sufijo 8bit para el estado de 8 bits (requiere bitsandbytes)bnbadamw, bnbadamw8bit

Algunos nombres son anteriores a las convenciones: lambc y larc son LAMB / LARS con recorte de la relación de confianza (la variante corregida de decaimiento de LAMB es lambcd), momentum es SGD con momento clásico y sgd es SGD con momento de Nesterov. Las implementaciones legacy de la tabla siguiente son anteriores a su inclusión en PyTorch.

Familias de optimizadores

NombresImplementaciónNotas
adamw, adam, nadam, radam, radamw, adamax, adadelta, adagrad, rmsprop, sgd, momentum, nesterovtorch.optim
adamwlegacy, adamc, cadamw, cadamcAdamWLegacyAdamW con precaución, decaimiento corregido, recorte de actualización, capturable
nadamw, nadamc, cnadamw, cnadamcNAdamWAdamW con momento de Nesterov (forma de eficiencia algorítmica de MLCommons)
adopt, adoptw, adoptc, cadopt, cadoptw, cadoptcAdoptVariante de Adam que converge para cualquier β2
adan, adanw, cadan, cadanwAdanMomentum adaptativo de Nesterov
adabelief, radabeliefAdaBeliefradabelief añade una rectificación de estilo RAdam
adafactor, cadafactorAdafactorAdafactor de fairseq, tamaño de paso relativo cuando lr=None
adafactorbv, adafactorbvc, cadafactorbv, cadafactorbvcAdafactorBigVisionBig Vision Adafactor, momentos de segundo orden factorizados, momento de baja precisión, recorte de actualización
adamp, cadamp, sgdp, csgdpAdamP, SGDPProyección de la actualización para pesos invariantes a la escala
adahessianAdahessianSegundo orden, requiere un cierre (is_second_order)
kron, kronw, kroncKronPSGD con un precondicionador factorizado de Kronecker
lamb, lambc, lambw, lambcw, lambcd, clamb, clambwLambMomentos adaptativos por capa, variantes trust_clip (lambc, lambcw)
laprop, lapropc, clapropLaPropMomentum y adaptabilidad separados
lars, larc, nlars, nlarcLarsEscala adaptativa de tasa por capa, variantes trust_clip (larc, nlarc)
lion, lionc, clion, clioncLionMomentum de señal evolucionado
madgrad, madgradwMADGRADPromedio dual basado en momento
mars, cmarsMarsReducción de varianza, actualización de estilo AdamW o Lion
muon, nmuon, adamuon, nadamuonMuonMomentum ortogonalizado Newton-Schulz para pesos 2D+, AdamW / NAdamW como alternativa para parámetros 1D
novograd, novogradw, novogradcNvNovoGradMomentos normalizados por capa
rmsproptf, rmsproptfw, rmsproptfc, crmsproptfRMSpropTFOrden de las operaciones y manejo de eps en TensorFlow, lr plegado en el búfer de momentum
sgdw, nesterovw, sgdc, csgdw, csgdcSGDWSGD con decaimiento de peso desacoplado
nadamlegacy, radamlegacyNAdamLegacy, RAdamLegacyImplementaciones de referencia, reemplazadas por torch.optim
fused*, bnb*NVIDIA Apex, bitsandbytesRegistrado cuando se instala el paquete

Opciones comunes

La mayoría de los optimizadores de timm comparten un conjunto de opciones además de los habituales lr, weight_decay, betas y eps. Puede comprobar qué optimizadores aceptan qué opciones en las firmas de las clases a continuación; la fábrica genera un error si se pasan argumentos no admitidos.

  • caution aplica la máscara de actualización cautelosa, equivalente a los nombres de registro con el prefijo c.
  • corrected_weight_decay escala el decaimiento de peso desacoplado por lr² / max_lr en lugar de lr (los nombres con el sufijo c), de modo que el decaimiento efectivo siga la programación de la tasa de aprendizaje. max_lr es la tasa de aprendizaje con la que se construyó el optimizador; constrúyalo con la lr de la programación pico (como lo hace train.py). Se conserva en cada grupo de parámetros (max_lr_snapshot) y se guarda / restaura junto con el estado del optimizador.
  • decoupled_decay (o decoupled) cambia los optimizadores que por defecto usan decaimiento L2 acoplado a un decaimiento estilo AdamW (los nombres con el sufijo w).
  • foreach selecciona la implementación multi-tensor. De forma predeterminada (None), se utiliza en CUDA y otros dispositivos con kernels foreach, coincidiendo con torch.optim, a menos que la configuración no lo soporte (un tensor lr sin capturable, o caution en una versión de PyTorch sin la sobrecarga _foreach_maximum_ requerida). El paso multi-tensor se ejecuta en lotes de parámetros de un tamaño tal que el conjunto de trabajo de cada lote permanezca en la caché L2 de la GPU, lo cual es más rápido que transmitir cada parámetro a través de la memoria una vez por operación en modelos grandes. El tamaño del lote se deriva del tamaño de la caché L2 del dispositivo (PyTorch >= 2.5) y se omite el loteo en dispositivos donde el lote resultante sería inferior a 4M de elementos. TIMM_FOREACH_CHUNK_SIZE=<elements> anula el tamaño del lote, y 0 deshabilita el loteo.
  • capturable (AdamWLegacy, NAdamW, Adopt, Muon) mantiene el recuento de pasos en el dispositivo para que el paso pueda capturarse en un grafo de CUDA. Todos los optimizadores aceptan un lr dado como un tensor de 0 dimensiones, actualizado in situ por una programación, para su uso con torch.compile y grafos de CUDA.
  • clipping_threshold (AdamWLegacy, NAdamW, AdafactorBigVision) recorta la actualización por su RMS, update / max(1, rms / threshold) con rms el RMS del gradiente normalizado por el segundo momento, por tensor (StableAdamW, Adafactor). 1.0 como en los artículos. Al igual que en Adafactor, el decaimiento de peso (desacoplado) no se recorta, StableAdamW también escala el decaimiento por la tasa de aprendizaje recortada.
  • maximize maximiza el objetivo en lugar de minimizarlo.

Se admiten parámetros de baja precisión (bfloat16, float16) en todo el proceso:

  • AdaBelief, RAdamLegacy y Adafactor mantienen su estado en float32 para parámetros de baja precisión.
  • AdafactorBigVision mantiene su momento en una precisión reducida (momentum_dtype).
  • Kron tiene opciones separadas mu_dtype / precond_dtype.

Estos dtypes de estado se conservan mediante load_state_dict (el cargador predeterminado de PyTorch convierte el estado al dtype del parámetro). Las funciones de paso evitan las sincronizaciones con el host (ramificaciones de Python dependientes de datos en tensores de dispositivo); la comprobación de proyección de AdamP / SGDP es la excepción.

Grupos de parámetros

Cuando se proporciona un modelo, create_optimizer_v2 agrupa los parámetros con param_groups_weight_decay (sin decaimiento para parámetros de 1D y el conjunto no_weight_decay() del modelo) o, con layer_decay establecido, param_groups_layer_decay, que asigna una escala de tasa de aprendizaje de layer_decay ** (num_layers - layer_id) por capa utilizando group_matcher() del modelo. Los modelos sin group_matcher() recurren a auto_group_layers, que necesita pretrained_cfg['classifier'] del modelo para separar la cabeza. Para optimizadores híbridos (Muon), los argumentos fallback_list y fallback_no_weight_decay dirigen los parámetros al optimizador de respaldo (AdamW).

API

Funciones de fábrica

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 )

Parámetros

  • model_or_params — Un modelo de PyTorch o un iterable de parámetros/grupos de parámetros. Si se proporciona un modelo, los parámetros se extraerán y agruparán automáticamente en función de los demás argumentos.
  • opt — Nombre del optimizador a crear (p. ej., ‘adam’, ‘adamw’, ‘sgd’). Use list_optimizers() para ver las opciones disponibles.
  • lr — Tasa de aprendizaje. Si es None, se usará el valor predeterminado del optimizador.
  • weight_decay — Factor de decaimiento de peso. Se usará para crear grupos de parámetros si model_or_params es un modelo.
  • momentum — Momentum factor for optimizers that support it. Only used if the chosen optimizer accepts a momentum parameter.
  • foreach — Habilita o deshabilita la implementación foreach (multi-tensor) si está disponible. Si es None, se usarán los valores predeterminados específicos del optimizador.
  • filter_bias_and_bn — Si es True, a los parámetros de sesgo y de capas de normalización (todos los parámetros 1d) no se les aplicará decaimiento de peso. Solo se usa cuando model_or_params es un modelo y weight_decay > 0.
  • fallback_list — Colección de patrones de nombres de parámetros para usar el optimizador de respaldo en optimizadores híbridos (p. ej., AdamW para Muon). Admite coincidencias con comodines.
  • fallback_no_weight_decay — Si es True, los parámetros en la lista no_weight_decay() del modelo usarán el optimizador de respaldo para los optimizadores híbridos (p. ej., AdamW para Muon).
  • layer_decay — Factor de decaimiento de la tasa de aprendizaje por capa, opcional. Si se proporciona, las tasas de aprendizaje se escalarán por layer_decay^(max_depth - layer_depth). Solo se utiliza cuando model_or_params es un modelo.
  • param_group_fn — Función opcional para crear grupos de parámetros personalizados. Si se proporciona, se ignorarán las demás opciones de agrupación de parámetros.
  • **kwargs — Argumentos adicionales específicos del optimizador (p. ej., betas para Adam).

Cree una instancia de optimizador a través del registro de timm.

Crea y configura un optimizador con grupos de parámetros y ajustes apropiados. Admite la creación automática de grupos de parámetros para el decaimiento de peso (weight decay) y las tasas de aprendizaje por capa, así como la agrupación personalizada de parámetros.

Ejemplos:

AdamW de un modelo, los grupos de parámetros se crean automáticamente:

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

SGD con momento y decaimiento de peso:

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

Adam con decaimiento de la tasa de aprendizaje por capa:

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

Grupos de parámetros personalizados:

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)

Nota: Precedencia del manejo de grupos de parámetros:

  1. Si se proporciona param_group_fn, se usará de forma exclusiva
  2. Si se proporciona layer_decay, se crearán grupos por capa
  3. Si weight_decay > 0 y filter_bias_and_bn es True, se crearán grupos de decaimiento de pesos
  4. En caso contrario, todos los parámetros estarán en un único grupo

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

Parámetros

  • filter — Cadena de filtro con comodines o lista de cadenas de filtro (p. ej., ‘adam’ para todas las variantes de Adam, o [‘adam’, ‘*8bit’] para variantes de Adam y optimizadores de 8 bits). Una cadena vacía significa que no se aplica ningún filtro.
  • exclude_filters — Lista opcional de patrones comodín para excluir. Por ejemplo, [’8bit’, ‘fused’] excluiría las implementaciones de 8 bits y fusionadas.
  • with_description — Si es True, devuelve tuplas de (name, description) en lugar de solo nombres. Las descripciones proporcionan explicaciones breves de las características del optimizador.

Devuelve

Si with_description es False

Lista de nombres de optimizadores como cadenas (p. ej., [‘adam’, ‘adamw’, …]) Si with_description es True: Lista de tuplas de (name, description) (p. ej., [(‘adam’, ‘Adaptive Moment…’), …])

Muestra los nombres de optimizadores disponibles, opcionalmente filtrados.

Muestra todos los optimizadores registrados, con filtrado opcional mediante patrones comodín. Los optimizadores se pueden filtrar usando patrones de inclusión y exclusión, y opcionalmente devolver descripciones junto con el nombre de cada optimizador.

Ejemplos:

>>> 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

Parámetros

  • name — Nombre del optimizador a recuperar (p. ej., ‘adam’, ‘sgd’)
  • bind_defaults — Si es True, devuelve una función parcial con los argumentos predeterminados de OptimInfo vinculados. Si es False, devuelve la clase de optimizador sin procesar.

Devuelve

Si bind_defaults es False

La clase de optimizador (p. ej., torch.optim.Adam) Si bind_defaults es True: Una función parcial con argumentos predeterminados vinculados

Lanza

ValueError

  • ValueError — Si el nombre del optimizador no se encuentra en el registro

Obtiene la clase de optimizador por nombre con la opción de vincular argumentos predeterminados.

Obtiene la clase de optimizador o una función parcial con argumentos predeterminados vinculados. Esto permite la instancia directa de optimizadores con sus configuraciones predeterminadas sin pasar por la fábrica completa.

Ejemplos:

Con los valores predeterminados del registro vinculados, sgd tiene el momento de nesterov habilitado:

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

La clase de optimizador sin procesar:

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 )

Parámetros

  • name — Nombre del optimizador

Lanza

ValueError

  • ValueError — Si no se encuentra el optimizador

Obtenga la OptimInfo de un optimizador.

Funciones de grupos de parámetros

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 )

Grupos de parámetros para el decaimiento del lr por capa & el decaimiento del peso Basado en BEiT: https://github.com/microsoft/unilm/blob/master/beit/optim_factory.py#L58

timm.optim.auto_group_layers

< >

( modellayers_per_group = 12num_groups = None )

Clases de optimizador

clase 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 )

Parámetros

  • params (iterable) — iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros
  • lr (float, opcional) — tasa de aprendizaje (predeterminado: 1e-3)
  • betas (Tuple[float, float], opcional) — coeficientes utilizados para calcular las medias móviles del gradiente y su cuadrado (predeterminado: (0.9, 0.999))
  • eps (float, opcional) — término añadido al denominador para mejorar la estabilidad numérica (predeterminado: 1e-16)
  • weight_decay (float, opcional) — decaimiento de peso (penalización L2) (predeterminado: 0)
  • amsgrad (boolean, opcional) — si se debe usar la variante AMSGrad de este algoritmo del artículo On the Convergence of Adam and Beyond_ (valor predeterminado: False)
  • decoupled_decay (boolean, opcional) — (predeterminado: True) Si se establece como True, el optimizador utiliza decaimiento de peso desacoplado, como en AdamW
  • fixed_decay (boolean, opcional) — (predeterminado: False) Se utiliza cuando weightdecouple se establece como True. Cuando fixed_decay == True, el decaimiento de los pesos se realiza como $W{new} = W{old} - W{old} \times decay$. Cuando fixeddecay == False, el decaimiento de los pesos se realiza como $W{new} = W{old} - W{old} \times decay \times lr$. Tenga en cuenta que, en este caso, la proporción de decaimiento de los pesos disminuye con la tasa de aprendizaje (lr).
  • rectify (boolean, opcional) — (predeterminado: True) Si se establece como True, se realiza la actualización rectificada similar a RAdam
  • degenerated_to_sgd (boolean, opcional) (predeterminado —True) Si se establece como True, se realiza una actualización de SGD cuando la varianza del gradiente es alta
  • foreach (boolean, opcional) — usar la implementación foreach (multi-tensor), por defecto (None) se usa a menos que no sea compatible

Implementa el algoritmo AdaBelief. Modificado a partir de Adam en PyTorch

referencia: Optimizador AdaBelief, adaptación de los tamaños de paso según la confianza en los gradientes observados, NeurIPS 2020

Para una tabla completa de hiperparámetros recomendados, consulte https://github.com/juntang-zhuang/Adabelief-Optimizer’ Por ejemplo, para los argumentos de entrenamiento de EfficientNet, consulte estos gists

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 )

Implementa el algoritmo Adafactor.

Esta implementación se basa en: Adafactor: Adaptive Learning Rates with Sublinear Memory Cost (ver https://arxiv.org/abs/1804.04235)

Tenga en cuenta que este optimizador ajusta internamente la tasa de aprendizaje en función de las opciones scale_parameter, relative_step y warmup_init.

Se utiliza un programa de tasa de aprendizaje manual (externo) cuando lr está establecido (relative_step es entonces False). Tenga en cuenta que en esta implementación scale_parameter y warmup_init solo se aplican a la tasa de aprendizaje de paso relativo (lr=None), a diferencia de fairseq / HF Transformers, la escalación RMS del parámetro no se aplica a una tasa de aprendizaje externa.

Ags: params: iterable de parámetros a optimizar o diccionarios que definen grupos de parámetros lr: tasa de aprendizaje externa eps: constantes de regularización para el gradiente cuadrado y la escala del parámetro, respectivamente eps_scale: constantes de regularización para la escala del parámetro, respectivamente clip_threshold: umbral de la raíz media cuadrada de la actualización final del gradiente decay_rate: coeficiente utilizado para calcular las medias móviles del gradiente cuadrado beta1: coeficiente utilizado para calcular las medias móviles del gradiente weight_decay: decaimiento de peso scale_parameter: si es True, la tasa de aprendizaje del paso relativo se escala por la raíz media cuadrada del parámetro warmup_init: el cálculo de la tasa de aprendizaje dependiente del tiempo depende de si se está utilizando una inicialización de calentamiento

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una función de cierre que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 )

Implementación de PyTorch de la variante de Adafactor de BigVision, con implementaciones de tensor único y multi tensor.

Adaptado de https://github.com/google-research/big_vision por Ross Wightman

clase 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 )

Parámetros

  • params (iterable) — iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros
  • lr (float, opcional) — tasa de aprendizaje (predeterminado: 0.1)
  • betas ((float, float), opcional) — coeficientes utilizados para calcular las medias móviles del gradiente y la traza del hessiano al cuadrado (predeterminado: (0.9, 0.999))
  • eps (float, opcional) — término añadido al denominador para mejorar la estabilidad numérica (predeterminado: 1e-8)
  • weight_decay (float, opcional) — decaimiento de peso (penalización L2) (predeterminado: 0.0)
  • hessian_power (float, opcional) — exponente de la traza de la hessiana (predeterminado: 1.0)
  • update_each (int, opcional) — calcular la aproximación de la traza de la hessiana solo después de este número de pasos (para ahorrar tiempo) (predeterminado: 1)
  • n_samples (int, opcional) — cuántas veces muestrear z para la aproximación de la traza de la hessiana (predeterminado: 1)

Implements the AdaHessian algorithm from “ADAHESSIAN: An Adaptive Second OrderOptimizer for Machine Learning”

get_params

< >

( )

Obtiene todos los parámetros en todos los param_groups con gradientes

set_hessian

< >

( )

Calcula la aproximación de Hutchinson de la traza de la hessiana y la acumula para cada parámetro entrenable.

paso

< >

( closure = None )

Parámetros

  • closure (llamable, opcional) — una función de cierre que reevalúa el modelo y devuelve la pérdida (predeterminado — None)

Realiza un paso de optimización.

zero_hessian

< >

( )

Pone a cero las trazas hessianas acumuladas.

clase timm.optim.AdamP

< >

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

clase 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 )

Parámetros

  • params — iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros
  • lr — tasa de aprendizaje
  • betas — coeficientes utilizados para calcular las medias móviles del gradiente y su cuadrado
  • eps — término añadido al denominador para mejorar la estabilidad numérica
  • weight_decay — coeficiente de decaimiento de peso
  • amsgrad — si se debe usar la variante AMSGrad de este algoritmo del artículo On the Convergence of Adam and Beyond
  • caution — usa AdamW con precaución
  • corrected_weight_decay — aplicar decaimiento de peso corregido (lr**2 / max_lr)
  • maximize — maximiza los parámetros en función del objetivo, en lugar de minimizarlos
  • foreach — si se utiliza la implementación foreach del optimizador. Si el usuario no lo especifica (es decir, foreach es None), intentaremos usar foreach en lugar de la implementación con bucle for en CUDA, ya que en general es más rápida.
  • capturable — si esta instancia es segura para capturar en un grafo de CUDA. Pasar True puede deteriorar el rendimiento no graficado, por lo que si no tiene la intención de capturar en un grafo esta instancia, déjelo en False
  • clipping_threshold — umbral de recorte para la actualización RMS (StableAdamW, https://arxiv.org/abs/2304.13013), la actualización se escala por 1 / max(1, rms / clipping_threshold) donde rms es el RMS de grad / (sqrt(v_hat) + eps). Amortigua la actualización de los parámetros con un aumento repentino del gradiente en relación con su estimación del segundo momento. 1.0 según el artículo, None (predeterminado) lo desactiva. Al igual que en Adafactor, el decaimiento de peso desacoplado no se recorta (StableAdamW también escala el decaimiento por el lr recortado).

Implementa el algoritmo AdamW.

NOTA: Esta implementación ha quedado obsoleta en favor de torch.optim.AdamW y se mantiene como referencia

Referencias:

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 )

Parámetros

  • params — Iterables de parámetros para optimizar o diccionarios que definen grupos de parámetros.
  • lr — Tasa de aprendizaje.
  • betas — Coeficientes utilizados para los momentos de primer y segundo orden.
  • eps — Término añadido al denominador para mejorar la estabilidad numérica.
  • weight_decay — Decaimiento de pesos desacoplado (penalización L2)
  • no_prox — Cómo aplicar el decaimiento de pesos
  • caution — Habilitar la precaución desde ‘Cautious Optimizers’
  • foreach — Si es True, se usará la implementación de torch._foreach. Es más rápida, pero usa un poco más de memoria.

Implementa una variante de Adan para PyTorch.

Adan fue propuesto en Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models https://arxiv.org/abs/2208.06677

paso

< >

( closure = None )

Realiza un paso de optimización.

clase 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 modificado puede converger con cualquier β2 con la tasa óptima: https://arxiv.org/abs/2411.02853

paso

< >

( closure = None )

Parámetros

  • closure (Callable, opcional) — Una función de cierre que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 )

Parámetros

  • params — Iterables de parámetros para optimizar o diccionarios que definen grupos de parámetros.
  • lr — Tasa de aprendizaje.
  • momentum — Momentum parameter.
  • weight_decay — Decaimiento de peso.
  • preconditioner_update_probability — Probabilidad de actualizar el precondicionador. Si es None, el valor predeterminado es un programa que reduce gradualmente de 1.0 a 0.03 en 4000 pasos.
  • max_size_triangular — Tamaño máximo para que el precondicionador de dim sea triangular.
  • min_ndim_triangular — Número mínimo de dimensiones que una capa debe tener para usar precondicionadores triangulares.
  • memory_save_mode — ‘one_diag’, ‘smart_one_diag’ o ‘all_diag’, el valor predeterminado es None para establecer todos los precondicionadores como triangulares, ‘one_diag’ establece la dimensión más grande o la última como diagonal por capa, y ‘all_diag’ establece todos los precondicionadores como diagonales.
  • momentum_into_precond_update — si se envía el momentum a la actualización del precondicionador en lugar de los gradientes crudos.
  • mu_dtype — Dtype del acumulador de momento.
  • precond_dtype — Dtype del precondicionador.
  • decoupled_decay — decaimiento de peso desacoplado estilo AdamW
  • corrected_weight_decay — aplicar un decaimiento de peso corregido al usar decoupled_decay (lr**2 / max_lr)
  • flatten — Aplana las dimensiones en lugar de depender por completo de las expresiones para parámetros de rango superior
  • flatten_start_dim — Inicio del rango de aplanamiento, el valor predeterminado es 2. Parece un buen compromiso para las ConvNets.
  • flatten_end_dim — Final del rango de aplanado, valor predeterminado -1.
  • stochastic_weight_decay — Habilita la modulación aleatoria del decaimiento de pesos
  • deterministic — Comportamiento determinista entre guardar / cargar (reanudar). FIXME lento, necesita trabajo

Implementa PSGD Kron de https://github.com/lixilinx/psgd_torch.

clase 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 )

Parámetros

  • params — Iterables de parámetros para optimizar o diccionarios que definen grupos de parámetros.
  • lr — Tasa de aprendizaje
  • betas — Coeficientes utilizados para calcular las medias móviles del gradiente y su norma.
  • eps — Término añadido al denominador para mejorar la estabilidad numérica.
  • weight_decay — Decaimiento de peso
  • grad_averaging — Si se aplica (1-beta2) al gradiente al calcular las medias móviles del gradiente.
  • max_grad_norm — Valor utilizado para recortar la norma global del gradiente.
  • trust_clip — Habilita el recorte de la relación de confianza de LAMBC.
  • always_adapt — Aplica la tasa de aprendizaje adaptativa al parámetro de decaimiento de peso 0.0.
  • caution — Aplique precaución.
  • decoupled — aplicar decaimiento de peso desacoplado
  • corrected_weight_decay — aplicar un decaimiento de peso corregido (lr**2 / max_lr) al usar decoupled_decay
  • foreach — usa la implementación foreach (multi-tensor), por defecto (None) se usa a menos que no sea compatible

Implementa una variante de pytorch puro del optimizador FuseLAMB (variante NvLamb) de apex.optimizers.FusedLAMB referencia: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py

LAMB fue propuesto en:

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 )

Parámetros

  • foreach — usa la implementación foreach (multi-tensor), por defecto (None) se usa a menos que no sea compatible (ver laprop())

Optimizador LaProp

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

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase timm.optim.Lars

< >

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

Parámetros

  • params (iterable) — iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros.
  • lr (float, opcional) — tasa de aprendizaje (predeterminado: 1.0).
  • momentum (float, opcional) — factor de momentum (predeterminado: 0)
  • weight_decay (float, opcional) — decaimiento de peso (penalización L2) (predeterminado: 0)
  • dampening (float, opcional) — amortiguación para el momento (predeterminado: 0)
  • nesterov (bool, opcional) — habilita el momento de Nesterov (predeterminado: False)
  • trust_coeff (float) — coeficiente de confianza para calcular lr adaptativo / trust_ratio (predeterminado: 0.001)
  • eps (float) — eps para el denominador de la división (predeterminado: 1e-8)
  • trust_clip (bool) — habilita el recorte de la relación de confianza de LARC (predeterminado: False)
  • always_adapt (bool) — aplicar siempre la adaptación de LARS LR, de lo contrario solo cuando group weight_decay != 0 (predeterminado: False)
  • foreach (bool, opcional) — usar la implementación foreach (multi-tensor), por defecto (None) se usa a menos que no sea compatible

LARS para PyTorch

Artículo: Large batch training of Convolutional Networks - https://arxiv.org/pdf/1708.03888.pdf

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una función de cierre que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 )

Implementa el algoritmo Lion.

paso

< >

( closure = None )

Parámetros

  • closure — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase timm.optim.Lookahead

< >

( base_optimizeralpha = 0.5k = 6 )

clase timm.optim.MADGRAD

< >

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

Parámetros

  • params (iterable) — Iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros.
  • lr (float) — Tasa de aprendizaje (predeterminada: 1e-2).
  • momentum (float) — Valor de momentum en el rango [0,1) (predeterminado: 0.9).
  • weight_decay (float) — Decaimiento de peso, es decir, una penalización L2 (predeterminado: 0).
  • eps (float) — Término que se suma al denominador, fuera de la operación de raíz, para mejorar la estabilidad numérica. (valor predeterminado: 1e-6).

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

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

MADGRAD es un optimizador de uso general que puede utilizarse en lugar de SGD o Adam y que puede converger más rápido y generalizar mejor. Actualmente, solo es compatible con GPU. Por lo general, se puede utilizar la misma programación de tasa de aprendizaje que se usa para SGD o Adam. La tasa de aprendizaje global no es comparable a la de ninguno de los dos métodos y debe determinarse mediante un barrido de hiperparámetros.

MADGRAD requiere menos decaimiento de peso que otros métodos, a menudo tan poco como cero. Los valores de momento utilizados para SGD o beta1 de Adam deberían funcionar también aquí.

En problemas dispersos, tanto weight_decay como momentum deben establecerse en 0.

paso

< >

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

Parámetros

  • closure (callable, opcional) — Una función de cierre que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 )

Optimizador MARS

Artículo: MARS: Liberando el poder de la reducción de varianza para el entrenamiento de modelos grandes https://arxiv.org/abs/2411.10438

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 - Momento Ortogonalizado por Newton-Schulz

Combina Muon para parámetros de 2D o más (matrices de pesos) con AdamW para parámetros de 1D (sesgos, normas) y grupos de parámetros con ‘use_fallback=True’ establecido (o ‘use_muon=False’ para compatibilidad).

Admite dos algoritmos:

  • “muon”: Algoritmo Muon estándar con momento + ortogonalización
  • “adamuon”: algoritmo AdaMuon que añade estimación del segundo momento elemento a elemento a las direcciones ortogonalizadas para una escalado adaptativo similar al de Adam

paso

< >

( closure = None )

Realiza un paso de optimización.

clase timm.optim.NAdamLegacy

< >

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

Parámetros

  • params (iterable) — iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros
  • lr (float, opcional) — tasa de aprendizaje (predeterminado: 2e-3)
  • betas (Tuple[float, float], opcional) — coeficientes utilizados para calcular las medias móviles del gradiente y su cuadrado
  • eps (float, opcional) — término añadido al denominador para mejorar la estabilidad numérica (predeterminado: 1e-8)
  • weight_decay (float, opcional) — decaimiento de peso (penalización L2) (predeterminado: 0)
  • schedule_decay (float, opcional) — decaimiento del programa de momentum (predeterminado: 4e-3)

Implementa el algoritmo Nadam (una variante de Adam basada en el momento de Nesterov).

NOTA: Esta implementación ha quedado obsoleta en favor de torch.optim.NAdam y se mantiene como referencia

Se ha propuesto en Incorporating Nesterov Momentum into Adam__.

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

Originalmente tomado de: https://github.com/pytorch/pytorch/pull/1408 NOTA: Puede tener problemas, pero funciona bien en algunos casos.

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase 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 )

Parámetros

  • params — iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros
  • lr — tasa de aprendizaje
  • betas — coeficientes utilizados para calcular las medias móviles del gradiente y su cuadrado
  • eps — término añadido al denominador para mejorar la estabilidad numérica
  • weight_decay — coeficiente de decaimiento de peso
  • caution — habilitar la precaución
  • corrected_weight_decay — aplicar decaimiento de peso corregido (lr**2 / max_lr)
  • maximize — maximiza los parámetros en función del objetivo, en lugar de minimizarlos
  • foreach — si se utiliza la implementación foreach del optimizador. Si no se especifica (None), se utiliza la implementación foreach en CUDA (dispositivos con kernels foreach) ya que en general es más rápida.
  • capturable — si esta instancia es segura para capturar en un grafo de CUDA
  • clipping_threshold — umbral de recorte para la actualización RMS (StableAdamW, https://arxiv.org/abs/2304.13013), la actualización se escala por 1 / max(1, rms / clipping_threshold) donde rms es el RMS de grad / (sqrt(v_hat) + eps). Amortigua la actualización de los parámetros con un aumento repentino del gradiente en relación con su estimación del segundo momento. 1.0 según el artículo, None (predeterminado) lo desactiva. Al igual que en Adafactor, el decaimiento de peso desacoplado no se recorta (StableAdamW también escala el decaimiento por el lr recortado).

Implementa el algoritmo NAdamW.

Consulte la Tabla 1 en https://arxiv.org/abs/1910.05446 para la implementación del algoritmo NAdam (también hay un comentario en el código que destaca la única diferencia entre NAdamW y AdamW).

Para más detalles sobre el algoritmo, remitimos a

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase timm.optim.NvNovoGrad

< >

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

Parámetros

  • params (iterable) — iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros
  • lr (float, opcional) — tasa de aprendizaje (predeterminado: 1e-3)
  • betas (Tuple[float, float], opcional) — coeficientes utilizados para calcular las medias móviles del gradiente y su cuadrado (predeterminado: (0.95, 0.98))
  • eps (float, opcional) — término añadido al denominador para mejorar la estabilidad numérica (predeterminado: 1e-8)
  • weight_decay (float, opcional) — decaimiento de peso (penalización L2) (predeterminado: 0)
  • grad_averaging — promedio de gradientes
  • amsgrad (boolean, opcional) — si se debe usar la variante AMSGrad de este algoritmo del artículo On the Convergence of Adam and Beyond_ (valor predeterminado: False)
  • decoupled_decay — aplicar el decaimiento de peso directamente a los pesos (lr * weight_decay por paso) en lugar de añadirlo al gradiente normalizado antes de la actualización del momento (según el artículo)
  • corrected_weight_decay — aplicar decaimiento de peso corregido (lr**2 / max_lr) cuando decoupled_decay es True

Implementa el algoritmo Novograd.

paso

< >

( closure = None )

Parámetros

  • closure (llamable, opcional) — Una función de cierre que reevalúa el modelo
  • and devuelve la pérdida. —

Realiza un paso de optimización.

clase timm.optim.RAdamLegacy

< >

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

Optimizador RAdam de PyTorch

NOTA: Esta implementación ha quedado obsoleta en favor de torch.optim.AdamW y se mantiene como referencia

clase 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 )

Parámetros

  • params — iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros
  • lr — tasa de aprendizaje
  • momentum — factor de momentum
  • alpha — constante de suavizado (decaimiento)
  • eps — término añadido al denominador para mejorar la estabilidad numérica
  • centered — si es True, se calcula el RMSProp centrado, la gradiente se normaliza mediante una estimación de su varianza
  • weight_decay — decaimiento de pesos (penalización L2) (predeterminado: 0)
  • decoupled_decay — decaimiento de peso desacoplado según https://arxiv.org/abs/1711.05101
  • corrected_weight_decay — aplicar decaimiento de peso corregido (lr**2 / max_lr) cuando decoupled_decay es True
  • lr_in_momentum — la escalada de la tasa de aprendizaje se incluye en la actualización del búfer de momentum, según los valores predeterminados de Tensorflow
  • caution — aplicar precaución
  • foreach — usa la implementación foreach (multi-tensor), por defecto (None) se usa a menos que no sea compatible (ver rmsprop_tf())

Implementa el algoritmo RMSprop (epsilon estilo TensorFlow)

NOTA: Esto es una copia directa de PyTorch RMSprop con eps aplicado antes de sqrt y algunas otras modificaciones para coincidir más de cerca con Tensorflow al usar hiperparámetros equivalentes.

Los cambios notables incluyen:

  1. Epsilon aplicado dentro de la raíz cuadrada
  2. square_avg inicializado con unos
  3. Escala de LR de la actualización acumulada en el búfer de momentum

Propuesto por G. Hinton en su curso.

La versión centrada aparece por primera vez en Generating Sequences With Recurrent Neural Networks.

paso

< >

( closure = None )

Parámetros

  • closure (callable, opcional) — Una closure que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

clase timm.optim.SGDP

< >

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

clase 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 )

paso

< >

( closure = None )

Parámetros

  • closure (Callable, opcional) — Una función de cierre que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización.

Update on GitHub

←Pérdidas Programadores de tasa de aprendizaje→