【Pytorch】touch.optim

一、简介

  介绍： totch.optim是一个实现很多优化算法的包，并且支持常用的方法，并且接口足够通用，因此也可以用来轻松集成更复杂的方法。
  使用方法： 使用torch.optim，必须构建一个优化器对象，该优化器对象将保持当前状态，并根据计算出的梯度更新参数.
  构建优化器： 构建优化器，必须给它提供一个包含参数的可迭代器（所有参数都应为Variable）以进行优化。然后可以指定优化器特定选项，如学习率，权重衰减等。

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

  优化器也支持每个参数选项（不用传递variables的可迭代器），而是传递dicts的迭代——每个dict定义了一个单独的参数组，每个参数组包含一个名为params的key，value为该组的参数列表。其他key应与优化器接受的关键字参数匹配用作该字典包含参数的优化选项。

optim.SGD([
                {'params': model.base.parameters()},#model.base.parameters使用默认学习率1e-2
                {'params': model.classifier.parameters(), 'lr': 1e-3}
            ], lr=1e-2, momentum=0.9)

  优化模型参数： 所有优化器使用step()的方法，更新模型的参数，它有两种使用方式
  方法1：optimizer.step()
  这种方法支持大多数优化器，一旦使用backward()函数计算梯度，就可以调用optimizer.step()来更新参数。

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

  方法2：optimizer.step(closure)
  一些优化算法（如共轭梯度和LBFGS）需要多次重新评估函数，因此您必须传递closure以允许它们重新计算模型。closure应清除梯度，计算损耗，然后将其返回。

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)

二、优化器Optimizer

2.1 类torch.optim.Optimizer()

  语法：torch.optim.Optimizerparams, defaults()
  所有优化器的基类。
  注意：参数为具有确定性顺序的集合，这些顺序在两次运行之间是一致的。

参数	功能
params	(iterable)可迭代。torch.Tensor或dict的迭代， 指定应该优化哪些张量
default	(dict)字典。包含优化选项默认值的dict（在参数组未指定优化选项值时使用）。

2.2 方法

2.2.1 add_param_group(param_group)

  功能：将参数组param_group添加到Optimizer的参数组中。当对预训练的网络进行微调时，这很有用 ，因为可以使冻结的层成为可训练的，并随着训练的进行而添加到优化器中。

参数	功能
param_group	(dict)字典。指定应与Optimizer的参数组一起优化哪些张量
optimization options	（具体）

2.2.2 load_state_dict（state_dict ）

  功能：加载优化器状态

参数	功能
state_dict	(dict)字典。优化器状态，该状态是通过调用 state_dict(). 函数得到的

2.2.3 state_dict()

  功能：返回优化器的状态，返回值为dict字典，字典包含了两个条目：
    1.state：一个字典，保持当前优化状态， 字典内容在优化程序类之间有所不同。
    2.param_groups：一个字典，包含所有参数组

2.2.4 step(closure)

  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable)可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

三、优化算法

3.1 torch.optim.Adadelta()

  语法：torch.optim.Adadelta(params, lr=1.0, rho=0.9, eps=1e-06, weight_decay=0)
  功能：自适应学习率优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=1.0	（float, optional)。学习率：在将增量应用于参数之前缩放增量的系数（默认值：1.0）
rho	（float, optional)。用于计算平方梯度的移动平均值的系数（默认值：0.9）
eps=1e-06	（float, optional)。分母中添加的项以提高数值稳定性（默认值：1e-6）
weight_decay=0	（float, optional)。权重衰减（默认值：0）

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.2 torch.optim.Adagrad()

  语法：torch.optim.Adagrad(params, lr=0.01, lr_decay=0, weight_decay=0, initial_accumulator_value=0, eps=1e-10)
  功能：Adagrad优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=0.01	（float, optional)。学习率：（默认值：0.01）
lr_decay=0	（float, optional)。学习率衰减（默认值：0）
weight_decay=0	（float, optional)。权重衰减（默认值：0）
initial_accumulator_value=0
eps=1e-10	（float, optional)。分母中添加的项以提高数值稳定性（默认值：1e-10）

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.3 torch.optim.Adam()

  语法：torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)
  功能：Adam优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=0.001	（float, optional)。学习率：（默认值：0.001）
