【深度学习】学习率策略合集

已于 2022-03-16 17:10:59 修改
阅读量5.2k 收藏 69
点赞数 13
分类专栏： 深度学习 机器学习 python
于 2022-03-16 17:06:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40035462/article/details/123512727
版权

学习率 PyTorch PaddlePaddle 策略 模型训练
关键词由CSDN通过智能技术生成
深度学习 同时被 3 个专栏收录
88 篇文章 29 订阅
订阅专栏
python
11 篇文章 0 订阅
订阅专栏
机器学习
7 篇文章 0 订阅
订阅专栏

深度学习中有各种学习率策略，本文统计了pytorch和paddlepaddle共16种学习率策略，给出示例代码及对应的学习率变化图，相信一定对你有所帮助。

目录

一、LambdaLR

二、MultiplicativeLR

三、StepLR

四、MultiStepLR

五、ConstantLR

六、LinearLR

七、ExponentialLR

八、CosineAnnealingLR

九、CosineAnnealingWarmRestarts

十、CyclicLR

十一、ReduceLROnPlateau

十二、InverseTimeDecay

十三、PolynomialDecay

十四：PiecewiseDecay

十五、NoamDecay

十六、LinearWarmup

参考

一、LambdaLR

LambdaLR初始化时需要一个传入一个lambda函数，学习率等于初始学习率乘该函数的返回值。

lr=lr\_init*function\_return\_value

代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
lambda1 = lambda epoch: epoch // 30
lambda2 = lambda epoch: 0.95 ** epoch
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer=optimizer, lr_lambda=[lambda1])
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

效果：

二、MultiplicativeLR

LambdaLR初始化时需要一个传入一个lambda函数，学习率等于上一步学习率乘该函数的返回值。

lr_{i+1}=lr_{i}*function\_return\_value

代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
lambda1 = lambda epoch: 0.9
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.MultiplicativeLR(optimizer=optimizer, lr_lambda=[lambda1])
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    print(scheduler.get_last_lr())
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

效果：

三、StepLR

StepLR需要设置学习率衰减的步长step_size，每过step_size，学习率等于上一步的学习率乘衰减因子。

lr_{i+1} = lr_{i}*(epoch//step\_size)

代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer=optimizer, step_size=10, gamma=0.9)
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

效果：

四、MultiStepLR

MultiStepLR需要设定学习率衰减的步长列表，达到一定步长后学习率衰减，和StepLR不同的是每次衰减的步长是自己设定的（StepLR衰减步长固定）。

lr_{i+1} = lr_{i}*(epoch//step\_size_{i})

代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer=optimizer, milestones=[10, 50, 80], gamma=0.9)
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

效果：

五、ConstantLR

ConstantLR需要设定步长和衰减因子，在到达设定步长前，学习率等于初始学习率乘以该因子。

lr=\begin{cases} & \text lr*factor \ \ \ \ \ { if } \ epoch<total\_iters \\ & \text lr \ \ \ \ \ \ { if }\ epoch\geq total\_iters \end{cases}

代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.ConstantLR(optimizer=optimizer, factor=0.5, total_iters=10)
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

效果：

六、LinearLR

LinearLR需要设定步长和衰减因子的变化范围，随着步长变化，衰减因子也动态变化。

lr=\begin{cases} & \text lr*(\frac{end\_factor-beg\_factor}{total\_iters}*epoch+beg\_factor)\ \ \ \ \ { if } \ epoch<total\_iters \\ & \text lr \ \ \ \ \ \ { if }\ epoch\geq total\_iters \end{cases}

代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.LinearLR(optimizer=optimizer, start_factor=0.5, end_factor=1.0, total_iters=20)
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    print(scheduler.get_last_lr())
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

 效果：

七、ExponentialLR

ExponentialLR只需要传入衰减因子，学习率每轮epoch衰减。

lr=lr\_init*gamma^{epoch}

代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer=optimizer, gamma=0.9)
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    print(scheduler.get_last_lr())
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

效果：

八、CosineAnnealingLR

CosineAnnealingLR是余弦退火学习率策略，学习率周期性变化，对于一般的学习率单调衰减策略，很有可能会使网络停留在局部最优无法走出来，余弦退火学习率周期性变化，能够走出局部最优。

代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer=optimizer, T_max=20, eta_min=0.001)
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    print(scheduler.get_last_lr())
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

效果：

九、CosineAnnealingWarmRestarts

CosineAnnealingWarmRestarts和CosineAnnealingLR的不同在于，学习率上升变化是突变的，并且cos衰减周期是变化的。CosineAnnealingWarmRestarts接受2个和周期相关的参数：T_0和T_mult，第一次衰减的周期为T_0，第二次为T*T_mult，第三次为T*T_mult*T_mult，依次类推。

 代码：

