文章目录
- 1、LambdaLR自定义学习率调整方式
- 2、StepLR分阶段更新学习率
- 3、MultiStepLR顶点分阶段更新学习率
- 4、ExponentialLR指数衰减更新学习率
- 5、CosineAnnealingLR余弦更新学习率
- 5、ReduceLROnPlateau自适应调整学习率
- 6、CyclicLR循环学习率
- 7、自定义学习率
- 8、完整的测试程序
1、LambdaLR自定义学习率调整方式
torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1)optimizer：优化器
lr_lambda：自定义的何时更新学习率的lambda表达式，可以是一个lambda也可以是一个lambda表达式的列表，当参数为lambda的列表是需要保证optimizer所包含的group数量和该list长度相同否则会报错。
last_epoch：最后一个更新学习率的epoch，默认为-1，一直更新
2、StepLR分阶段更新学习率
torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)optimizer：优化器
step_size：每多少个epoch更新一次学习率
gamma：学习率decay因子
last_epoch：最后一个更新学习率的epoch，默认为-1，一直更新
3、MultiStepLR顶点分阶段更新学习率
torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)optimizer：优化器
step_size：每多少个epoch更新一次学习率
milestones：需要更新学习率的epoch的列表，需要列表内的值是递增的
gamma：学习率decay因子
last_epoch：最后一个更新学习率的epoch，默认为-1，一直更新
4、ExponentialLR指数衰减更新学习率
torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1)optimizer：优化器
gamma：学习率decay因子
last_epoch：最后一个更新学习率的epoch，默认为-1，一直更新
5、CosineAnnealingLR余弦更新学习率
torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)optimizer：优化器
T_max：该余弦函数的周期
eta_min：学习率的最小值
last_epoch：最后一个更新学习率的epoch，默认为-1，一直更新
5、ReduceLROnPlateau自适应调整学习率
torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)optimizer：优化器
mode：分两种模式：min和max
- min：当网络的评价指标不再下降时更新学习率
- max：当网络的评价指标不再上升时更新学习率
factor：学习率下降因子，new_lr = base_lr * factor
patience：多少个epoch网络没有提升就会更新学习率
verbose：是否向标准输出stdout输出更新消息，True为是，False反之
threshold：衡量新的最优位置的阈值，保证不会对小规模的变化起作用
threshold_mode：分为两种模式rel和abs:
- rel-max：dynamic_threshold = best * ( 1 + threshold )
- rel-min：=max：dynamic_threshold = best * ( 1 - threshold )
- abs-max：dynamic_threshold = best + threshold
- abs-min：dynamic_threshold = best - threshold
cooldown：减少学习率之后恢复正常操作之前需要等待的epoch数
min_lr：学习率更新的下限
eps：学习率下降的最小尺度
注意：使用时和其他的学习率调整器不同需要在step中传入val loss
6、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)optimizer：优化器
base_lr：基础学习率
max_lr：学习率的上限
step_size_up：学习率上升的步数
step_size_down：学习率下降的步数
mode：三种模式:triangular，triangular2和exp_range,和之前的几个参数交互所用，如果scale_fn不是None则忽略
gamma：exp_range中的常量gamma**(cycle iterations)
scale_fn：自定义的缩放策略保证所有x>=0的情况下scale_fn(x)的值域是[0，1]
scale_mode：两种模式cycle和iterations决定scale_fn函数以何种方式作用
cycle_momentum：如果为True，则动量与’base_momentum’和’max_momentum之间的学习率成反比
base_momentum：初始动量，即每个参数组的循环中的下边界。
max_momentum：每个参数组的循环中的上动量边界。 在功能上，它定义了循环幅度（max_momentum - base_momentum）。 任何周期的动量都是max_momentum和幅度的一些比例的差异; 因此，实际上可能无法达到base_momentum，具体取决于缩放功能。
last_epoch：最后一个更新学习率的epoch，默认为-1，一直更新
7、自定义学习率
def adjust_learning_rate(optimizer, epoch, lr):
"""Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
lr = lr * (0.1 ** (epoch // 30))
for param_group in optimizer.param_groups:
param_group['lr'] = lr8、完整的测试程序
from tensorboardX import SummaryWriter
from torchvision import models
from torch.optim import SGD, lr_scheduler
import matplotlib.pyplot as plt
import numpy as np
#自定义学习率更新方式在调用step的地方调用
def adjust_learning_rate(optimizer, epoch, lr):
"""Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
lr = lr * (0.1 ** (epoch // 30))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
def lambda_lr(optimizer, epochs, gamma):
#lambda1 = lambda epoch:epochs // 100 #根据epoch计算出与lr相乘的乘数因子为epoch//10的值
#当epoch=0时，lr = lr * (0.2**0)=0.05;当epoch=1时，lr = lr * (0.2**1)=0.01
gamma = gamma * 100
lambda2 = lambda epochs:np.sin(epochs//gamma) / (epochs//gamma)
#这里的lr_lambda其实可以指定一个lambda表达式的list
return lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda2)
def step_lr(optimizer, epochs, gamma):
step_size = epochs // 6
return lr_scheduler.StepLR(optimizer,step_size=step_size,gamma = gamma)
def multi_step_lr(optimizer, epochs, gamma):
milestones = [i//50 * 50 for i in range(0, epochs, 100)]
return lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=gamma)
def exponential_lr(optimizer, epochs, gamma):
return lr_scheduler.ExponentialLR(optimizer, gamma=gamma)
def cosine_lr(optimizer, epochs, gamma):
T_max = epochs/4
eta_min = gamma / 10e5
return lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)
def reduce_lr(optimizer, epochs):
'''根据损失下降
'''
return lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)
def cyclic_lr(optimizer, epochs, gamma):
base_lr = 0.5
max_lr = 1e-8
return lr_scheduler.CyclicLR(optimizer, base_lr, max_lr, step_size_up=100, step_size_down=None, mode='triangular', gamma=gamma, scale_fn=None, scale_mode='cycle', cycle_momentum=True, base_momentum=0.8, max_momentum=0.9, last_epoch=-1)
def lr_test():
plt.figure()
lr_dict = {'lambda_lr':lambda_lr, 'step_lr':step_lr, 'multi_step_lr':multi_step_lr, 'exponential_lr':exponential_lr, 'cosine_lr':cosine_lr, 'cyclic_lr':cyclic_lr}#'reduce_lr':reduce_lr}
for key in lr_dict.keys():
desc = key
epochs = 300
model = models.alexnet()
learning_rate = 0.1
optimizer = SGD(model.parameters(), lr=learning_rate, momentum=0.9)
#scheduler = lambda_lr(optimizer, epochs)
#scheduler = step_lr(optimizer, epochs)
#scheduler = multi_step_lr(optimizer, epochs)
#scheduler = exponential_lr(optimizer, epochs)
#cheduler = cosine_lr(optimizer, epochs)
#scheduler = reduce_lr(optimizer, epochs)
#scheduler = cyclic_lr(optimizer, epochs)
for gamma in range(1, 11, 1):
scheduler = lr_dict[key](optimizer, epochs, gamma/10)
x = []
y = []
for epoch in range(epochs):
print(epoch)
scheduler.step()
lr = scheduler.get_lr()[0]
x.append(epoch)
y.append(lr)
plt.plot(x, y, label = 'gamma-' + str(gamma/10))
plt.title(key)
plt.legend()
plt.savefig(desc + '.png')
plt.show()
if __name__ == '__main__':
lr_test()