betas=(0.9, 0.999)	（Tuple[float, float], optional)。用于计算梯度及其平方的移动平均值的系数（默认值：（0.9，0.999）
eps=1e-8	（float, optional)。分母中添加的项以提高数值稳定性（默认值：1e-8）
weight_decay=0	（float, optional)。权重衰减（默认值：0）
amsgrad=False	（boolean ，optional）。是否使用AMSGrad的变体（默认值：False）

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.4 torch.optim.AdamW()

  语法：torch.optim.AdamW(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False)
  功能：AdamW优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=0.001	（float, optional)。学习率：（默认值：0.001）
betas=(0.9, 0.999)	（Tuple[float, float], optional)。用于计算梯度及其平方的移动平均值的系数（默认值：（0.9，0.999）
eps=1e-8	（float, optional)。分母中添加的项以提高数值稳定性（默认值：1e-8）
weight_decay=0.01	（float, optional)。权重衰减（默认值：1e-2）
amsgrad=False	（boolean ，optional）。是否使用AMSGrad的变体（默认值：False）

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.5 torch.optim.SparseAdam()

  语法：torch.optim.SparseAdam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08)
  功能：SparseAdam优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=0.001	（float, optional)。学习率：（默认值：0.001）
betas=(0.9, 0.999)	（Tuple[float, float], optional)。用于计算梯度及其平方的移动平均值的系数（默认值：（0.9，0.999）
eps=1e-8	（float, optional)。分母中添加的项以提高数值稳定性（默认值：1e-8）

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.6 torch.optim.Adamax()

  语法：torch.optim.Adamax(params, lr=0.002, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)
  功能：Adamax优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=0.002	（float, optional)。学习率：（默认值：0.002）
betas=(0.9, 0.999)	（Tuple[float, float], optional)。用于计算梯度及其平方的移动平均值的系数（默认值：（0.9，0.999）
eps=1e-8	（float, optional)。分母中添加的项以提高数值稳定性（默认值：1e-8）
weight_decay=0	（float, optional)。权重衰减（默认值：0）

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.7 torch.optim.ASGD()

  语法：torch.optim.ASGD(params, lr=0.01, lambd=0.0001, alpha=0.75, t0=1000000.0, weight_decay=0)
  功能：ASGD优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=0.002	（float, optional)。学习率：（默认值：0.002）
lambd=0.0001	（（float，optional）。衰减项（默认值：1e-4）
alpha=0.75	（float, optional)。eta更新的power（默认值：0.75）
t0=1000000.0	（float, optional)。开始平均的点（默认值：1e6）
weight_decay=0	（float, optional)。权重衰减（默认值：0）

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可选、可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.8 torch.optim.LBFGS()

  语法：torch.optim.LBFGS(params, lr=1, max_iter=20, max_eval=None, tolerance_grad=1e-07, tolerance_change=1e-09, history_size=100, line_search_fn=None)
  功能：LBFGS优化算法
  该优化器不支持每个参数的选项和参数组（只能有一个）。这是一个占用大量内存的优化器（需要额外的 字节）

参数	功能
params	不支持per-parameter选项（【字典1，字典2】）和参数组（只能包含一个）
lr=1	（float, optional)。学习率：（默认值：1）
max_iter=20	（int）。每个优化步骤的最大迭代次数（默认值：20）
max_eval=None	（int）。e每个优化步骤的最大函数评估数（默认值：max_iter * 1.25）。
tolerance_grad=1e-07	（float)。一阶最优的端接公差（默认值：1e-5）。
tolerance_change=1e-09	（float)。函数值/参数更改的终止公差（默认值：1e-9）
history_size=100	（int)。更新历史记录大小（默认值：100）
line_search_fn	（str）。 ‘strong_wolfe’ 或 None (默认: None).

  优化：step(closure)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable)可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.9 torch.optim.RMSprop()

  语法：torch.optim.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)
  功能：RMSprop优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=0.01	（float, optional)。学习率：（默认值：0.01）