import torch
import matplotlib.pyplot as plt


epoches = 100
learning_rate = 0.1
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer=optimizer, T_0=10, T_mult=2, eta_min=0.001)
e = [i for i in range(epoches)]
lrs = []
for epoch in range(100):
    optimizer.step()
    scheduler.step()
    print(scheduler.get_last_lr())
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

效果：

十、CyclicLR

CyclicLR是循环学习率策略，学习率根据设定的步长循环变化，该学习率应该跟随iteration变化，有3种模式：

triangular：三角形变化，无缩放

triangular2：三角形变化，每次循环学习率减半

exp_range：学习率周期变化的同时乘上缩放系数gamma^{iterations}（gamma为1时和triangular策略相同）

triangular代码：

import torch
import matplotlib.pyplot as plt


iterations = 1000
learning_rate = 0.01
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.CyclicLR(
    optimizer=optimizer,
    base_lr=0.001,
    max_lr=0.1,
    step_size_up=100,
    step_size_down=None,
    mode='triangular',
    gamma=0.9,
    scale_fn=None,
)
e = [i for i in range(iterations)]
lrs = []
for epoch in range(iterations):
    optimizer.step()
    scheduler.step()
    print(scheduler.get_last_lr())
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

 triangular效果：

triangular2代码：

import torch
import matplotlib.pyplot as plt


iterations = 1000
learning_rate = 0.01
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.CyclicLR(
    optimizer=optimizer,
    base_lr=0.001,
    max_lr=0.1,
    step_size_up=100,
    step_size_down=None,
    mode='triangular2',
    gamma=0.9,
    scale_fn=None,
)
e = [i for i in range(iterations)]
lrs = []
for epoch in range(iterations):
    optimizer.step()
    scheduler.step()
    print(scheduler.get_last_lr())
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

triangular2效果：

exp_range代码：

import torch
import matplotlib.pyplot as plt


iterations = 1000
learning_rate = 0.01
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = torch.optim.SGD(model, learning_rate)
scheduler = torch.optim.lr_scheduler.CyclicLR(
    optimizer=optimizer,
    base_lr=0.001,
    max_lr=0.1,
    step_size_up=100,
    step_size_down=None,
    mode='exp_range',
    gamma=0.99,
    scale_fn=None,
)
e = [i for i in range(iterations)]
lrs = []
for epoch in range(iterations):
    optimizer.step()
    scheduler.step()
    print(scheduler.get_last_lr())
    lrs.append(scheduler.get_last_lr())

plt.plot(e, lrs)
plt.show()

exp_range效果：

十一、ReduceLROnPlateau

loss 自适应的学习率衰减策略。默认情况下，当 loss 停止下降时，降低学习率。其思想是：一旦模型表现不再提升，将学习率降低2-10倍对模型的训练往往有益。

如果 loss 停止下降超过 patience 个epoch，学习率将会衰减为 learning_rate * factor。

此外，每降低一次学习率后，将会进入一个时长为 cooldown 个epoch的冷静期，在冷静期内，将不会监控 loss 的变化情况，也不会衰减。 在冷静期之后，会继续监控 loss 的上升或下降。

十二、InverseTimeDecay

InverseTimeDecay是逆时间衰减学习率策略，即学习率和衰减次数成反比。

代码：

import paddle
import matplotlib.pyplot as plt

epoches = 100
learning_rate = 0.1
linear = paddle.nn.Linear(10, 10)
scheduler = paddle.optimizer.lr.InverseTimeDecay(learning_rate=learning_rate, gamma=0.1, verbose=True)
sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameters=linear.parameters())
x = [i for i in range(epoches)]
lrs = []
for epoch in range(epoches):
    scheduler.step()
    lrs.append(scheduler.get_lr())

plt.plot(x, lrs)
plt.show()

 效果：

十三、PolynomialDecay

PolynomialDecay是多项式学习率衰减策略，他有2种模式，一种是学习率下降至最低后不变，一种是学习率下降至最低后再次上升（有益于脱离局部最优）。

1、学习率不上升

 代码：

import paddle
import matplotlib.pyplot as plt

epoches = 100
learning_rate = 0.1
linear = paddle.nn.Linear(10, 10)
scheduler = paddle.optimizer.lr.PolynomialDecay(learning_rate=learning_rate, decay_steps=50, end_lr=0, power=2, cycle=False)
sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameters=linear.parameters())
x = [i for i in range(epoches)]
lrs = []
for epoch in range(epoches):
    scheduler.step()
    lrs.append(scheduler.get_lr())

plt.plot(x, lrs)
plt.show()

