pytorch常用的学习率设置方式

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'] = lr

8、完整的测试程序

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()