alpha=0.99	（float, optional)。平滑常数（默认值：0.99））
eps=1e-08	（（float，optional）。分母中添加的项以提高数值稳定性（默认值：1e-8）
weight_decay=0	（float, optional)。权重衰减（默认值：0）
momentum=0	（float, optional)。动量因子（默认值：0）
centered=False	（bool, optional)。如果True计算居中RMSProp，则通过估计其方差来对梯度进行归一化

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可选、可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.10 torch.optim.Rprop()

  语法：torch.optim.Rprop(params, lr=0.01, etas=(0.5, 1.2), step_sizes=(1e-06, 50))
  功能：Rprop优化算法

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr=0.01	（float, optional)。学习率：（默认值：0.01）
etas=(0.5, 1.2)	(Tuple[float, float], optional)。（etaminus，etaplis）是可乘的增加和减少因子（默认值：（0.5，1.2））
eps=1e-08	（（float，optional）。分母中添加的项以提高数值稳定性（默认值：1e-8）
step_sizes=(1e-06, 50)	（Tuple[float, float], optional)。一对最小和最大允许步长（默认值：（1e- 6，50））

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可选、可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

3.11 torch.optim.SGD()

  语法：torch.optim.SGD(params, lr= < required parameter>, momentum=0, dampening=0, weight_decay=0, nesterov=False)
  功能：SGD优化算法，随机梯度下降

参数	功能
params	(iterable)可迭代。用于优化的参数的迭代或定义参数组的字典
lr= < required parameter>	（floatl)。学习率，无默认值，必须指定
momentum=0	(float, optional)。动量因子
dampening=0	（float，optional）。衰减动量（默认值：0）
weight_decay=0	（float，optional）。权重衰减（L2惩罚）（默认值：0）
nesterov=False	（bool，optional）。启用Nesterov动量（默认值：False）

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> optimizer.zero_grad()
>>> loss_fn(model(input), target).backward()
>>> optimizer.step()

  优化：step(closure=None)
  功能：执行单个优化步骤（参数更新）

参数	功能
closure	(callable， optional)可选、可调用。对于大多数优化器是可选的。重新评估模型并返回损失的闭合。

四、调整学习率

  torch.optim.lr_scheduler提供了几种根据epoch数调整学习率的方法。
  编写代码示例：

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

  定义调整学习率的 scheduler后可以使用：
  （1）load_state_dict(state_dict)
  功能：加载scheduler状态

参数	功能
state_dict	(dict)scheduler状态。该状态是调用state_dict().函数得到

  （2）state_dict()
  功能：返回scheduler状态，返回值为一个列表

参数	功能
state_dict	(dict)scheduler状态。该状态是调用state_dict().函数得到

4.1 torch.optim.lr_scheduler.LambdaLR（）

  语法：torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1, verbose=False)
  功能：将每个参数组的学习率设置为给定函数的初始lr倍。 当last_epoch = -1时，将初始lr设置为lr。

参数	功能
optimizer	(Optimizer) 。 优化器
lr_lambda	（function or list)。给定整数参数epoch时计算乘法因子的函数、或此类函数的列表optimizer.param_groups中的每个组对应列表的一个函数。
last_epoch=-1	(int) 。最后一个epoch的索引（默认值：-1）
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

>>> # 假设optimizer 有两个参数组 .
>>> lambda1 = lambda epoch: epoch // 30
>>> lambda2 = lambda epoch: 0.95 ** epoch
>>> scheduler = LambdaLR(optimizer, lr_lambda=[lambda1, lambda2])
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

4.2 torch.optim.lr_scheduler.MultiplicativeLR（）

  语法：torch.optim.lr_scheduler.MultiplicativeLR(optimizer, lr_lambda, last_epoch=-1, verbose=False)
  功能：将每个参数组的学习率乘以指定函数中给定的因子。 当last_epoch = -1时，将初始lr设置为lr。

参数	功能
optimizer	(Optimizer) 。 优化器
lr_lambda	（function or list)。给定整数参数epoch时计算乘法因子的函数、或此类函数的列表optimizer.param_groups中的每个组对应列表的一个函数。
last_epoch=-1	(int) 。最后一个epoch的索引（默认值：-1）
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

>>> lmbda = lambda epoch: 0.95
>>> scheduler = MultiplicativeLR(optimizer, lr_lambda=lmbda)
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

4.3 torch.optim.lr_scheduler.StepLR（）

  语法：torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1, verbose=False)
  功能：在每step_size时期(epoch)，通过gamma降低每个参数组的学习率。 注意，这种衰减可能与此调度程序外部的学习速率的其他更改同时发生。当last_epoch = -1时，将初始lr设置为lr。

