torch.optim¶

是一个实现各种优化算法的包。已经支持最常用的方法，并且界面是通用的足够了，因此更复杂的也可以轻松集成到前途。

如何使用优化器¶

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

构建¶

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

注意

如果您需要通过将模型移动到 GPU，请在为其构建优化器。之后模型的参数是与调用之前的对象不同的对象。.cuda().cuda()

通常，您应该确保优化的参数位于构造和使用优化器时的一致位置。

例：

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)

基类¶

class （params， defaults）[来源]torch.optim.Optimizer¶

所有优化器的基类。

警告

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

参数

params （iterable） - s 或 s 的可迭代对象。指定应优化的 Tensor。
defaults – （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 算法。
`稀疏亚当`	实现适用于稀疏张量的 Adam 算法的惰性版本。
`阿达麦克斯`	实现 Adamax 算法（基于无穷范数的 Adam 变体）。
`ASGD`	实现平均随机梯度下降。
`LBFGS 公司`	实现 L-BFGS 算法，深受 minFunc 的启发。
`纳丹`	实现 NAdam 算法。
`RAdam`	实现 RAdam 算法。
`RMS属性`	实现 RMSprop 算法。
`Rprop`	实现弹性反向传播算法。
`新币`	实现随机梯度下降（可选使用动量）。

如何调整学习率¶

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

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

例：

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

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

例：

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 算法。

>>> 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`	使用余弦退火计划设置每个参数组的学习率，其中 $\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 中两次热重启之间的纪元数：

随机权重平均¶

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

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

构建平均模型¶

AveragedModel 类用于计算 SWA 模型的权重。您可以创建一个平均模型：

>>> swa_model = AveragedModel(model)

此处的模型可以是任意对象。将跟踪参数的运行平均值。更新这些 averages，您可以使用以下函数：modelswa_modelmodelupdate_parameters()

>>> swa_model.update_parameters(model)

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

自定义平均策略¶

默认情况下，计算提供的参数，但您也可以将自定义平均函数与参数一起使用。在下面的示例中，计算指数移动平均线。torch.optim.swa_utils.AveragedModelavg_fnema_model

例：

>>> 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 模型。我们训练模型总共 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)

torch.optim¶

如何使用优化器¶

构建¶

每个参数选项¶

采取优化步骤¶

`optimizer.step()`¶

`optimizer.step(closure)`¶

基类¶

算法¶

如何调整学习率¶

随机权重平均¶

构建平均模型¶

SWA 学习率计划¶

处理批量归一化¶

自定义平均策略¶

把它们放在一起¶

文档

教程

资源

torch.optim¶

如何使用优化器¶

构建¶

每个参数选项¶

采取优化步骤¶

optimizer.step()¶

optimizer.step(closure)¶

基类¶

算法¶

如何调整学习率¶

随机权重平均¶

构建平均模型¶

SWA 学习率计划¶

处理批量归一化¶

自定义平均策略¶

把它们放在一起¶

文档

教程

资源

`optimizer.step()`¶

`optimizer.step(closure)`¶