timm 文档

优化

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始

优化

此页面包含 timm 中学习率优化器的 API 参考文档。

优化器

工厂函数

timm.optim.create_optimizer_v2

< >

( model_or_params: typing.Union[torch.nn.modules.module.Module, typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] opt: str = 'sgd' lr: typing.Optional[float] = None weight_decay: float = 0.0 momentum: float = 0.9 foreach: typing.Optional[bool] = None filter_bias_and_bn: bool = True layer_decay: typing.Optional[float] = None param_group_fn: typing.Optional[typing.Callable[[torch.nn.modules.module.Module], typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]]]] = None **kwargs: typing.Any )

参数

  • model_or_params — 一个 PyTorch 模型或参数/参数组的可迭代对象。如果提供模型,将根据其他参数自动提取和分组参数。
  • opt — 要创建的优化器的名称(例如,‘adam’、‘adamw’、‘sgd’)。使用 list_optimizers() 查看可用选项。
  • lr — 学习率。如果为 None,将使用优化器的默认值。
  • weight_decay — 权重衰减因子。如果 model_or_params 是模型,将用于创建参数组。
  • momentum — 支持动量的优化器的动量因子。仅当选择的优化器接受动量参数时使用。
  • foreach — 如果可用,启用/禁用 foreach(多张量)实现。如果为 None,将使用特定于优化器的默认值。
  • filter_bias_and_bn — 如果为 True,则偏差、归一化层参数(所有 1d 参数)将不会应用权重衰减。仅当 model_or_params 是模型且 weight_decay > 0 时使用。
  • layer_decay — 可选的逐层学习率衰减因子。如果提供,学习率将按 layer_decay^(max_depth - layer_depth) 缩放。仅当 model_or_params 是模型时使用。
  • param_group_fn — 用于创建自定义参数组的可选函数。如果提供,将忽略其他参数分组选项。
  • **kwargs — 其他特定于优化器的参数(例如,Adam 的 betas)。

通过 timm 注册表创建优化器实例。

创建和配置具有适当参数组和设置的优化器。支持为权重衰减和逐层学习率自动创建参数组,以及自定义参数分组。

示例

使用模型的基本用法

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

具有动量和权重衰减的 SGD

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

具有逐层学习率衰减的 Adam

optimizer = create_optimizer_v2( … model, ‘adam’, lr=1e-3, layer_decay=0.7 … )

自定义参数组

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

注意:参数组处理优先级

  1. 如果提供了 param_group_fn,将独占使用它。
  2. 如果提供了 layer_decay,将创建逐层组。
  3. 如果 weight_decay > 0 且 filter_bias_and_bn 为 True,将创建权重衰减组。
  4. 否则,所有参数将位于单个组中。

timm.optim.list_optimizers

< >

( filter: typing.Union[str, typing.List[str]] = '' exclude_filters: typing.Optional[typing.List[str]] = None with_description: bool = False ) 如果 with_description 为 False

参数

  • filter — 通配符样式的过滤器字符串或过滤器字符串列表(例如,‘adam*’ 代表所有 Adam 变体,或 [‘adam*’, ‘*8bit’] 代表 Adam 变体和 8 位优化器)。空字符串表示不进行过滤。
  • exclude_filters — 要排除的通配符模式的可选列表。例如,[’*8bit’, ‘fused*’] 将排除 8 位和融合实现。
  • with_description — 如果为 True,则返回 (name, description) 元组,而不是仅返回名称。描述提供了优化器特性的简要说明。

返回

如果 with_description 为 False

优化器名称字符串列表(例如,[‘adam’、‘adamw’、…])。如果 with_description 为 True:(name, description) 元组列表(例如,[(‘adam’, ‘Adaptive Moment…’), …])

列出可用的优化器名称,可选择过滤。

列出所有已注册的优化器,可选择使用通配符模式进行过滤。可以使用包含和排除模式过滤优化器,并且可以选择返回每个优化器名称的描述。

示例

list_optimizers() [‘adam’, ‘adamw’, ‘sgd’, …]

list_optimizers([‘la*’, ‘nla*’]) # 列出 lamb 和 lars [‘lamb’, ‘lambc’, ‘larc’, ‘lars’, ‘nlarc’, ‘nlars’]

list_optimizers(’*adam*’, exclude_filters=[‘bnb*’, ‘fused*’]) # 排除 bnb 和 apex adam 优化器 [‘adam’, ‘adamax’, ‘adamp’, ‘adamw’, ‘nadam’, ‘nadamw’, ‘radam’]