参数	功能
optimizer	(Optimizer) 。 优化器
step_size	(int) 。学习率衰减的周期。单位为epoch
gamma=0.1	（float） 。学习率衰减的乘数。（默认值：0.1）
last_epoch	（int）。最后一个epoch的索引
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

>>> # Assuming optimizer uses lr = 0.05 for all groups
>>> # lr = 0.05     if epoch < 30
>>> # lr = 0.005    if 30 <= epoch < 60
>>> # lr = 0.0005   if 60 <= epoch < 90
>>> # ...
>>> scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

4.4 torch.optim.lr_scheduler.MultiStepLR（）

  语法：torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1, verbose=False)
  功能：一旦epoch达到milestones数，就以gamma衰减每个参数组的学习率 注意，这种衰减可能与此调度程序外部的学习速率的其他更改同时发生。当last_epoch = -1时，将初始lr设置为lr。

参数	功能
optimizer	(Optimizer) 。 优化器
milestones	(list)列表 。epoch索引的列表
gamma=0.1	（float） 。学习率衰减的乘数。（默认值：0.1）
last_epoch	（int）。最后一个epoch的索引
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

>>> # Assuming optimizer uses lr = 0.05 for all groups
>>> # lr = 0.05     if epoch < 30
>>> # lr = 0.005    if 30 <= epoch < 80
>>> # lr = 0.0005   if epoch >= 80
>>> scheduler = MultiStepLR(optimizer, milestones=[30,80], gamma=0.1)
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

4.5 torch.optim.lr_scheduler.ExponentialLR（）

  语法：torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1, verbose=False)
  功能：每个epoch就以gamma衰减每个参数组的学习率 当last_epoch = -1时，将初始lr设置为lr。

参数	功能
optimizer	(Optimizer) 。 优化器
gamma=0.1	（float） 。学习率衰减的乘数。（默认值：0.1）
last_epoch	（int）。最后一个epoch的索引
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

4.6 torch.optim.lr_scheduler.CosineAnnealingLR（）

  语法：torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1, verbose=False)
  功能：使用余弦退火schedule设置每个参数组的学习率 当last_epoch = -1时，将初始lr设置为lr。

参数	功能
optimizer	(Optimizer) 。 优化器
T_max	（int） 。最大迭代次数
eta_min=0	（float）。最低学习率。（默认值：0）
last_epoch	（int）。最后一个epoch的索引，（默认值：-1）
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

4.7 torch.optim.lr_scheduler.ReduceLROnPlateau（）

  语法：torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode=‘min’, factor=0.1, patience=10, threshold=0.0001, threshold_mode=‘rel’, cooldown=0, min_lr=0, eps=1e-08, verbose=False)
  功能：当指标停止改善时，降低学习率。一旦学习停滞，模型通常会受益于将学习率降低2-10倍。该调度程序读取度量指标，如果对于“耐心”的时期没有看到改善，则学习率会降低。

参数	功能
optimizer	(Optimizer) 。 优化器
mode=‘min’	（str） 。最小或最大。在最小模式下，当监视的数量停止减少时，lr将减小；在最大模式下，当监视的数量停止增加时，它将减少。默认值：“ min”。
factor=0.1	（float）。学习率降低的因数。new_lr = lr *因子。（默认值：0.1）
patience=10	（int）。没有改善的时期数，之后学习率将降低。例如，如果 耐心= 2，那么我们将忽略前两个时期而没有任何改善，并且如果损失仍然没有改善，则只会在第三个时期之后降低LR。默认值：10
threshold=0.0001	（float）。用于测量新的最佳阈值，仅关注重大变化。默认值：1e-4。
hreshold_mode=‘rel’	(str)。 rel或abs。在rel模式下，“ max”模式下的dynamic_threshold = best *（1 + threshold），在min模式下，dynamic_threshold = best *（1-threshold）。在abs模式下，dynamic_threshold =最佳+ 最大模式下的阈值或最佳- 最小模式下的阈值。（默认值：“ rel”）。
cooldown=0,	（int）。减少lr后恢复正常运行之前要等待的时期数。（默认值：0）
min_lr=0	(float or list)。标量或标量列表。所有参数组或每个组的学习率的下限。默认值：0
eps=1e-08	（float）。最小衰减应用于lr。如果新旧lr之间的差异小于eps，则忽略该更新。默认值：1e-8。
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = ReduceLROnPlateau(optimizer, 'min')
>>> for epoch in range(10):
>>>     train(...)
>>>     val_loss = validate(...)
>>>     # Note that step should be called after validate()
>>>     scheduler.step(val_loss)

