torch.optim¶

是一个实现各种优化算法的包。

已经支持最常用的方法，并且界面是通用的足够了，因此更复杂的也可以轻松集成到前途。

如何使用优化器¶

要使用，您必须构造一个 optimizer 对象，该对象将包含当前状态，并将根据计算的梯度更新参数。

构建¶

要构造一个，你必须给它一个包含参数（全部应为 S）进行优化。然后您可以指定特定于优化器的选项，例如 Learning Rate（学习率）、权重衰减等。Variable

例：

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

每个参数选项¶

还支持指定每个参数的选项。要执行此操作，请改为传递 s 的 iterable，传入 s 的 iterable。它们中的每一个都将定义一个单独的参数组，并且应该包含一个键，其中包含属于它的参数列表。其他键应与优化器接受的关键字参数匹配，并将使用作为此组的优化选项。Variableparams

注意

你仍然可以将选项作为关键字参数传递。它们将用作 defaults，位于未覆盖它们的组中。这在以下情况下非常有用只想改变一个选项，同时保持所有其他选项一致参数组之间。

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

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

这意味着的参数将使用默认的学习率，的参数将使用学习率，并且所有参数都将使用动量。model.base1e-2model.classifier1e-30.9

采取优化步骤¶

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

`optimizer.step()`¶

这是大多数优化器支持的简化版本。该函数可以是在使用例如 .backward()

例：

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）需要多次重新评估函数，因此您必须传入一个闭包，该闭包将允许他们重新计算您的模型。闭包应清除梯度，计算损失，然后返回。

例：

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)

基类¶

类 torch.optim 中。优化器（params， defaults）[来源]¶

所有优化器的基类。

警告

需要将参数指定为具有确定性排序，在运行之间保持一致。不这样做的对象示例满足这些属性的是 dictionaries 值的 set 和 iterators。

参数

params （iterable） - s 或 s 的可迭代对象。指定应优化的 Tensor。
defaults （Dict[str， Any]） – （dict）：包含优化默认值的 dict options （在参数组未指定时使用）。

`Optimizer.add_param_group`	将 param 组添加到 s param_groups。
`Optimizer.load_state_dict`	加载优化器状态。
`Optimizer.state_dict`	将优化器的状态作为返回。
`优化器.step`	执行单个优化步骤（参数更新）。
`Optimizer.zero_grad`	重置所有优化 s 的渐变。

算法¶

`阿达德尔塔`	实现 Adadelta 算法。
`阿达格勒`	实现 Adagrad 算法。
`亚当`	实现 Adam 算法。
`亚当W`	实现 AdamW 算法。
`稀疏亚当`	SparseAdam 实现了适用于稀疏梯度的 Adam 算法的掩码版本。
`阿达麦克斯`	实现 Adamax 算法（基于无穷范数的 Adam 变体）。
`ASGD`	实现平均随机梯度下降。
`LBFGS 公司`	实现 L-BFGS 算法。
`纳丹`	实现 NAdam 算法。
`RAdam`	实现 RAdam 算法。
`RMS属性`	实现 RMSprop 算法。
`Rprop`	实现弹性反向传播算法。
`新币`	实现随机梯度下降（可选使用动量）。

我们的许多算法都有针对性能进行优化的各种实现，可读性和/或通用性，因此我们尝试默认为通常最快的 implementation （如果尚未实现特定由用户指定。

我们有 3 大类实现：for-loop、foreach（多张量）和融合。最直接的实现是对参数进行 for 循环，其中大块计算。For 循环通常比我们的 foreach 慢实现，将参数组合成一个多张量并运行大块的 County，从而节省了许多顺序的内核调用。我们的一些优化器具有更快的融合实现，它融合了计算到一个内核中。我们可以将 foreach 实现视为 fusing 水平融合实现，并在其上垂直融合。

通常，这 3 种实现的性能顺序> foreach > for 循环融合在一起。因此，在适用时，我们默认在 for 循环中使用 foreach。Applicable 是指 foreach implementation is available，则用户尚未指定任何特定于 implementation 的 kwargs （例如，fused、foreach、differentiable），并且所有张量都是原生的并且基于 CUDA。请注意，虽然 Fused 应该比 foreach 更快，但实现是更新的，我们会喜欢在到处拨动开关之前给他们更多的烘烤时间。不客气不过要试试它们！

下表显示了每种算法的可用和默认实现：