list_optimizers(with_description=True) # 获取描述 [(‘adabelief’, ‘根据梯度预测误差调整学习率’), (‘adadelta’, ‘torch.optim Adadelta, 根据梯度运行窗口调整学习率’), (‘adafactor’, ‘Adam 的内存高效实现,具有分解梯度’), …]

timm.optim.get_optimizer_class

< >

( name: str bind_defaults: bool = True ) 如果 bind_defaults 为 False

参数

  • name — 要检索的优化器的名称(例如,‘adam’、‘sgd’)
  • bind_defaults — 如果为 True,则返回一个部分函数,其中包含来自 OptimInfo 绑定的默认参数。如果为 False,则返回原始优化器类。

返回

如果 bind_defaults 为 False

优化器类(例如,torch.optim.Adam)。如果 bind_defaults 为 True:具有默认参数绑定的部分函数。

抛出

ValueError

  • ValueError — 如果在注册表中找不到优化器名称

通过名称获取优化器类,可以选择绑定默认参数。

检索优化器类或具有默认参数绑定的部分函数。这允许直接实例化优化器及其默认配置,而无需经过完整的工厂。

示例

获取带有Nesterov动量默认值的SGD

SGD = get_optimizer_class(‘sgd’) # nesterov=True bound opt = SGD(model.parameters(), lr=0.1, momentum=0.9)

获取原始优化器类

SGD = get_optimizer_class(‘sgd’) opt = SGD(model.parameters(), lr=1e-3, momentum=0.9)

优化器类

class timm.optim.AdaBelief

< >

( params lr = 0.001 betas = (0.9, 0.999) eps = 1e-16 weight_decay = 0 amsgrad = False decoupled_decay = True fixed_decay = False rectify = True degenerated_to_sgd = True )

参数

  • params (iterable) — 要优化的参数的可迭代对象或定义参数组的字典
  • lr (float, optional) — 学习率 (默认值: 1e-3)
  • betas (Tuple[float, float], optional) — 用于计算梯度及其平方的运行平均值的系数 (默认值: (0.9, 0.999))
  • eps (float, optional) — 添加到分母以提高数值稳定性的项 (默认值: 1e-16)
  • weight_decay (float, optional) — 权重衰减 (L2 惩罚) (默认值: 0)
  • amsgrad (boolean, optional) — 是否使用论文 On the Convergence of Adam and Beyond_ 中的 AMSGrad 变体 (默认值: False)
  • decoupled_decay (boolean, optional) — (默认值: True) 如果设置为 True,则优化器使用与 AdamW 中相同的解耦权重衰减
  • fixed_decay (boolean, optional) — (默认值: False) 当 weight_decouple 设置为 True 时使用。当 fixed_decay == True 时,权重衰减执行为 $W_{new} = W_{old} - W_{old} \times decay$。当 fixed_decay == False 时,权重衰减执行为 $W_{new} = W_{old} - W_{old} \times decay \times lr$。请注意,在这种情况下,权重衰减率随着学习率 (lr) 降低。
  • rectify (boolean, optional) — (默认值: True) 如果设置为 True,则执行类似于 RAdam 的整流更新
  • degenerated_to_sgd (boolean, optional) (默认值 —True) 如果设置为 True,则在梯度方差较高时执行 SGD 更新

实现了 AdaBelief 算法。从 PyTorch 中的 Adam 修改而来

参考文献: AdaBelief Optimizer, adapting stepsizes by the belief in observed gradients, NeurIPS 2020

有关推荐超参数的完整表格,请参阅 https://github.com/juntang-zhuang/Adabelief-Optimizer’ 例如,有关 EfficientNet 的 train/args,请参阅这些要点

step

< >

( closure = None )

参数

  • closure (callable, optional) — 重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.Adafactor

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: typing.Optional[float] = None eps: float = 1e-30 eps_scale: float = 0.001 clip_threshold: float = 1.0 decay_rate: float = -0.8 betas: typing.Optional[typing.Tuple[float, float]] = None weight_decay: float = 0.0 scale_parameter: bool = True warmup_init: bool = False min_dim_size_to_factor: int = 16 caution: bool = False )

实现了 Adafactor 算法。