4.8 torch.optim.lr_scheduler.CyclicLR（）

  语法：torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr, max_lr, step_size_up=2000, step_size_down=None, mode=‘triangular’, gamma=1.0, scale_fn=None, scale_mode=‘cycle’, cycle_momentum=True, base_momentum=0.8, max_momentum=0.9, last_epoch=-1, verbose=False)
  功能：根据周期性学习率策略（CLR）设置每个参数组的学习率。该策略以恒定的频率在两个边界之间循环学习率。周期性学习率策略会在每批量之后更改学习率。

参数	功能
optimizer	(Optimizer) 。 优化器
base_lr	（(float or list)） 。初始学习率，它是每个参数组在循环中的下边界。
max_lr	（(float or list)）每个参数组在循环中的较高学习率边界。从功能上讲，它定义了循环幅度（max_lr-base_lr）。任何周期的lr是base_lr与振幅的一定比例之和；因此，取决于缩放函数，可能实际上无法达到max_lr。
step_size_up=2000	（int）。周期递增的一半中的训练迭代次数。默认值：2000
step_size_down=None	（int）。循环的减半中的训练迭代次数。如果step_size_down为None，则将其设置为step_size_up。默认值：None
scale_mode=‘cycle’,	（str）。 {triangle，trialang2，exp_range}之一。值与上面详述的策略相对应。如果scale_fn不为None，则忽略此参数。默认值：“三角形”
gamma=1.0	（float）。学习率降低的因数。new_lr = lr *因子。（默认值：0.1）
scale_fn=None	（function）。由单个参数lambda函数定义的自定义缩放策略，其中对于所有x> = 0，0 <= scale_fn（x）<=1。如果指定，则忽略“ mode”。默认值：无
scale_mode=‘cycle’	(str)。 {‘cycle’，‘iterations’}。定义是否在循环数或循环迭代（自循环开始以来的训练迭代）上评估scale_fn。默认值：“循环”。
cycle_momentum=True	（bool）。如果为True，则动量与“ base_momentum”和“ max_momentum”之间的学习速率成反比。默认值：True
base_momentum=0.8	(float or list)。每个参数组在循环中的较低动量边界。注意，动量与学习速度成反比。在一个周期的峰值，动量为“ base_momentum”，学习速率为“ max_lr”。默认值：0.8
max_momentum=0.9	（float or list）。每个参数组在循环中的上动量边界。从功能上讲，它定义了循环幅度（max_momentum-base_momentum）。任何周期的动量都是max_momentum与振幅的一定比例之差；因此，取决于缩放功能，实际上可能无法达到base_momentum。注意，动量与学习速度成反比。在周期开始时，动量为“ max_momentum”，学习速率为“ base_lr”默认值：0.9
last_epoch=-1	（int）。最后一个batch的索引，恢复训练作业时使用此参数。由于应该在每个批处理之后而不是在每个epoch之后调用step（），因此该数字表示所计算的批次总数，而不是所计算的epoch总数。当last_epoch = -1时，调度将从头开始。默认值：-1
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.01, max_lr=0.1)
>>> data_loader = torch.utils.data.DataLoader(...)
>>> for epoch in range(10):
>>>     for batch in data_loader:
>>>         train_batch(...)
>>>         scheduler.step()

  get_lr（）
  功能：计算批次索引的学习率。此函数将 self.last_epoch视为最后一批索引。
如果self.cycle_momentum为True，则此函数具有更新优化器动量的副作用。

4.9 torch.optim.lr_scheduler.OneCycleLR（）

  语法：torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr, total_steps=None, epochs=None, steps_per_epoch=None, pct_start=0.3, anneal_strategy=‘cos’, cycle_momentum=True, base_momentum=0.85, max_momentum=0.95, div_factor=25.0, final_div_factor=10000.0, last_epoch=-1, verbose=False)
  功能：根据1cycle学习率策略设置每个参数组的学习率。1周期策略将学习速率从初始学习速率退火到某个最大学习速率，然后从该最大学习速率退火到某个远低于初始学习速率的最小学习速率。1cycle学习率策略每批更改一次学习率。 一批用于训练后应调用步骤。

