torch.optim¶

torch.optim 是一个实现各种优化算法的包。大多数常用方法已经得到支持，接口足够通用，因此未来也可以轻松集成更复杂的算法。

如何使用优化器¶

要使用 torch.optim，你必须构造一个优化器对象，该对象将保存当前状态，并根据计算出的梯度更新参数。

构建它¶

要构建一个 Optimizer，你必须提供一个包含参数的可迭代对象（所有参数都应为Variable）来进行优化。然后，你可以指定特定于优化器的选项，例如学习率、权重衰减等。

Example:

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr=0.0001)

每个参数的选项¶

Optimizer 还支持指定每个参数的选项。为此，不要传入一个 Variable 的可迭代对象，而是传入一个 dict 的可迭代对象。每一个都会定义一个单独的参数组，并且应该包含一个 params 键，其中包含属于该组的参数列表。其他键应与优化器接受的关键字参数匹配，并将用作此组的优化选项。

注意

你仍然可以将选项作为关键字参数传递。它们将被用作默认值，在没有覆盖它们的组中。当你只想在参数组之间保持所有其他选项一致，同时仅更改单个选项时，这非常有用。

例如，当用户想要指定每层的学习率时，这非常有用：

optim.SGD([
                {'params': model.base.parameters()},
                {'params': model.classifier.parameters(), 'lr': 1e-3}
            ], lr=1e-2, momentum=0.9)

这意味着 model.base 的参数将使用默认学习率 1e-2， model.classifier 的参数将使用学习率为 1e-3，并且所有参数都将使用动量值 0.9。

执行优化步骤¶

所有优化器都实现了一个 step() 方法，该方法用于更新参数。它可以用两种方式使用：

`optimizer.step()`¶

这是一个被大多数优化器支持的简化版本。在使用例如 backward() 计算梯度后，可以调用该函数。

Example:

for input, target in dataset:
    optimizer.zero_grad()
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()

`optimizer.step(closure)`¶

某些优化算法，如共轭梯度法（Conjugate Gradient）和 LBFGS，需要多次重新计算函数，因此你必须传入一个闭包（closure），以便它们能够重新计算你的模型。该闭包应该清除梯度，计算损失，并返回该损失。

Example:

for input, target in dataset:
    def closure():
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output, target)
        loss.backward()
        return loss
    optimizer.step(closure)

基类¶

class torch.optim.Optimizer(params, defaults)[source]¶

所有优化器的基类。

警告

需要将参数指定为具有确定性顺序的集合，且该顺序在不同运行之间保持一致。不满足这些特性的对象示例包括集合和字典值的迭代器。

Parameters

params (iterable) – 一个 torch.Tensor 或 dict 的可迭代对象。指定哪些张量需要被优化。
defaults – (dict): 一个包含优化选项默认值的字典（当参数组未指定时使用这些值）。

`Optimizer.add_param_group`	向 `Optimizer` s 的 param_groups 添加一个参数组。
`Optimizer.load_state_dict`	加载优化器状态。
`Optimizer.state_dict`	返回优化器的状态作为一个 `dict`。
`Optimizer.step`	执行单个优化步骤（参数更新）。
`Optimizer.zero_grad`	将所有优化的 `torch.Tensor` 的梯度设为零。

算法¶

`Adadelta`	实现 Adadelta 算法。
`Adagrad`	实现 Adagrad 算法。
`Adam`	实现 Adam 算法。
`AdamW`	实现 AdamW 算法。
`SparseAdam`	实现适用于稀疏张量的 Adam 算法的延迟版本。
`Adamax`	实现 Adamax 算法（基于无穷范数的 Adam 变体）。
`ASGD`	实现平均随机梯度下降。
`LBFGS`	实现L-BFGS算法，深受minFunc启发。
`NAdam`	实现 NAdam 算法。
`RAdam`	实现 RAdam 算法。
`RMSprop`	实现 RMSprop 算法。
`Rprop`	实现弹性反向传播算法。
`SGD`	实现随机梯度下降（可选动量）。

如何调整学习率¶

torch.optim.lr_scheduler 提供了几种根据训练轮数调整学习率的方法。 torch.optim.lr_scheduler.ReduceLROnPlateau 允许根据某些验证指标动态降低学习率。