此实现基于: Adafactor: Adaptive Learning Rates with Sublinear Memory Cost (参见 https://arxiv.org/abs/1804.04235)

请注意,此优化器在内部调整学习率,具体取决于 scale_parameterrelative_stepwarmup_init 选项。

要使用手动(外部)学习率计划,您应设置 scale_parameter=Falserelative_step=False

参数 (Args): params: 要优化的参数的可迭代对象或定义参数组的字典 lr: 外部学习率 eps: 分别用于平方梯度和参数尺度的正则化常数 eps_scale: 分别用于参数尺度的正则化常数 clip_threshold: 最终梯度更新的均方根阈值 decay_rate: 用于计算平方梯度的运行平均值的系数 beta1: 用于计算梯度运行平均值的系数 weight_decay: 权重衰减 scale_parameter: 如果为 True,则学习率按参数的均方根缩放 warmup_init: 时间相关的学习率计算取决于是否正在使用预热初始化

step

< >

( closure = None )

参数

  • closure (callable, optional) — 重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.AdafactorBigVision

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: float = 1.0 min_dim_size_to_factor: int = 16 decay_rate: float = 0.8 decay_offset: int = 0 beta2_cap: float = 0.999 momentum: typing.Optional[float] = 0.9 momentum_dtype: typing.Union[str, torch.dtype] = torch.bfloat16 eps: typing.Optional[float] = None weight_decay: float = 0.0 clipping_threshold: typing.Optional[float] = None unscaled_wd: bool = False caution: bool = False foreach: typing.Optional[bool] = False )

BigVision 的 Adafactor 变体的 PyTorch 实现,具有单张量和多张量实现。

由 Ross Wightman 改编自 https://github.com/google-research/big_vision

class timm.optim.Adahessian

< >

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

参数

  • params (iterable) — 可迭代的参数,用于优化,或定义参数组的字典
  • lr (float, optional) — 学习率 (默认值: 0.1)
  • betas ((float, float), optional) — 用于计算梯度和海森矩阵迹的运行平均值的系数 (默认值: (0.9, 0.999))
  • eps (float, optional) — 添加到分母以提高数值稳定性的项 (默认值: 1e-8)
  • weight_decay (float, optional) — 权重衰减 (L2 惩罚) (默认值: 0.0)
  • hessian_power (float, optional) — 海森矩阵迹的指数 (默认值: 1.0)
  • update_each (int, optional) — 计算海森矩阵迹近似的步数间隔 (为了节省时间) (默认值: 1)
  • n_samples (int, optional) — 为了近似海森矩阵迹,对 z 采样的次数 (默认值: 1)

实现了来自 “ADAHESSIAN: An Adaptive Second OrderOptimizer for Machine Learning” 的 AdaHessian 算法

get_params

< >

( )

获取所有具有梯度的参数组中的所有参数

set_hessian

< >

( )

计算海森矩阵迹的 Hutchinson 近似,并为每个可训练参数累积它。

step

< >

( closure = None )

参数

  • closure (callable, optional) — 一个重新评估模型并返回损失的闭包 (默认值 — None)

执行单个优化步骤。

zero_hessian

< >

( )

将累积的海森矩阵迹归零。

class timm.optim.AdamP

< >

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

class timm.optim.Adan

< >

( params lr: float = 0.001 betas: typing.Tuple[float, float, float] = (0.98, 0.92, 0.99) eps: float = 1e-08 weight_decay: float = 0.0 no_prox: bool = False caution: bool = False foreach: typing.Optional[bool] = None )

参数

  • params — 用于优化的参数的可迭代对象或定义参数组的字典。
  • lr — 学习率。
  • betas — 用于一阶和二阶矩的系数。
  • eps — 添加到分母以提高数值稳定性的项。
  • weight_decay — 解耦权重衰减 (L2 惩罚)
  • no_prox — 如何执行权重衰减
  • caution — 启用来自 ‘Cautious Optimizers’ 的谨慎模式
  • foreach — 如果为 True,将使用 torch._foreach 实现。速度更快,但使用稍多的内存。

实现了 Adan 的 pytorch 变体。

Adan 在 Adan 中被提出: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models https://arxiv.org/abs/2208.06677

step

< >

( closure = None )

执行单个优化步骤。

class timm.optim.Adopt

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: typing.Union[float, torch.Tensor] = 0.001 betas: typing.Tuple[float, float] = (0.9, 0.9999) eps: float = 1e-06 clip_exp: typing.Optional[float] = 0.333 weight_decay: float = 0.0 decoupled: bool = False caution: bool = False foreach: typing.Optional[bool] = False maximize: bool = False capturable: bool = False differentiable: bool = False )

ADOPT: 修改后的 Adam 可以在任何 β2 下以最优速率收敛: https://arxiv.org/abs/2411.02853

step

< >

( closure = None )

参数

  • closure (Callable, 可选) — 一个重新评估模型并返回损失的闭包。

执行单次优化步骤。

class timm.optim.Lamb

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: float = 0.001 bias_correction: bool = True betas: typing.Tuple[float, float] = (0.9, 0.999) eps: float = 1e-06 weight_decay: float = 0.01 grad_averaging: bool = True max_grad_norm: typing.Optional[float] = 1.0 trust_clip: bool = False always_adapt: bool = False caution: bool = False decoupled_decay: bool = False )

