学习率调整策略
梯度下降： Wi+1 = Wi - LR * g(Wi)
学习率(learning rate)控制更新的步伐。
Class _LRScheduler
class _LRScheduler(object):
def __init__(self, optimizer, last_epoch=-1):
def get_lr(self):
raise NotImplementedError
主要属性：
optimizer: 关联的优化器
last_epoch: 记录epoch数，学习率的调整周期为epoch
base_lrs: 记录初始学习率
主要方法：
step(): 更新下一个epoch的学习率
get_lr(): 虚函数，计算下一个epoch的学习率
代码调试
在80行设置断点，并进行Debug，
点击step into，进入StepLR类中，而StepLR 继承于_LRScheduler类。__init__函数中我们可以发现前两行代码记录需要的参数，在208行StepLR继承了父类的__init__函数，
进入父类的__init__函数，前面是输入的合法性判断，在第17行将optimizer赋予到类的优化器中，在第27行构建一个base_lrs，由于我们可能有多个学习率，因此base_lrs为list类型，该行代码到我们优化器中的参数组param_groups中把我们参数组的每个初始学习率取出来，构建一个list存放到_LRScheduler中的base_lrs中，
所以base_lrs为一个list，如下图所示，由于我们之管理了一个参数组，所以list中只有一个元素。
在构建好scheduler后我们会在scheduler.step()使用它，用来更新下一个epoch的学习率。接下来我们进入该行代码查看流程，
进入step()函数，
点击运行到103行，这里对epoch进行一个加1的操作，所以step()必需放入epoch中，在106行会修改参数组中的学习率，对优化器中的参数组进行for循环，参数组为list，list中每一个元素为一个字典，lr采用了self.get_lr()函数，即传入计算的下一个epoch的学习率。
接下来我们进入self.get_lr()查看如何计算下一个epoch的学习率。首先对self.base_lrs进行for循环，把list中的每一个元素取出来乘以gamma的(self.epoch // self.step_size)次方，
六种学习率调整策略
import torch
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
torch.manual_seed(1)
LR = 0.1
iteration = 10
max_epoch = 200
# ------------------------------ fake data and optimizer ------------------------------
weights = torch.randn((1), requires_grad=True)
target = torch.zeros((1))
optimizer = optim.SGD([weights], lr=LR, momentum=0.9)
1、StepLR
lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)
功能：等间隔调整学习率
主要参数：
step_size: 调整间隔数
gamma: 调整系数
调整方式： lr = lr * gamma
# ------------------------------ 1 Step LR ------------------------------
# flag = 0
flag = 1
if flag:
scheduler_lr = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.1) # 设置学习率下降策略
lr_list, epoch_list = list(), list()
for epoch in range(max_epoch):
# 获取当前lr，新版本用 get_last_lr()函数，旧版本用get_lr()函数，具体看UserWarning
lr_list.append(scheduler_lr.get_last_lr())
epoch_list.append(epoch)
for i in range(iteration):
loss = torch.pow((weights - target), 2)
loss.backward()
optimizer.step()
optimizer.zero_grad()
scheduler_lr.step()
plt.plot(epoch_list, lr_list, label="Step LR Scheduler")
plt.xlabel("Epoch")
plt.ylabel("Learning rate")
plt.legend()
plt.show()
我们可以看到，每隔50个epoch就会下降学习率。
2、MultizStepLR
lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)
主要参数：
milestones: 设定调整时刻数
gamma: 调整系数
调整方式： lr = lr * gamma
# ------------------------------ 2 Multi Step LR ------------------------------
# flag = 0
flag = 1
if flag:
milestones = [50, 125, 160]
scheduler_lr = optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1)
lr_list, epoch_list = list(), list()
for epoch in range(max_epoch):
lr_list.append(scheduler_lr.get_lr())
epoch_list.append(epoch)
for i in range(iteration):
loss = torch.pow((weights - target), 2)
loss.backward()
optimizer.step()
optimizer.zero_grad()
scheduler_lr.step()
plt.plot(epoch_list, lr_list, label="Multi Step LR Scheduler\nmilestones:{}".format(milestones))
plt.xlabel("Epoch")
plt.ylabel("Learning rate")
plt.legend()
plt.show()
3、ExponentialLR
lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1)
功能：按指数衰减调整学习率
主要参数：
gamma: 指数的底
调整方式： lr = lr * gamma ** epoch
# ------------------------------ 3 Exponential LR ------------------------------
# flag = 0
flag = 1
if flag:
gamma = 0.95
scheduler_lr = optim.lr_scheduler.ExponentialLR(optimizer, gamma=gamma)
lr_list, epoch_list = list(), list()
for epoch in range(max_epoch):
lr_list.append(scheduler_lr.get_lr())
epoch_list.append(epoch)
for i in range(iteration):
loss = torch.pow((weights - target), 2)
loss.backward()
optimizer.step()
optimizer.zero_grad()
scheduler_lr.step()
plt.plot(epoch_list, lr_list, label="Exponential LR Scheduler\ngamma:{}".format(gamma))
plt.xlabel("Epoch")
plt.ylabel("Learning rate")
plt.legend()
plt.show()
4、CosineAnnealingLR
lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)
功能：余炫周期调整学习率
主要参数：
T_max: 下降周期
eta_min:学习率下限
调整方式：
# ------------------------------ 4 Cosine Annealing LR ------------------------------
# flag = 0
flag = 1
if flag:
t_max = 50
scheduler_lr = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=t_max, eta_min=0.)
lr_list, epoch_list = list(), list()
for epoch in range(max_epoch):
lr_list.append(scheduler_lr.get_lr())
epoch_list.append(epoch)
for i in range(iteration):
loss = torch.pow((weights - target), 2)
loss.backward()
optimizer.step()
optimizer.zero_grad()
scheduler_lr.step()
plt.plot(epoch_list, lr_list, label="CosineAnnealingLR Scheduler\nT_max:{}".format(t_max))
plt.xlabel("Epoch")
plt.ylabel("Learning rate")
plt.legend()
plt.show()
5、ReduceLROnPlateau
lr_scheduler.ReduceLROnPlateau(optimizer, mode=‘min’, factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_model=‘rel’, cooldown=0, min_lr=0, eps=1e-8)
功能: 监控指标，当指标不再变化则调整
主要参数：
model: min/max两种模式，min对应于loss,max对应于分类的准确缺略
factor: 调整系数
patience：“耐心”， 接受几次不变化
cooldown: “冷却时间”，停止监控一段时间
verbose：是否打印日志
min_lr: 学习率下限
eps: 学习率衰减最小值
# ------------------------------ 5 Reduce LR On Plateau ------------------------------
# flag = 0
flag = 1
if flag:
loss_value = 0.5
accuray = 0.9
factor = 0.1
mode = "min"
patience = 10
cooldown = 10
min_lr = 1e-4
verbose = True
scheduler_lr = optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=factor, mode=mode, patience=patience,
cooldown=cooldown, min_lr=min_lr, verbose=verbose)
for epoch in range(max_epoch):
for i in range(iteration):
# train(...)
optimizer.step()
optimizer.zero_grad()
if epoch == 5:
loss_value = 0.4
scheduler_lr.step(loss_value)
6、LambdaLR
lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1)
功能：自定义调整策略，可以对不同的参数组，设置不同的调整方法。
主要参数：
lr_lambda: function or list
# ------------------------------ 6 lambda ------------------------------
# flag = 0
flag = 1
if flag:
lr_init = 0.1
weights_1 = torch.randn((6, 3, 5, 5))
weights_2 = torch.ones((5, 5))
#两个参数组的优化器
optimizer = optim.SGD([
{'params': [weights_1]},
{'params': [weights_2]}], lr=lr_init)
#计算两个参数组学习率的调整方法，输入为epoch，输出为一个调整系数
lambda1 = lambda epoch: 0.1 ** (epoch // 20)
lambda2 = lambda epoch: 0.95 ** epoch
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=[lambda1, lambda2])
lr_list, epoch_list = list(), list()
for epoch in range(max_epoch):
for i in range(iteration):
# train(...)
optimizer.step()
optimizer.zero_grad()
scheduler.step()
lr_list.append(scheduler.get_lr())
epoch_list.append(epoch)
print('epoch:{:5d}, lr:{}'.format(epoch, scheduler.get_lr()))
plt.plot(epoch_list, [i[0] for i in lr_list], label="lambda 1")
plt.plot(epoch_list, [i[1] for i in lr_list], label="lambda 2")
plt.xlabel("Epoch")
plt.ylabel("Learning Rate")
plt.title("LambdaLR")
plt.legend()
plt.show()
代码调试
在206行添加断点，进行观察，
step into进入step()函数后，我们进入了_LRScheduler类，
我们跳到106行，进入self.get_lr()观察怎样得到新的学习率。base_lr会乘以一个系数，该系数是通过我们定义的lambda函数进行计算的，该函数只会接收我们的self.last_epoch,即上一次epoch的数，
运行至177行观察lambda的实现方法，接下来就进入了我们自己定义的lambda函数，来计算这个系数，
结果为下图：
565
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