效果：

 2、学习率上升

 代码：

import paddle
import matplotlib.pyplot as plt

epoches = 100
learning_rate = 0.1
linear = paddle.nn.Linear(10, 10)
scheduler = paddle.optimizer.lr.PolynomialDecay(learning_rate=learning_rate, decay_steps=30, end_lr=0, power=2, cycle=True)
sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameters=linear.parameters())
x = [i for i in range(epoches)]
lrs = []
for epoch in range(epoches):
    scheduler.step()
    lrs.append(scheduler.get_lr())

plt.plot(x, lrs)
plt.show()

效果：

十四：PiecewiseDecay

PiecewiseDecay策略是在指定epoch内的学习率。

代码：

import paddle
import matplotlib.pyplot as plt

epoches = 100
linear = paddle.nn.Linear(10, 10)
scheduler = paddle.optimizer.lr.PiecewiseDecay(boundaries=[30, 60], values=[0.1, 0.05, 0.01])
sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameters=linear.parameters())
x = [i for i in range(epoches)]
lrs = []
for epoch in range(epoches):
    scheduler.step()
    lrs.append(scheduler.get_lr())

plt.plot(x, lrs)
plt.show()

效果：

十五、NoamDecay

NoamDecay策略，公式如下（d_{model}为输入或者输出的维度）：

 代码：

import paddle
import matplotlib.pyplot as plt

epoches = 100
linear = paddle.nn.Linear(10, 10)
scheduler = paddle.optimizer.lr.NoamDecay(d_model=100, warmup_steps=20, learning_rate=0.1)
sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameters=linear.parameters())
x = [i for i in range(epoches)]
lrs = []
for epoch in range(epoches):
    scheduler.step()
    lrs.append(scheduler.get_lr())

plt.plot(x, lrs)
plt.show()

效果：

十六、LinearWarmup

LinearWarmup线性学习率热身策略，先以较低的学习率开始训练，学习率慢慢提升至设定值后按照正常的衰减策略衰减。

当训练步数小于热身步数（warmup_steps）时，学习率lr按如下方式更新：

 当训练步数大于等于热身步数（warmup_steps）时，学习率lr为：

代码：

import paddle
import matplotlib.pyplot as plt

epoches = 100
linear = paddle.nn.Linear(10, 10)
scheduler = paddle.optimizer.lr.LinearWarmup(learning_rate=0.1, warmup_steps=10, start_lr=0.01, end_lr=0.1)
sgd = paddle.optimizer.SGD(learning_rate=scheduler, parameters=linear.parameters())
x = [i for i in range(epoches)]
lrs = []
for epoch in range(epoches):
    scheduler.step()
    lrs.append(scheduler.get_lr())

plt.plot(x, lrs)
plt.show()

效果：

参考

torch.optim — PyTorch 1.11.0 documentation

API 文档-API文档-PaddlePaddle深度学习平台

所有示例代码：各类学习率策略示例代码

