pytorch 学习率调整策略

两大类学习率调整策略

• 采用torch.optim.lr_scheduler()提供的几种衰减函数

torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1)

lr_lambda 会接收到一个int参数：epoch，然后根据epoch计算出对应的lr。如果设置多个lambda函数的话，会分别作用于Optimizer中的不同的params_group

import numpy as np 
lr_list = []
model = net()
LR = 0.01
optimizer = Adam(model.parameters(),lr = LR)
# 先定义lambda1 函数（关于epoch的函数）
lambda1 = lambda epoch:np.sin(epoch) / epoch
scheduler = lr_scheduler.LambdaLR(optimizer,lr_lambda = lambda1)
for epoch in range(100):
    scheduler.step()
    lr_list.append(optimizer.state_dict()['param_groups'][0]['lr'])
plt.plot(range(100),lr_list,color = 'r')

torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1)

以step_size 个epoch 为周期，每过一个周期，学习率 lr = lr * gamma

import torch
import torch.optim as optim
from torch.optim import lr_scheduler
from torchvision.models import AlexNet
import matplotlib.pyplot as plt
 
 
model = AlexNet(num_classes=2)
optimizer = optim.SGD(params=model.parameters(), lr=0.05)
 
# lr_scheduler.StepLR()
# 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 = lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
plt.figure()
x = list(range(100))
y = []
for epoch in range(100):
    scheduler.step()
    lr = scheduler.get_lr()
    print(epoch, scheduler.get_lr()[0])
    y.append(scheduler.get_lr()[0])
 
plt.plot(x, y)

torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)

跟StepLR, 有点相似，但是这里是一个三段式学习率，milestones 是一个二元列表，
在第一个数那个epoch，lr *= gamma ， 在第二个数那个epoch，lr *= gamma

# 可以指定区间
# lr_scheduler.MultiStepLR()
#  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
print()
plt.figure()
y.clear()
scheduler = lr_scheduler.MultiStepLR(optimizer, [30, 80], 0.1)
for epoch in range(100):
    scheduler.step()
    print(epoch, 'lr={:.6f}'.format(scheduler.get_lr()[0]))
    y.append(scheduler.get_lr()[0])
 
plt.plot(x, y)
plt.show()

torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1)

指数衰减，每个epoch中lr都乘以gamma

scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.9)
print()
plt.figure()
y.clear()
for epoch in range(100):
    scheduler.step()
    print(epoch, 'lr={:.6f}'.format(scheduler.get_lr()[0]))
    y.append(scheduler.get_lr()[0])
 
plt.plot(x, y)
plt.show()

torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)

T_max cosx 的半周期所对应的epoch数值
eta_min 为最小的lr值，默认为0

lr_list = []
model = net()
LR = 0.01
optimizer = Adam(model.parameters(),lr = LR)
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max = 20)
for epoch in range(100):
    scheduler.step()
    lr_list.append(optimizer.state_dict()['param_groups'][0]['lr'])
plt.plot(range(100),lr_list,color = 'r')

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)

在发现loss不再降低或者acc不再提高之后，降低学习率。各参数意义如下：
mode：'min’模式检测metric是否不再减小，'max’模式检测metric是否不再增大；
factor: 触发条件后lr*=factor；
patience:不再减小（或增大）的累计次数；
verbose:触发条件后print；
threshold:只关注超过阈值的显著变化；
threshold_mode:有rel和abs两种阈值计算模式，rel规则：max模式下如果超过best(1+threshold)为显著，min模式下如果低于best(1-threshold)为显著；abs规则：max模式下如果超过best+threshold为显著，min模式下如果低于best-threshold为显著；
cooldown：触发一次条件后，等待一定epoch再进行检测，避免lr下降过速；
min_lr:最小的允许lr；
eps:如果新旧lr之间的差异小与1e-8，则忽略此次更新。

• 自定义调整函数

import torch
from torch.optim import *
import torch.nn as nn
 
class net(nn.Module):
    def __init__(self):
        super(net,self).__init__()
        self.fc = nn.Linear(1,10)
    def forward(self,x):
        return self.fc(x)
 
model = net()
LR = 0.01
optimizer = Adam(model.parameters(),lr = LR)
for epoch in range(100):
    if epoch % 5 == 0:
    	# we can define any function about compute the lr
    	lr = get_lr()
    	# update for each param_groups
    	# optimizer.param_groups is equal to optimizer.state_dict()["param_groups"]
        for p in optimizer.param_groups:
            p['lr'] = lr
  

Some things about optimizer

optimizer 支持为不同参数指定不同的学习率

for example

#一般是一组
optimizer = optim.SGD(net.parameters(),lr=lr,momentum = 0.9)
#下面是多组
optimizer = optim.SGD([
                {'params': model.base.parameters()},
                {'params': model.classifier.parameters(), 'lr': 1e-3}
            ], lr=1e-2, momentum=0.9)

如上所见，传入的参数是一个列表，每个元素是一个字典，我们称其为一个组，一个组可以指定特定的学习率或者在权重衰减系数，如果不指定，将采用默认值，例如第一个group，没有指定学习率，那么它将采用默认值lr = 1e-2， 而第二个组将采用指定的1e-3.
注意字典的key 一定是‘params’，而 学习率的key则是‘lr’。

optimizer.state_dict()

返回一个状态字典
state_dict ={
“state” : { } -> dict,
“param_groups”:[ {}, {}]
}
一个状态字典，一个参数组列表