参数

  • params — 要优化的参数的可迭代对象或定义参数组的字典。
  • lr — 学习率
  • betas — 用于计算梯度及其范数的运行平均值的系数。
  • eps — 添加到分母以提高数值稳定性的项。
  • weight_decay — 权重衰减
  • grad_averaging — 在计算梯度运行平均值时是否将 (1-beta2) 应用于梯度。
  • max_grad_norm — 用于裁剪全局梯度范数的值。
  • trust_clip — 启用 LAMBC 信任率裁剪。
  • always_adapt — 将自适应学习率应用于 0.0 权重衰减参数。
  • caution — 应用 caution。

实现了 apex.optimizers.FusedLAMB 中的 FuseLAMB (NvLamb 变体) 优化器的纯 pytorch 变体。FusedLAMB 参考: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py

LAMB 在以下论文中被提出

step

< >

( closure = None )

参数

  • closure (callable, 可选) — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.LaProp

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: float = 0.0004 betas: typing.Tuple[float, float] = (0.9, 0.999) eps: float = 1e-15 weight_decay: float = 0.0 caution: bool = False )

LaProp 优化器

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

step

< >

( closure = None )

参数

  • closure (callable, 可选) — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.Lars

< >

( params lr = 1.0 momentum = 0 dampening = 0 weight_decay = 0 nesterov = False trust_coeff = 0.001 eps = 1e-08 trust_clip = False always_adapt = False )

参数

  • params (iterable) — 要优化的参数的可迭代对象或定义参数组的字典。
  • lr (float, optional) — 学习率 (默认: 1.0)。
  • momentum (float, optional) — 动量因子 (默认: 0)
  • weight_decay (float, optional) — 权重衰减(L2 惩罚)(默认值:0)
  • dampening (float, optional) — 动量的阻尼系数(默认值:0)
  • nesterov (bool, optional) — 启用 Nesterov 动量(默认值:False)
  • trust_coeff (float) — 用于计算自适应 lr / trust_ratio 的信任系数(默认值:0.001)
  • eps (float) — 用于除法分母的 eps 值(默认值:1e-8)
  • trust_clip (bool) — 启用 LARC 信任率裁剪(默认值:False)
  • always_adapt (bool) — 始终应用 LARS LR 自适应,否则仅当组 weight_decay != 0 时应用(默认值:False)

PyTorch 的 LARS

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

step

< >

( closure = None )

参数

  • closure (callable, optional) — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.Lion

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: float = 0.0001 betas: typing.Tuple[float, float] = (0.9, 0.99) weight_decay: float = 0.0 caution: bool = False maximize: bool = False foreach: typing.Optional[bool] = None )

实现了 Lion 算法。

step

< >

( closure = None )

参数

  • closure — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.Lookahead

< >

( base_optimizer alpha = 0.5 k = 6 )

class timm.optim.MADGRAD

< >

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

参数

  • params (iterable) — 要优化的参数的可迭代对象或定义参数组的字典。
  • lr (float) — 学习率(默认值:1e-2)。
  • momentum (float) — 动量值,范围为 [0,1)(默认值:0.9)。
  • weight_decay (float) — 权重衰减,即 L2 惩罚(默认值:0)。
  • eps (float) — 添加到根运算之外的分母中的项,以提高数值稳定性。(默认值:1e-6)。

MADGRAD_: 一种用于随机优化的动量化、自适应、双重平均梯度方法。

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

MADGRAD 是一种通用的优化器,可以用来代替 SGD 或 Adam,可能会收敛更快,泛化性更好。目前仅支持 GPU。通常,可以使用用于 SGD 或 Adam 的相同学习率计划。总体学习率与这两种方法都不可比,应通过超参数扫描确定。

MADGRAD 比其他方法需要的权重衰减更少,通常可以少到零。用于 SGD 或 Adam 的 beta1 的动量值也应在此处有效。

在稀疏问题上,weight_decay 和 momentum 都应设置为 0。

step

< >

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

参数

  • closure (callable, optional) — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.Mars

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: float = 0.003 betas: typing.Tuple[float, float] = (0.9, 0.99) eps: float = 1e-08 weight_decay: float = 0.0 gamma: float = 0.025 mars_type: str = 'adamw' optimize_1d: bool = False lr_1d_factor: float = 1.0 betas_1d: typing.Optional[typing.Tuple[float, float]] = None caution: bool = False )

MARS 优化器

论文:MARS: Unleashing the Power of Variance Reduction for Training Large Models https://arxiv.org/abs/2411.10438

