一、简介

介绍： 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()
所有优化器的基类。
注意：参数为具有确定性顺序的集合，这些顺序在两次运行之间是一致的。

2.2 方法

2.2.1 add_param_group(param_group)

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

2.2.2 load_state_dict（state_dict ）

功能：加载优化器状态

2.2.3 state_dict()

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

2.2.4 step(closure)

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

三、优化算法

3.1 torch.optim.Adadelta()

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

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

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优化算法

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

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优化算法

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

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优化算法

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

3.5 torch.optim.SparseAdam()

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

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

3.6 torch.optim.Adamax()

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

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

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优化算法

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

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优化算法
该优化器不支持每个参数的选项和参数组（只能有一个）。这是一个占用大量内存的优化器（需要额外的 字节）

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

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优化算法

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

3.10 torch.optim.Rprop()

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

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

3.11 torch.optim.SGD()

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

>>> 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)
功能：执行单个优化步骤（参数更新）

四、调整学习率

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

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

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

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

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 有两个参数组 .
>>> 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。

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

>>> # 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。

>>> # 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。

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。

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 = 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 = 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学习率策略每批更改一次学习率。 一批用于训练后应调用步骤。

>>> 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)
功能：使用余弦退火时间表设置每个参数组的学习率

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