pytorch日积月累11-学习率

先使用大学习率后使用小学习率。

基类：class _LRScheduler

  • optimizer：关联的优化器
  • last_epoch：记录epoch数
  • base_lrs：记录初始学习率

主要方法：

  • step()：更新下一个epoch的学习率
  • get_lr()：虚函数，计算下一个epoch的学习率
1
2
3
4
class _LRScheduler(object):
    def __init__(self, optimizer, last_epoch=-1):
    def get_lr(self):
        raise NotImplementedError

六种学习率调整策略：

1.StepLR

1
2
3
4
5
#等间隔调整学习率
lr_scheduler.StepLR(optimizer, 
                    step_size, #调整间隔数
                    gamma=0.1, #调整系数
                    last_epoch=-1)

2.MultiStepLR

功能：按给定间隔调整学习率

1
2
3
4
lr_scheduler.MultiStepLR(optimizer, 
                         milestones,#设定调整时刻数 
                         gamma=0.1, 
                         last_epoch=-1)

3.ExponentialLR

功能：按照指数衰减调整学习率

1
2
3
lr_scheduler.ExponentialLR(optimizer, 
                           gamma, #指数的底
                           last_epoch=-1)

4.CosineAnnealingLR

功能：余弦周期调整学习率

1
2
3
4
lr_scheduler.CosineAnnealingLR(optimizer, 
                               T_max, #下降周期
                               eta_min=0, #学习率下限
                               last_epoch=-1)

5.ReduceLROnPlateau

功能：监控指标，当指标不再变化则调整

1
2
3
4
5
6
7
8
9
10
lr_scheduler.ReduceLROnPlateau(optimizer, 
                               mode='min',#模式 min/max模式 
                               factor=0.1, #调整系数
                               patience=10, #“耐心”，接受几次没变化
                               verbose=False, #是否打印日志
                               threshold=0.0001, 
                               threshold_mode='rel', 
                               cooldown=0, #冷却时间
                               min_lr=0, #设置学习率下限
                               eps=1e-08)#学习率衰减最小值

6.LambdaLR

功能：自定义调整策略

1
2
3
lr_scheduler.LambdaLR(optimizer, 
                      lr_lambda,#lr_lambda：function or list 
                      last_epoch=-1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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)
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()))

学习率调整小结

有序调整：Step、MultiStep、Exponential 和 CosineAnnealing

自适应调整：ReduceLROnPleateau

自定义调整：Lambda