学习率调度应在优化器更新之后应用；例如，你应该这样编写代码：

Example:

model = [Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = SGD(model, 0.1)
scheduler = ExponentialLR(optimizer, gamma=0.9)

for epoch in range(20):
    for input, target in dataset:
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output, target)
        loss.backward()
        optimizer.step()
    scheduler.step()

大多数学习率调度器可以连续调用（也称为调度器链）。其结果是，每个调度器会依次应用于前一个调度器所得到的学习率。

Example:

model = [Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = SGD(model, 0.1)
scheduler1 = ExponentialLR(optimizer, gamma=0.9)
scheduler2 = MultiStepLR(optimizer, milestones=[30,80], gamma=0.1)

for epoch in range(20):
    for input, target in dataset:
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output, target)
        loss.backward()
        optimizer.step()
    scheduler1.step()
    scheduler2.step()

在文档的许多地方，我们将使用以下模板来引用调度器算法。

>>> scheduler = ...
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

警告

在 PyTorch 1.1.0 之前，学习率调度器应在优化器更新之前调用；1.1.0 版本以一种破坏向后兼容性的方式改变了这一行为。如果你在优化器更新（调用 optimizer.step()）之前调用学习率调度器（调用 scheduler.step()），这将跳过学习率计划的第一个值。如果你在升级到 PyTorch 1.1.0 后无法重现结果，请检查你是否在错误的时间调用了 scheduler.step()。

`lr_scheduler.LambdaLR`	将每个参数组的学习率设置为初始 lr 乘以给定的函数。
`lr_scheduler.MultiplicativeLR`	将每个参数组的学习率乘以指定函数中给出的因子。
`lr_scheduler.StepLR`	每个参数组的学习率每隔 step_size 个 epoch 按 gamma 的比例衰减。
`lr_scheduler.MultiStepLR`	当训练轮数达到指定的里程碑之一时，将每个参数组的学习率按 gamma 进行衰减。
`lr_scheduler.ConstantLR`	将每个参数组的学习率按一个小的常数因子衰减，直到训练轮数达到预定义的里程碑：total_iters。
`lr_scheduler.LinearLR`	将每个参数组的学习率通过线性变化的小乘数因子进行衰减，直到训练的轮数达到预定义的里程碑：total_iters。
`lr_scheduler.ExponentialLR`	每个参数组的学习率在每个训练周期（epoch）后按 gamma 的比例衰减。
`lr_scheduler.CosineAnnealingLR`	使用余弦退火计划设置每个参数组的学习率，其中 $\eta_{max}$ 被设置为初始学习率， $T_{cur}$ 是 SGDR 中自上次重启以来的 epoch 数：
`lr_scheduler.ChainedScheduler`	学习率调度器链表。
`lr_scheduler.SequentialLR`	接收在优化过程中预期按顺序调用的调度器列表，以及提供精确间隔的里程碑点，以反映在给定时期应调用哪个调度器。
`lr_scheduler.ReduceLROnPlateau`	当某个指标停止提升时，降低学习率。
`lr_scheduler.CyclicLR`	根据循环学习率策略（CLR）设置每个参数组的学习率。
`lr_scheduler.OneCycleLR`	根据 1cycle 学习率策略设置每个参数组的学习率。
`lr_scheduler.CosineAnnealingWarmRestarts`	使用余弦退火计划设置每个参数组的学习率，其中 $\eta_{max}$ 设置为初始 lr， $T_{cur}$ 是自上次重启以来的 epoch 数量， $T_{i}$ 是 SGDR 中两次 warm 重启之间的 epoch 数量:

随机权重平均¶

torch.optim.swa_utils 实现了随机权重平均（SWA）。特别是, torch.optim.swa_utils.AveragedModel 类实现了 SWA 模型, torch.optim.swa_utils.SWALR 实现了 SWA 学习率调度器, torch.optim.swa_utils.update_bn() 是一个实用函数，用于在训练结束时更新 SWA 批量归一化统计信息。

SWA已在《通过平均权重获得更宽的最优解和更好的泛化能力》中提出。

构建平均模型¶