参数	功能
optimizer	(Optimizer) 。 优化器
max_lr	（int）循环中的总步数。请注意，如果此处未提供值，则必须通过为epochs和steps_per_epoch提供值来进行推断。默认值：none
total_steps=None	（int）。周期递增的一半中的训练迭代次数。默认值：2000
epochs=None	（int）。要训练的时期数。如果未提供total_steps的值，则将其与steps_per_epoch一起使用以推断循环中的步骤总数。默认值：无
steps_per_epoch=None	（int）。每个epoch要训练的步数。如果未提供total_steps的值，则将其与历元一起使用以推断循环中的总步数。默认值：无
pct_start=0.3	（float）。花费的周期百分比（以步数为单位），以提高学习率。默认值：0.3
anneal_strategy=‘cos’	（str）。{‘cos’，‘linear’}指定退火策略：余弦退火为“ cos”，线性退火为“ linear”。默认值：“ cos”
cycle_momentum=True	(bool)。 如果为True，则动量与“ base_momentum”和“ max_momentum”之间的学习速率成反比。默认值：True
base_momentum=0.85	(float or list)。每个参数组在循环中的较低动量边界。注意，动量与学习速度成反比。在一个周期的峰值，动量为“ base_momentum”，学习速率为“ max_lr”。默认值：0.85
max_momentum=0.9	（float or list）。每个参数组在循环中的上动量边界。从功能上讲，它定义了循环幅度（max_momentum-base_momentum）。注意，动量与学习速度成反比。在周期开始时，动量为“ max_momentum”，学习速率为“ base_lr”默认值：0.95
div_factor=25.0	（float）。通过initial_lr = max_lr / div_factor确定初始学习率默认值：25
final_div_factor=10000.0	（float）。通过min_lr = initial_lr / final_div_factor确定最小学习率默认值：1e4
last_epoch=-1	（int）。最后一个batch的索引，恢复训练作业时使用此参数。由于应该在每个批处理之后而不是在每个epoch之后调用step（），因此该数字表示所计算的批次总数，而不是所计算的epoch总数。当last_epoch = -1时，调度将从头开始。默认值：-1
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

>>> data_loader = torch.utils.data.DataLoader(...)
>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.01, steps_per_epoch=len(data_loader), epochs=10)
>>> for epoch in range(10):
>>>     for batch in data_loader:
>>>         train_batch(...)
>>>         scheduler.step()

4.10 torch.optim.lr_scheduler.CosineAnnealingWarmRestarts（）

  语法：torch.optim.lr_scheduler.(optimizer, T_0, T_mult=1, eta_min=0, last_epoch=-1, verbose=False)
  功能：使用余弦退火时间表设置每个参数组的学习率

参数	功能
optimizer	(Optimizer) 。 优化器
T_0	（int）第一次重启的迭代次数。
T_mult=1	（int,optional）。重启之后因素增加Ti，默认：0
eta_min=0	（float, optional）。最低学习率。默认值：0
last_epoch=-1	（int,optional）。最后一个epoch的索引。默认值：-1
verbose=False	（bool）。如果True为，则每次更新都会向stdout打印一条消息。默认值：False。

>>> data_loader = torch.utils.data.DataLoader(...)
>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.01, steps_per_epoch=len(data_loader), epochs=10)
>>> for epoch in range(10):
>>>     for batch in data_loader:
>>>         train_batch(...)
>>>         scheduler.step()

>>> scheduler = CosineAnnealingWarmRestarts(optimizer, T_0, T_mult)
>>> iters = len(dataloader)
>>> for epoch in range(20):
>>>     for i, sample in enumerate(dataloader):
>>>         inputs, labels = sample['inputs'], sample['labels']
>>>         optimizer.zero_grad()
>>>         outputs = net(inputs)
>>>         loss = criterion(outputs, labels)
>>>         loss.backward()
>>>         optimizer.step()
>>>         scheduler.step(epoch + i / iters)

>>> scheduler = CosineAnnealingWarmRestarts(optimizer, T_0, T_mult)
>>> for epoch in range(20):
>>>     scheduler.step()
>>> scheduler.step(26)
>>> scheduler.step() # scheduler.step(27), instead of scheduler(20)