算法	违约	有 foreach？	已融合？
`阿达德尔塔`	foreach	是的	不
`阿达格勒`	foreach	是的	不
`亚当`	foreach	是的	是的
`亚当W`	foreach	是的	是的
`稀疏亚当`	for 循环	不	不
`阿达麦克斯`	foreach	是的	不
`ASGD`	foreach	是的	不
`LBFGS 公司`	for 循环	不	不
`纳丹`	foreach	是的	不
`RAdam`	foreach	是的	不
`RMS属性`	foreach	是的	不
`Rprop`	foreach	是的	不
`新币`	foreach	是的	不

如何调整学习率¶

提供了几种调整学习的方法 rate 基于 epoch 的数量。允许根据某些验证测量结果动态降低学习率。

学习率调度应在 optimizer 更新后应用;例如，您应该这样编写你的代码：

例：

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
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()

大多数学习率调度器都可以背靠背调用（也称为链接调度器）。结果是，每个调度程序都在 other 的 Adobe，则根据前一个 Bean 获得的学习率。

例：

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
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 算法。

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

警告

在 PyTorch 1.1.0 之前，学习率调度器应该在之前被调用优化器的更新;1.1.0 以突破性的方式改变了这种行为。如果您使用优化器更新之前的学习率调度器（调用）（调用），这将跳过学习率计划的第一个值。如果升级到 PyTorch 1.1.0 后无法重现结果，请检查如果您在错误的时间打电话。scheduler.step()optimizer.step()scheduler.step()

`lr_scheduler。LambdaLR`	将每个参数组的学习率设置为给定函数的初始 lr 乘以。
`lr_scheduler。乘法 LR`	将每个参数组的学习率乘以指定函数中给定的因子。
`lr_scheduler。StepLR`	每 step_size 个 epoch 每 gamma 衰减每个参数组的学习率。
`lr_scheduler。多步 LR`	一旦纪元数达到其中一个里程碑，则按 gamma 衰减每个参数组的学习率。
`lr_scheduler。常数LR`	将每个参数组的学习率衰减一个小的常数因子，直到纪元数达到预定义的里程碑：total_iters。
`lr_scheduler。线性LR`	通过线性改变小的乘法因子来衰减每个参数组的学习率，直到纪元数达到预定义的里程碑：total_iters。
`lr_scheduler。指数LR`	每个 epoch 按 gamma 衰减每个参数组的学习率。
`lr_scheduler。多项式 LR`	在给定total_iters中使用多项式函数衰减每个参数组的学习率。
`lr_scheduler。余弦退火LR`	使用余弦退火计划设置每个参数组的学习率，其中 $\eta_{max}$ 设置为初始 LR，并且 $T_{cur}$ 是自 SGDR 中上次重新启动以来的纪元数：
`lr_scheduler。链式调度器`	学习率调度器的链列表。
`lr_scheduler。顺序LR`	接收预期在优化过程中按顺序调用的计划程序列表，以及提供确切间隔以反映应在给定纪元调用的计划程序的里程碑点。
`lr_scheduler。ReduceLROnPlateau`	当指标停止改进时降低学习率。
`lr_scheduler。CyclicLR`	根据循环学习率策略（CLR）设置每个参数组的学习率。
`lr_scheduler。一周期LR`	根据 1cycle 学习率策略设置每个参数组的学习率。
`lr_scheduler。CosineAnnealingWarmRestarts`	使用余弦退火计划设置每个参数组的学习率，其中 $\eta_{max}$ 设置为初始 lr， $T_{cur}$ 是自上次重启以来的 epoch 数， $T_{i}$ 是 SGDR 中两次热重启之间的纪元数：

权重平均（SWA 和 EMA）¶

实施随机权重平均（SWA）和指数移动平均线（EMA）。特别该类实现了 SWA 和 EMA 模型，实现了 SWA 学习率调度器，并且是用于更新 SWA/EMA 批处理的实用函数训练结束时的标准化统计。torch.optim.swa_utils.AveragedModeltorch.optim.swa_utils.SWALRtorch.optim.swa_utils.update_bn()

SWA 已在平均权重导致更广泛的最优值和更好的泛化中提出。

EMA 是一种广为人知的技术，它通过减少所需的权重更新次数来减少训练时间。它是 Polyak 平均法的变体，但在迭代中使用指数权重而不是相等的权重。

构建平均模型¶

AveragedModel 类用于计算 SWA 或 EMA 模型的权重。

您可以通过运行以下命令来创建 SWA 平均模型：

>>> averaged_model = AveragedModel(model)

EMA 模型是通过指定参数来构建的，如下所示：multi_avg_fn