AveragedModel 类用于计算 SWA 模型的权重。你可以通过运行以下代码来创建一个平均模型：

>>> swa_model = AveragedModel(model)

此处的模型 model 可以是任意一个 torch.nn.Module 对象。 swa_model 将跟踪 model 参数的运行平均值。要更新这些平均值，可以使用 update_parameters() 函数：

>>> swa_model.update_parameters(model)

SWA学习率计划¶

通常，在SWA中，学习率被设置为一个较高的固定值。SWALR 是一种学习率调度器，它将学习率退火到一个固定值，然后保持不变。例如，以下代码创建了一个调度器，该调度器在每个参数组的5个训练周期内将学习率从初始值线性退火到0.05：

>>> swa_scheduler = torch.optim.swa_utils.SWALR(optimizer, \
>>>         anneal_strategy="linear", anneal_epochs=5, swa_lr=0.05)

您也可以通过设置 anneal_strategy="cos"，使用余弦退火到固定值，而不是线性退火。

处理批量归一化¶

update_bn() 是一个实用函数，允许在训练结束时计算 SWA 模型在给定数据加载器 loader 上的批量归一化统计信息：

>>> torch.optim.swa_utils.update_bn(loader, swa_model)

update_bn() 将 swa_model 应用于数据加载器中的每个元素，并计算模型中每个批量归一化层的激活统计信息。

警告

update_bn() 假设数据加载器中的每个批次 loader 要么是一个张量，要么是一个张量列表，其中第一个元素是网络 swa_model 应该应用到的张量。如果你的数据加载器有不同的结构，你可以通过在数据集的每个元素上进行前向传递来更新 swa_model 的批归一化统计信息，使用 swa_model。

自定义平均策略¶

默认情况下，torch.optim.swa_utils.AveragedModel 会计算你提供的参数的运行平均值，但你也可以使用 avg_fn 参数自定义平均函数。在下面的示例中，ema_model 计算的是指数移动平均值。

Example:

>>> ema_avg = lambda averaged_model_parameter, model_parameter, num_averaged:\
>>>         0.1 * averaged_model_parameter + 0.9 * model_parameter
>>> ema_model = torch.optim.swa_utils.AveragedModel(model, avg_fn=ema_avg)

整合所有内容¶

在下面的示例中，swa_model 是SWA模型，它累积权重的平均值。我们总共训练模型300个周期，并在第160个周期时切换到SWA学习率计划并开始收集参数的SWA平均值：

>>> loader, optimizer, model, loss_fn = ...
>>> swa_model = torch.optim.swa_utils.AveragedModel(model)
>>> scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=300)
>>> swa_start = 160
>>> swa_scheduler = SWALR(optimizer, swa_lr=0.05)
>>>
>>> for epoch in range(300):
>>>       for input, target in loader:
>>>           optimizer.zero_grad()
>>>           loss_fn(model(input), target).backward()
>>>           optimizer.step()
>>>       if epoch > swa_start:
>>>           swa_model.update_parameters(model)
>>>           swa_scheduler.step()
>>>       else:
>>>           scheduler.step()
>>>
>>> # Update bn statistics for the swa_model at the end
>>> torch.optim.swa_utils.update_bn(loader, swa_model)
>>> # Use swa_model to make predictions on test data
>>> preds = swa_model(test_input)

torch.optim¶

如何使用优化器¶

构建它¶

每个参数的选项¶

执行优化步骤¶

`optimizer.step()`¶

`optimizer.step(closure)`¶

基类¶

算法¶

如何调整学习率¶

随机权重平均¶

构建平均模型¶

SWA学习率计划¶

处理批量归一化¶

自定义平均策略¶

整合所有内容¶

文档

教程

资源

torch.optim¶

如何使用优化器¶

构建它¶

每个参数的选项¶

执行优化步骤¶

optimizer.step()¶

optimizer.step(closure)¶

基类¶

算法¶

如何调整学习率¶

随机权重平均¶

构建平均模型¶

SWA学习率计划¶

处理批量归一化¶

自定义平均策略¶

整合所有内容¶

文档

教程

资源

`optimizer.step()`¶

`optimizer.step(closure)`¶