timm 文档
优化
并获得增强的文档体验
开始使用
优化
本页包含 timm 中学习率优化器的 API 参考文档。
优化器
工厂函数
timm.optim.create_optimizer_v2
< 源代码 >( model_or_params: typing.Union[torch.nn.modules.module.Module, collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 layer_decay_min_scale: float = 0.0 layer_decay_no_opt_scale: typing.Optional[float] = None param_group_fn: typing.Optional[typing.Callable[[torch.nn.modules.module.Module], typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 — 支持动量的优化器的动量因子。仅当所选优化器接受 momentum 参数时使用。
- foreach — 启用/禁用 foreach (多张量) 实现（如果可用）。如果为 None，将使用优化器特定的默认值。
- filter_bias_and_bn — 如果为 True，则偏置、归一化层参数（所有一维参数）将不应用权重衰减。仅当 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 … )
注意：参数组处理优先级
- 如果提供了 param_group_fn，将只使用它
- 如果提供了 layer_decay，将创建逐层分组
- 如果 weight_decay > 0 且 filter_bias_and_bn 为 True，将创建权重衰减分组
- 否则，所有参数将分在同一组
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，则返回 (名称, 描述) 的元组，而不仅仅是名称。描述提供了优化器特性的简要说明。
返回
如果 with_description 为 False
字符串形式的优化器名称列表（例如，[‘adam’, ‘adamw’, …]） 如果 with_description 为 True：(名称, 描述) 的元组列表（例如，[(‘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
通过名称获取优化器类，并可选择绑定默认参数。
检索优化器类或一个绑定了默认参数的偏函数。这允许直接使用其默认配置实例化优化器，而无需通过完整的工厂函数。
示例
获取带 nesterov 动量默认值的 SGD
SGD = get_optimizer_class(‘sgd’) # 绑定 nesterov=True 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，请参见这些 gists
- 训练脚本链接：https://gist.github.com/juntang-zhuang/0a501dd51c02278d952cf159bc233037
- args.yaml 链接：https://gist.github.com/juntang-zhuang/517ce3c27022b908bb93f78e4f786dc3
执行单次优化步骤。
class timm.optim.Adafactor
< 源代码 >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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_parameter、relative_step 和 warmup_init 选项内部调整学习率。
要使用手动（外部）学习率调度，您应设置 scale_parameter=False 和 relative_step=False。
参数： params: 用于优化的参数可迭代对象或定义参数组的字典 lr: 外部学习率 eps: 分别用于平方梯度和参数尺度的正则化常数 eps_scale: 分别用于参数尺度的正则化常数 clip_threshold: 最终梯度更新的均方根阈值 decay_rate: 用于计算平方梯度运行平均值的系数 beta1: 用于计算梯度运行平均值的系数 weight_decay: 权重衰减 scale_parameter: 如果为 True，学习率将按参数的均方根进行缩放 warmup_init: 依赖时间的学习率计算取决于是否使用预热初始化
执行单次优化步骤。
class timm.optim.AdafactorBigVision
< 源代码 >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 corrected_weight_decay: 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, 可选) — 仅在执行*此*步数后计算海森矩阵迹的近似值（以节省时间）（默认值：1）
- n_samples (int, 可选) — 为近似海森矩阵迹而对
z进行采样的次数（默认值：1）
实现了论文《ADAHESSIAN: An Adaptive Second OrderOptimizer for Machine Learning》中的 AdaHessian 算法。
获取所有参数组中带有梯度的所有参数。
计算海森矩阵迹的 Hutchinson 近似值，并为每个可训练参数累加该值。
执行单次优化步骤。
将累加的海森矩阵迹清零。
class timm.optim.AdamP
< source >( 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
< source >( 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 )
实现了 Adan 的一个 PyTorch 变体。
Adan 算法在论文《Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models》中被提出，网址：https://arxiv.org/abs/2208.06677
执行单次优化步骤。
class timm.optim.Adopt
< source >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 corrected_weight_decay: bool = False caution: bool = False foreach: typing.Optional[bool] = False maximize: bool = False capturable: bool = False differentiable: bool = False )
ADOPT: Modified Adam Can Converge with Any β2 with the Optimal Rate: https://arxiv.org/abs/2411.02853
执行单步优化。
class timm.optim.Lamb
< source >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 corrected_weight_decay: bool = False )
参数
- params — 要优化的可迭代参数或定义参数组的字典。
- lr — 学习率
- betas — 用于计算梯度及其范数的移动平均值的系数。
- eps — 添加到分母中以提高数值稳定性的项。
- weight_decay — 权重衰减
- grad_averaging — 在计算梯度的移动平均值时是否对梯度应用 (1-beta2)。
- max_grad_norm — 用于裁剪全局梯度范数的值。
- trust_clip — 启用 LAMBC 置信度裁剪。
- always_adapt — 将自适应学习率应用于权重衰减为 0.0 的参数。
- caution — 应用谨慎模式。
- decoupled — 应用解耦权重衰减
- corrected_weight_decay — 当使用 decoupled_decay 时，应用校正后的权重衰减 (lr**2 / max_lr)
实现了一个纯 PyTorch 版本的 FuseLAMB（NvLamb 变体）优化器，源自 apex.optimizers.FusedLAMB。参考：https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py
LAMB 算法在以下论文中被提出：
- Large Batch Optimization for Deep Learning - Training BERT in 76 minutes: https://arxiv.org/abs/1904.00962
- On the Convergence of Adam and Beyond: https://openreview.net/forum?id=ryQu7f-RZ
执行单次优化步骤。
class timm.optim.LaProp
< source >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 corrected_weight_decay: bool = False )
LaProp 优化器
论文：LaProp: Separating Momentum and Adaptivity in Adam, https://arxiv.org/abs/2002.04839
执行单次优化步骤。
class timm.optim.Lars
< source >( 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, 可选) — 学习率（默认值：1.0）。
- momentum (float, 可选) — 动量因子（默认值：0）
- weight_decay (float, 可选) — 权重衰减（L2 惩罚）（默认值：0）
- dampening (float, 可选) — 动量阻尼（默认值：0）
- nesterov (bool, 可选) — 启用 Nesterov 动量（默认值：False）
- trust_coeff (float) — 用于计算自适应学习率/置信度比率的置信系数（默认值：0.001）
- eps (float) — 用于除法分母的 epsilon 值（默认值：1e-8）
- trust_clip (bool) — 启用 LARC 置信度比率裁剪（默认值：False）
- always_adapt (bool) — 总是应用 LARS 学习率自适应，否则仅当组的 weight_decay != 0 时应用（默认值：False）
用于 PyTorch 的 LARS 优化器
论文：Large batch training of Convolutional Networks - https://arxiv.org/pdf/1708.03888.pdf
执行单次优化步骤。
class timm.optim.Lion
< source >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 corrected_weight_decay: bool = False maximize: bool = False foreach: typing.Optional[bool] = None )
实现了 Lion 算法。
执行单次优化步骤。
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 )
MADGRAD_：一种用于随机优化的动量化、自适应、双重平均梯度方法。
.. _MADGRAD: https://arxiv.org/abs/2101.11075
MADGRAD 是一种通用优化器，可替代 SGD 或 Adam，可能会更快地收敛并具有更好的泛化能力。目前仅支持 GPU。通常，可使用与 SGD 或 Adam 相同的学习率调度。总体学习率与这两种方法都不可比，应通过超参数搜索确定。
MADGRAD 所需的权重衰减比其他方法少，通常甚至可以为零。用于 SGD 或 Adam 的 beta1 的动量值也适用于此。
对于稀疏问题，weight_decay 和 momentum 都应设置为 0。
步骤
< 源代码 >( closure: typing.Optional[typing.Callable[[], float]] = None )
执行单次优化步骤。
class timm.optim.Mars
< 源代码 >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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
执行单次优化步骤。
class timm.optim.NAdamW
< 源代码 >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 corrected_weight_decay: bool = False maximize: bool = False foreach: typing.Optional[bool] = None capturable: bool = False )
实现 NAdamW 算法。
有关 NAdam 算法的实现，请参阅 https://arxiv.org/abs/1910.05446 中的表 1（代码中也有注释，强调了 NAdamW 和 AdamW 之间的唯一区别）。
有关该算法的更多详情，请参阅
- 解耦权重衰减正则化：https://arxiv.org/abs/1711.05101
- On the Convergence of Adam and Beyond: https://openreview.net/forum?id=ryQu7f-RZ
执行单次优化步骤。
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, 可选) — 学习率（默认值：1e-3）
- betas (Tuple[float, float], 可选) — 用于计算梯度及其平方的运行平均值的系数（默认值：(0.95, 0.98)）
- eps (float, 可选) — 为提高数值稳定性而添加到分母的项（默认值：1e-8）
- weight_decay (float, 可选) — 权重衰减（L2 惩罚项）（默认值：0）
- grad_averaging — 梯度平均
- amsgrad (boolean, 可选) — 是否使用论文 `On the Convergence of Adam and Beyond`_ 中的 AMSGrad 变体算法（默认值：False）
实现 Novograd 算法。
执行单次优化步骤。
class timm.optim.RMSpropTF
< 源代码 >( params: typing.Union[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 corrected_weight_decay: bool = False lr_in_momentum: bool = True caution: bool = False )
参数
- params — 可迭代的待优化参数或定义参数组的字典
- lr — 学习率
- momentum — 动量因子
- alpha — 平滑（衰减）常数
- eps — 为提高数值稳定性而添加到分母的项
- centered — 如果为 `True`，则计算中心化的 RMSProp，梯度将通过其方差的估计值进行归一化
- weight_decay — 权重衰减（L2 惩罚项）（默认值：0）
- decoupled_decay — 解耦权重衰减，根据 https://arxiv.org/abs/1711.05101
- corrected_weight_decay — 当 decoupled_decay 为 True 时，应用修正的权重衰减 (lr**2 / max_lr)
- lr_in_momentum — 根据 Tensorflow 中的默认设置，学习率缩放包含在动量缓冲更新中
- caution — 应用 caution
实现 RMSprop 算法（TensorFlow 风格的 epsilon）
注意：这是 PyTorch RMSprop 的直接复制粘贴，在 sqrt 之前应用了 eps，并进行了一些其他修改，以更接近 Tensorflow，从而匹配超参数。
值得注意的变化包括
- 在平方根内应用 Epsilon
- square_avg 初始化为 1
- 在动量缓冲中累积更新的学习率缩放
由 G. Hinton 在他的课程中提出。
中心化版本首次出现在 Generating Sequences With Recurrent Neural Networks 中。
执行单次优化步骤。
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[collections.abc.Iterable[torch.Tensor], collections.abc.Iterable[dict[str, typing.Any]], collections.abc.Iterable[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 corrected_weight_decay: bool = False maximize: bool = False foreach: typing.Optional[bool] = None differentiable: bool = False )
执行单次优化步骤。