>>> decay = 0.999
>>> averaged_model = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(decay))

Decay 是一个介于 0 和 1 之间的参数，用于控制平均参数的衰减速度。如果未提供给，则默认值为 0.999。get_ema_multi_avg_fn

get_ema_multi_avg_fn返回一个函数，该函数将以下 EMA 方程应用于权重：

W^\textrm{EMA}_{t+1} = \alpha W^\textrm{EMA}_{t} + (1 - \alpha) W^\textrm{model}_t

其中 alpha 是 EMA 衰减。

此处的模型可以是任意对象。将跟踪参数的运行平均值。更新这些 averages，你应该在 optimizer.step（）之后使用这个函数：modelaveraged_modelmodelupdate_parameters()

>>> averaged_model.update_parameters(model)

对于 SWA 和 EMA，此调用通常在 optimizer 之后立即完成。对于 SWA，通常会在训练开始时跳过某些步骤。step()

自定义平均策略¶

默认情况下，计算提供的参数，但您也可以将自定义平均函数与 OR 参数一起使用：torch.optim.swa_utils.AveragedModelavg_fnmulti_avg_fn

avg_fn允许定义一个对每个参数元组（平均参数、模型参数）进行操作的函数，并应返回新的平均参数。
multi_avg_fn允许同时定义对参数列表元组（平均参数列表、模型参数列表）的更有效操作，例如使用函数。此函数必须就地更新平均参数。torch._foreach*

在以下示例中，使用参数计算指数移动平均线：ema_modelavg_fn

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

在以下示例中，使用 more efficient 参数计算指数移动平均线：ema_modelmulti_avg_fn

>>> ema_model = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(0.9))

SWA 学习率计划¶

通常，在 SWA 中，学习率设置为较高的常量值。是一个学习率调度器，将学习率退火到一个固定值，然后保持它不断。例如，下面的代码创建一个调度程序，该调度程序对每个参数组内 5 个 epoch 的学习率从其初始值到 0.05：SWALR

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

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

处理批量归一化¶

update_bn()是一个实用程序函数，允许计算 SWA 模型的 batchnorm 统计信息在训练结束时，在给定的 DataLoader 上：loader

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

update_bn()将 the 应用于 DataLoader 中的每个元素并计算激活模型中每个批量归一化层的统计信息。swa_model

警告

update_bn()假设 DataLoader 中的每个批次都是一个张量或一个张量，其中第一个元素是应应用网络的张量。如果您的数据加载器具有不同的结构，您可以通过对数据集的每个元素执行前向传递来更新的批量规范化统计信息。loaderswa_modelswa_modelswa_model

综上所述：SWA¶

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

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

综上所述：EMA¶

在下面的示例中，是 EMA 模型，该模型以 0.999 的衰减率累积权重的指数衰减平均值。我们训练模型总共 300 个 epoch，并立即开始收集 EMA 平均值。ema_model

>>> loader, optimizer, model, loss_fn = ...
>>> ema_model = torch.optim.swa_utils.AveragedModel(model, \
>>>             multi_avg_fn=torch.optim.swa_utils.get_ema_multi_avg_fn(0.999))
>>>
>>> for epoch in range(300):
>>>       for input, target in loader:
>>>           optimizer.zero_grad()
>>>           loss_fn(model(input), target).backward()
>>>           optimizer.step()
>>>           ema_model.update_parameters(model)
>>>
>>> # Update bn statistics for the ema_model at the end
>>> torch.optim.swa_utils.update_bn(loader, ema_model)
>>> # Use ema_model to make predictions on test data
>>> preds = ema_model(test_input)

torch.optim¶

如何使用优化器¶

构建¶

每个参数选项¶

采取优化步骤¶

`optimizer.step()`¶

`optimizer.step(closure)`¶

基类¶

算法¶

如何调整学习率¶

权重平均（SWA 和 EMA）¶

构建平均模型¶

自定义平均策略¶

SWA 学习率计划¶

处理批量归一化¶

综上所述：SWA¶

综上所述：EMA¶

文档

教程

资源

torch.optim¶

如何使用优化器¶

构建¶

每个参数选项¶

采取优化步骤¶

optimizer.step()¶

optimizer.step(closure)¶

基类¶

算法¶

如何调整学习率¶

权重平均（SWA 和 EMA）¶

构建平均模型¶

自定义平均策略¶

SWA 学习率计划¶

处理批量归一化¶

综上所述：SWA¶

综上所述：EMA¶

文档

教程

资源

`optimizer.step()`¶

`optimizer.step(closure)`¶