前言：
之前在训练模型时一直使用自定义的学习率衰减函数，如下所示：
def adjust_learning_rate(args, optimizer, epoch, gamma=0.1):
"""Sets the learning rate to the initial LR decayed 0.1 every 50 epochs"""
lr = args.lr * (0.1 ** (epoch // 50))
for param_group in optimizer.param_groups:
param_group['lr'] = lr然后在每个epoch训练前调用一次，实现学习率的衰减：
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(args, optimizer, epoch, gamma=0.1)
......后来发现pytorch也像tensorflow一样实现了很多学习率调整的方法，并封装在了torch.optim.lr_scheduler模块中，接下来对这些方法进行一下总结。
1. torch.optim.lr_scheduler.StepLR
* step_size (int):
学习率的衰减周期，单位是epoch。
* gamma(float):
学习率衰减的乘积因子，默认为0.1。
* 说明：
等间隔的学习率衰减，每训练step_size个epoch，将学习率调整为lr=lr*gamma。
使用示例如下：
# 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
# ...
optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.9, weight_decay=1e-4)
scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
for epoch in range(start_epoch, epochs):
train(...)
validate(...)
scheduler.step()
2. torch.optim.lr_scheduler.MultiStepLR
* milestones(list)
: epoch索引的列表，必须是递增的。
* gamma(float)
: 学习率衰减的乘积因子，默认为0.1。
* 说明：
自定义多间隔的学习率衰减，当训练到epoch索引列表中的epoch值时，才将学习率调整为lr=lr*gamma。
使用示例如下：
# 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
# ...
optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.9, weight_decay=1e-4)
scheduler = MultiStepLR(optimizer, milestones=[30,80], gamma=0.1)
for epoch in range(start_epoch, epochs):
train(...)
validate(...)
scheduler.step()
3. torch.optim.lr_scheduler.ExponentialLR
* gamma(float)：
学习率衰减的乘积因子，默认为0.1。
* 说明：
学习率呈指数型衰减，每训练一个epoch，就将学习率调整为lr=lr*gamma**epoch。
使用示例如下：
# Assuming optimizer uses lr = 0.05 for all groups
# lr = lr*gamma**epoch
optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.9, weight_decay=1e-4)
scheduler = ExponentialLR(optimizer, gamma=0.1)
for epoch in range(start_epoch, epochs):
train(...)
validate(...)
scheduler.step()
4. torch.optim.lr_scheduler.CosineAnnealingLR
* T_max (int)：
学习率下降到最小值时的epoch值。即当epoch迭代到T_max时，学习率会下降到余弦函数最小值。（当epoch大于T_max时，学习率反而会上升）
* eta_min (float)：
学习率lr的最小值，默认为0。即当epoch迭代到T_max时，lr(min)=eta_min。
* 说明：
学习率呈余弦函数型衰减。具体来说，lr的曲线是如同cos(x)一样周期性变化的，以2*T_max为余弦函数的周期，当epoch=0时，对应余弦函数曲线x=0，此时 lr为初始值 lr=lr；当epoch=T_max时，对应余弦函数曲线x=
，此时 lr=eta_min。lr 的值在[0, T_max]区间下降；在[T_max, epochs]区间上升。
使用示例如下：
# Assuming optimizer uses lr = 0.05 for all groups
# lr = lr*gamma**epoch
optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.9, weight_decay=1e-4)
scheduler = CosineAnnealingLR(optimizer, T_max=epochs, eta_min=0.00000001)
for epoch in range(start_epoch, epochs):
train(...)
validate(...)
scheduler.step()
5. torch.optim.lr_scheduler.ReduceLROnPlateau
* mode(str)：
提供了’min’和’max’两种模式，’min’表示当监控指标(如loss)不再降低时调整学习率；‘max’表示当监控指标(如accuracy)不再升高时调整学习率。默认为’min’。
* factor (float)：
学习率衰减因子，new_lr = lr * factor，默认为0.1。
* patience (int)：
表示能忍受监控指标在patience个epochs内没有优化，如果超出patience个opechs，则进行学习率衰减。默认为10。
* verbose (bool)：
是否打印学习率信息，如果为True，则每次调整学习率后打印一条变化的信息，默认为False。
* threshold (float)：
衡量新最优值得阈值，只关注最大的变化。配合threshold_mode一起使用。
* threshold_mode (str)：
提供了’rel’ 和 ‘abs’两种模式，来判断监控指标是否达最优的模式。
‘rel’ 模式下，当mode=’max’时，dynamic_threshold = best * ( 1 + threshold )；
‘rel’ 模式下，当mode=’min’时，dynamic_threshold = best * ( 1 – threshold )；
‘abs’ 模式下，当mode=’max’时，dynamic_threshold = best + threshold；
‘abs’ 模式下，当mode=’min’时，dynamic_threshold = best – threshold；
* cooldown (int)：
减小 lr后恢复正常操作之前需要等待的epoch数，默认为0。
* min_lr (float or list)：
所有参数组（float）或各参数组（list）的学习率的下界。
* eps (float)：
学习率衰减的最小值。当学习率更新后的值小于eps，则勿略此次更新。
使用示例如下：
optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.9, weight_decay=1e-4)
scheduler = ReduceLROnPlateau(optimizer, 'min')
for epoch in range(start_epoch, epochs):
train(...)
val_loss = validate(...)
# Note that step should be called after validate()
scheduler.step(val_loss)
6. torch.optim.lr_scheduler.LambdaLR
* lr_lambda (function or list)：
自定义的学习率衰减函数，实现对于给定的epoch，计算不同epoch时期的学习率，当有多个参数组时，设为由函数构成的list。
使用示例如下：
# Assuming optimizer has two groups.
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()
注意：
1.
当有多个optimizer时，可以写成如下形式：
...
schedulers = [MultiStepLR(raw_optimizer, milestones=[60, 100], gamma=0.1),
MultiStepLR(concat_optimizer, milestones=[60, 100], gamma=0.1),
MultiStepLR(part_optimizer, milestones=[60, 100], gamma=0.1),
MultiStepLR(partcls_optimizer, milestones=[60, 100], gamma=0.1)]
...
for scheduler in schedulers:
scheduler.step()
...
2.
scheduler.step()在每个epoch中使用一次（区别于optimizer.step()在每个batch中使用一次），且通常用在train()和validate()之后。