step

< >

( closure = None )

参数

  • closure (callable, optional) — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.NAdamW

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: float = 0.001 betas: typing.Tuple[float, float] = (0.9, 0.999) eps: float = 1e-08 weight_decay: float = 0.01 caution: bool = False maximize: bool = False foreach: typing.Optional[bool] = None capturable: bool = False )

参数

  • params — 优化参数的可迭代对象或定义参数组的字典
  • lr — 学习率 (learning rate)
  • betas — 用于计算梯度及其平方的运行平均值的系数
  • eps — 添加到分母以提高数值稳定性的项
  • weight_decay — 权重衰减系数
  • caution — 启用 caution 模式

Implements NAdamW algorithm.

See Table 1 in https://arxiv.org/abs/1910.05446 for the implementation of the NAdam algorithm (there is also a comment in the code which highlights the only difference of NAdamW and AdamW).

For further details regarding the algorithm we refer to

step

< >

( closure = None )

参数

  • closure (callable, optional) — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.NvNovoGrad

< >

( params lr = 0.001 betas = (0.95, 0.98) eps = 1e-08 weight_decay = 0 grad_averaging = False amsgrad = False )

参数

  • params (iterable) — 优化参数的可迭代对象或定义参数组的字典
  • lr (float, optional) — 学习率 (learning rate) (默认值: 1e-3)
  • betas (Tuple[float, float], optional) — 用于计算梯度及其平方的运行平均值的系数 (默认值: (0.95, 0.98))
  • eps (float, optional) — 添加到分母以提高数值稳定性的项 (默认值: 1e-8)
  • weight_decay (float, optional) — 权重衰减 (L2 惩罚) (默认值: 0)
  • grad_averaging — 梯度平均
  • amsgrad (boolean, optional) — 是否使用论文 On the Convergence of Adam and Beyond_ 中的 AMSGrad 变体 (默认值: False)

Implements Novograd algorithm.

step

< >

( closure = None )

参数

  • closure (callable, optional) — 一个重新评估模型的闭包
  • and 返回损失值。 —

执行单个优化步骤。

class timm.optim.RMSpropTF

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: float = 0.01 alpha: float = 0.9 eps: float = 1e-10 weight_decay: float = 0 momentum: float = 0.0 centered: bool = False decoupled_decay: bool = False lr_in_momentum: bool = True caution: bool = False )

参数

  • params — 优化参数的可迭代对象或定义参数组的字典
  • lr — 学习率 (learning rate)
  • momentum — 动量因子 (momentum factor)
  • alpha — 平滑 (衰减) 常数
  • eps — 添加到分母以提高数值稳定性的项
  • centered — 如果为 True,则计算中心化的 RMSProp,梯度通过其方差的估计值进行归一化
  • weight_decay — 权重衰减 (L2 惩罚) (默认值: 0)
  • decoupled_decay — 解耦权重衰减,如 https://arxiv.org/abs/1711.05101 所述
  • lr_in_momentum — 学习率缩放包含在动量缓冲更新中,与 Tensorflow 中的默认设置一致
  • caution — 应用 caution

实现了 RMSprop 算法 (TensorFlow 风格的 epsilon)

注意:这是 PyTorch RMSprop 的直接复制粘贴,其中 eps 在 sqrt 之前应用,并进行了一些其他修改,以更接近 Tensorflow,从而匹配超参数。

值得注意的更改包括

  1. Epsilon 应用于平方根内部
  2. square_avg 初始化为 1
  3. 动量缓冲中累积的更新的 LR 缩放

由 G. Hinton 在他的课程中提出。

中心化版本首次出现在Generating Sequences With Recurrent Neural Networks中。

step

< >

( closure = None )

参数

  • closure (callable, optional) — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

class timm.optim.SGDP

< >

( params lr = <required parameter> momentum = 0 dampening = 0 weight_decay = 0 nesterov = False eps = 1e-08 delta = 0.1 wd_ratio = 0.1 )

class timm.optim.SGDW

< >

( params: typing.Union[typing.Iterable[torch.Tensor], typing.Iterable[typing.Dict[str, typing.Any]], typing.Iterable[typing.Tuple[str, torch.Tensor]]] lr: float = 0.001 momentum: float = 0.0 dampening: float = 0.0 weight_decay: float = 0.0 nesterov: bool = False caution: bool = False maximize: bool = False foreach: typing.Optional[bool] = None differentiable: bool = False )

step

< >

( closure = None )

参数

  • closure (Callable, optional) — 一个重新评估模型并返回损失的闭包。

执行单个优化步骤。

< > 更新 在 GitHub 上