参考链接：https://blog.csdn.net/qyhaill/article/details/103043637
调用例子：
import torch
import torch.nn as nn
from torch.optim.lr_scheduler import LambdaLR
initial_lr = 5
class model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=3, kernel_size=3)
def forward(self, x):
pass
net_1 = model()
optimizer_1 = torch.optim.Adam(net_1.parameters(), lr = initial_lr)
scheduler_1 = LambdaLR(optimizer_1, lr_lambda=lambda epoch: 1/(epoch+1),verbose = True)
print("初始化的学习率：", optimizer_1.defaults['lr'])
for epoch in range(1, 11):
optimizer_1.zero_grad()
optimizer_1.step()
print("第%d个epoch的学习率：%f" % (epoch, optimizer_1.param_groups[0]['lr']))
scheduler_1.step()
方法：
1.torch.optim.lr_scheduler.LambdaLR
初始学习率乘以系数，由于每一次乘系数都是乘初始学习率，因此系数往往是epoch的函数。
torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=- 1, verbose=False)
计算公式：
lr_lambda = f(epoch)
new_lr = lr_lambda * init_lr
参数：
- optimizer (Optimizer) – 需要优化的优化器
- lr_lambda：关于epoch的数学函数，或者一个此类函数的列表，比如： lambda: epoch*2。在每个epoch中进行。
- last_epoch：最后一个epoch的索引，默认为-1。
- verbose：如果设置为True, 打印每个epoch的new_lr。
例子：
lambda1 = lambda epoch: 0.95 ** epoch
scheduler = LambdaLR(optimizer, lr_lambda=lambda1, verbose = True)
for epoch in range(100):
train(...)
validate(...)
scheduler.step()
2.torch.optim.lr_scheduler.MultiplicativeLR
与LambdaLR不同，该方法用前一次的学习率乘以lr_lambda,因此通常lr_lambda函数不需要与epoch有关。
torch.optim.lr_scheduler.MultiplicativeLR(optimizer, lr_lambda, last_epoch=- 1, verbose=False)
计算公式：
new_lr = lr_lambda*old_lr
- optimizer ： 需要优化的优化器
- lr_lambda : 乘数、函数或者此类函数的列表。
- last_epoch：最后一个epoch的索引，默认为-1。
- verbose：如果设置为True, 打印每个epoch的new_lr。
例子：
lmbda = lambda epoch: 0.95
scheduler = MultiplicativeLR(optimizer, lr_lambda=lmbda)
for epoch in range(100):
train(...)
validate(...)
scheduler.step()
3.torch.optim.lr_scheduler.StepLR
每过step_size个epoch，做一次更新
torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=- 1, verbose=False)
计算公式：
- optimizer：要优化的优化器
- step_size：每训练step_size个epoch，更新一次参数
- gamma：更新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.torch.optim.lr_scheduler.MultiStepLR
与上述规定经过多少个epoch的方式不同，该方法是用于特定epoch时进行更新的，即每次遇到milestones中的epoch，做一次更新
torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=- 1, verbose=False)
- optimizer：要优化的优化器
- milestones：epoch的索引列表，里面的元素必须是递增的。
- gamma：更新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()
5.torch.optim.lr_scheduler.ConstantLR
将每个参数组的学习率衰减一个小的常数因子，直到 epoch 的数量达到预定义的milestone，这种衰减可能与此调度程序外部对学习率的其他更改同时发生。
torch.optim.lr_scheduler.ConstantLR（优化器，因子= 0.3333333333333333，total_iters = 5，last_epoch = - 1，详细= False）
公式：
[base_lr * (self.factor + (self.last_epoch >= self.total_iters) * (1 - self.factor))
- factor: 乘数因子，乘以学习率直到milestone的epoch
- total_iter: 调度程序衰减学习率的步数,即达到该iter，学习率变化。
例子：
# Assuming optimizer uses lr = 0.05 for all groups
# lr = 0.025 if epoch == 0
# lr = 0.025 if epoch == 1
# lr = 0.025 if epoch == 2
# lr = 0.025 if epoch == 3
# lr = 0.05 if epoch >= 4
scheduler = ConstantLR(self.opt, factor=0.5, total_iters=4)
for epoch in range(100):
train(...)
validate(...)
scheduler.step()
6.torch.optim.lr_scheduler.LinearLR
通过线性改变小的乘法因子来衰减每个参数组的学习率，直到 epoch 的数量达到预定义的milestone
torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=0.3333333333333333, end_factor=1.0, total_iters=5, last_epoch=- 1, verbose=False)
公式：
base_lr * (self.start_factor + (self.end_factor - self.start_factor) * min(self.total_iters, self.last_epoch) / self.total_iters
- start_factor ：在第一个 epoch 中乘以学习率的数字。在接下来的时期，乘法因子向 end_factor 变化。
- end_factor ：在线性变化过程结束时乘以学习率的数字。
- total_iters ：乘法因子达到 1 的迭代次数。
例子：（官网这个例子个人感觉输出错了）
>>> # Assuming optimizer uses lr = 0.05 for all groups
>>> # lr = 0.025 if epoch == 0
>>> # lr = 0.03125 if epoch == 1
>>> # lr = 0.0375 if epoch == 2
>>> # lr = 0.04375 if epoch == 3
>>> # lr = 0.005 if epoch >= 4
>>> scheduler = LinearLR(self.opt, start_factor=0.5, total_iters=4)
>>> for epoch in range(100):
>>> train(...)
>>> validate(...)
>>> scheduler.step()
7.torch.optim.lr_scheduler.ExponentialLR
与MultiplicativeLR相似，但这个是直接使用乘数因子
torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=- 1, verbose=False)