justld
关注
专栏目录
ddp 多卡训练torch 记录
andy dennis的博客
07-13 1210
之前一直拿别人的开源代码改，最近需要自己从头写，实验需要多卡训练，于是就记录一下。
深度学习tricks——学习率策略
Peach_____的博客
01-31 542
【代码】深度学习tricks——学习率策略。
MultiStepLR
最新发布
weixin_44012667的博客
07-21 422
是 PyTorch 提供的一种学习率调度器，用于在训练过程中按指定的里程碑（milestones）调整优化器的学习率。它允许在训练的不同阶段逐步降低学习率，从而帮助模型在接近局部最优解时更稳定地收敛。
深度学习之----各种学习策略
zxyhhjs2017的博客
05-06 1392
https://blog.csdn.net/tsyccnh/article/details/76270707
学习率优化策略
dididi的博客
06-22 715
Warmup 策略 深度学习中, 模型的初始权重是在训练启动阶段随机生成的, 选择 Warmup 策略可以使模型在训练初期使用较小的学 习率进行训练, 经过设定的一定数量的迭代次数, 模型趋向稳定后, 再改为预先设定的学习率, 达到预热学习率的效果, 可以防止模型震荡, 加速网络收敛速度, 提升效果. 实验中使用 Warmup 策略中的 Gradual Warmup, 即在学习率预热阶段中学习率随着迭代次数增加也逐步提高, 直到预热阶段结束时学习率达到预设定值, 再进行后续训练, 这样能够避免学习率突然增
学习率调整策略
Kelly_Ai_Bai的博客
12-23 1747
学习率调整策略
一种组合型的深度学习模型学习率策略.pdf
08-19
《一种组合型的深度学习模型学习率策略》 在深度学习领域，学习率策略是优化模型性能的关键因素之一。良好的学习率策略能显著提升深度学习模型的收敛速度，从而缩短训练时间并提高模型的准确度。传统的学习率策略，...
深度学习各类学习率调整策略示例代码
03-16
1. **Cyclic Learning Rates (cycliclr.py)**：由Leslie Smith提出的周期性学习率策略，通过在两个预设的学习率边界之间周期性地变化学习率来提高训练效率。这种方法可以避免在训练过程中手动调整学习率，简化了训练...
一种改进的深度学习模型自适应学习率策略.pdf
08-19
在深度学习模型训练中，学习率的设定是一个关键的超参数，它直接影响到模型...随着深度学习技术的不断进步和应用领域的扩大，这种自适应学习率策略有望在更多实际问题中得到应用，并为深度学习模型的优化提供有力支持。
深度学习：学习率规划-余弦退火CosineAnnealing和WarmRestart原理及实现 深度学习原理.pdf
04-13
深度学习：学习率规划-余弦退火CosineAnnealing和WarmRestart原理及实现 深度学习中的学习率规划是指在模型训练过程中，适时地调整学习率，以达到更好的模型收敛和泛化能力。其中，余弦退火CosineAnnealing和...
PyTorch深度学习实战（9）——学习率优化
盼小辉丶的博客
08-06 2230
学习率( learning rate )是神经网络训练中一个重要的超参数，用于控制模型更新参数的步长大小，它决定了每次迭代中模型参数更新的幅度。学习率的选择对于训练的结果具有重要影响，学习率过高会导致模型震荡不收敛甚至发散，无法有效优化目标函数；而学习率过低则会导致收敛速度缓慢，需要更多的迭代才能达到较好的效果。本节首先介绍学习率如何影响模型训练，并通过修改学习率观察不同学习率对模型性能的影响。
略解深度学习优化策略
from top to bottom
06-06 819
常见的优化算法：SGD和Adam梯度的简单解释：梯度可以理解为函数的导数，也可理解为函数的倾斜程度。函数图像水平时，函数的梯度消失。凸函数：深度学习中出现的几乎所有优化问题都是非凸的。下面是对凸（convex）和非凸的一个介绍。 由上图可以找到明显的规律是，第一个图形和后两个图形的明显区别，第一张图中的点线段部分出现在了图形外，而后两张线段都被包含在了图形内部。前者是非凸，后者是凸。继续看下面的图形。上面三张图形，中间的是非凸函数，两边的是凸函数，具体来说就是函数上的任意两点连线的线段中间的点的纵坐标大于或
深度学习中学习率调整策略总结
shengweiit的博客
05-12 3923
lr_scheduler.LambdaLR的优点是可以根据自定义的函数来调整学习率，灵活性比较高。可以根据具体任务和模型的需求来选择合适的函数，以提高模型的性能。缺点是需要自己定义函数，可能需要一定的数学知识和经验。此外，如果函数定义不合理，可能会导致模型在训练过程中出现震荡或过拟合的情况。因此，在使用LambdaLR时，需要根据具体情况进行调整，以达到最佳效果。
小白笔记：对学习率（Learning rate）本质与更新策略的理解
m0_73798143的博客
03-06 2794
小白笔记：学习率的概念、本质及其更新策略
pytorch08：学习率调整策略
慕溪同学的博客
01-05 1578
我们可以设置学习率逐渐从小变大观察精确度的一个变化，下面这幅图，当学习率为0.055左右的时候模型精确度最高，当学习率大于0.055的时候精确度出现下降情况，所以在模型训练过程中我们可以设置学习率为0.055作为我们的初始学习率。一般在模型训练过程中，在开始训练的时候我们会设置学习率大一些，随着模型训练epoch的增加，学习率会逐渐设置小一些。功能：监控指标，当指标不再变化则调整，例如：可以监控我们的loss或者准确率，当其不发生变化的时候，调整学习率。调整方式：lr = lr * gamma。
史上最全学习率调整策略lr_scheduler
热门推荐
weiman1的博客
07-06 1万+
学习率是深度学习训练中至关重要的参数，很多时候一个合适的学习率才能发挥出模型的较大潜力。所以学习率调整策略同样至关重要，这篇博客介绍一下Pytorch中常见的学习率调整方法。
pytorch 常用5种学习率策略
weixin_45461433的博客
03-02 391
固定步长衰减策略 参数 step_szie:表示每隔多少个步长修改一次(训练的时候表示每隔多少个epoch修改一次) gamma:0.1 表示每一次修改采用 lr_new = lr_old * gamma optimizer = torch.optim.SGD(model.parameters(), lr=0.01) scheduler_StepLR = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.9) 多步长衰减策
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

justld

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值