pytorch版本的学习率调度器

已于 2024-12-11 16:05:24 修改
阅读量1.7k 收藏 31
点赞数 29
分类专栏： 课题内容-模型轻量化方向 文章标签： 学习率调度器 pytorch 深度学习 python
于 2024-12-11 15:37:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48241022/article/details/144393152
版权

前言 

学习率调度器（Learning Rate Scheduler）是深度学习中优化的一部分，用于动态调整学习率，帮助优化器更高效地找到全局最优解。PyTorch 提供了一系列学习率调度器，可以根据训练进程调整学习率。

1. 为什么使用学习率调度器？

  • 提高收敛速度：在训练早期使用较大的学习率，快速收敛。
  • 避免局部最优：动态调整学习率可以帮助优化器跳出局部最优。
  • 稳定训练：在训练后期逐步减小学习率，获得更精确的模型参数。

2. PyTorch 常用学习率调度器

以下是一些常见的学习率调度器：
1. StepLR：每隔固定的步数减少学习率。
2. MultiStepLR：在指定的步数上调整学习率。
3. ExponentialLR：指数衰减学习率。
4. CosineAnnealingLR：余弦退火调整学习率，适用于 warm restart。
5. ReduceLROnPlateau：当监控的指标停止改善时减少学习率。
6. LambdaLR：基于用户定义的函数调整学习率，灵活性高。
7. LinearLR：线性调整学习率。
8. ChainedScheduler：串联多个调度器依次运行。

3. 选择学习率调度器的技巧

  • StepLR 和 MultiStepLR：适用于预先知道学习率调整时间点的情况。
  • CosineAnnealingLR：适用于需要周期性调整学习率的任务。
  • ReduceLROnPlateau：当无法确定学习率更新时机时使用。
  • LinearLR：适用于学习率从初始值逐步增加的 warmup (热身) 过程。
  • ExponentialLR：需要平稳指数衰减时使用。

根据具体任务选择合适的调度器，配合良好的初始学习率设置，可以显著提升模型性能和训练效率。

一、LinearLR(Pytorch 1.10.0版本开始引入) 

LinearLR 是 PyTorch 的一个学习率调度器，它可以线性调整学习率，常用于训练开始时逐步增大学习率（热身阶段）。通过线性学习率调整，可以有效缓解学习率突变对模型训练的不利影响。

1.1 LinearLR 的定义

LinearLR 位于 torch.optim.lr_scheduler 模块中，使用方法如下：

torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=0.3, end_factor=1.0, total_iters=5, last_epoch=-1, verbose=False)

1.2 参数说明

  • optimizer: 优化器实例，例如 torch.optim.SGD。
  • start_factor: 学习率起始值与初始学习率的比值（默认 0.3）。
    • 如果优化器初始学习率为 lr=0.01，则 start_factor=0.3 表示学习率从 0.01 * 0.3 = 0.003 开始。
  • end_factor: 学习率结束值与初始学习率的比值（默认 1.0）。
    • 表示学习率会逐步增大到优化器的初始学习率。
  • total_iters: 学习率从 start_factor 调整到 end_factor 所需的总迭代次数。
    • 通常等于热身阶段的迭代步数。
  • last_epoch: 上一次的 epoch 值，默认为 -1，表示从头开始。
  • verbose: 是否打印每次学习率调整的信息。

1.3 使用示例

以下代码展示了如何在训练时使用 LinearLR 调度器：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import LinearLR

# 创建模型和优化器
model = nn.Linear(10, 1)
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 配置 LinearLR 调度器
warmup_epochs = 5
scheduler = LinearLR(optimizer, start_factor=0.1, end_factor=1.0, total_iters=warmup_epochs)

# 模拟训练过程
for epoch in range(10):
    # 假装训练
    optimizer.step()
    
    # 更新学习率
    scheduler.step()

    # 打印当前学习率
    current_lr = optimizer.param_groups[0]['lr']
    print(f"Epoch {epoch + 1}, Learning Rate: {current_lr:.6f}")

1.4 LinearLR 输出示例

如果优化器初始学习率为 lr=0.1，总热身迭代次数为 5，则输出类似：

Epoch 1, Learning Rate: 0.010000
Epoch 2, Learning Rate: 0.032500
Epoch 3, Learning Rate: 0.055000
Epoch 4, Learning Rate: 0.077500
Epoch 5, Learning Rate: 0.100000
Epoch 6, Learning Rate: 0.100000
...

在热身阶段（前 5 个 epoch），学习率从 0.01（即 0.1 * 0.1）线性增加到 0.1。

1.5 与其他调度器配合使用

LinearLR 通常与其他调度器（如 MultiStepLR 或 CosineAnnealingLR）结合使用，用于实现更复杂的学习率调整策略。可以通过 ChainedScheduler 将多个调度器按顺序组合成一个整体调度器。在训练过程中，它会依次应用这些调度器，每个调度器负责一定的迭代范围。

1.6 LinearLR 学习率调度器产生的学习率趋势图

由于笔者的pytorch版本为1.9.1，在这个版本的pytorch中，optim.lr_scheduler 库中没有LinearLR，因此笔者自己写了一个类似的LinearLR学习率调度器，代码如下所示：

from torch.optim import Optimizer


class CustomLinearLR:
    def __init__(self, optimizer: Optimizer, start_factor: float, end_factor: float, total_iters: int,
                 last_epoch: int = -1):
        """
        自定义线性学习率调度器。

        Args:
            optimizer (Optimizer): PyTorch优化器。
            start_factor (float): 学习率的初始比例。
            end_factor (float): 学习率的最终比例。
            total_iters (int): 线性调整的总迭代次数。
            last_epoch (int): 上一次迭代的 epoch 索引。
        """
        if total_iters <= 0:
            raise ValueError("total_iters must be greater than 0.")

        self.optimizer = optimizer
        self.start_factor = start_factor
        self.end_factor = end_factor
        self.total_iters = total_iters
        self.last_epoch = last_epoch
        self.current_factor = start_factor

        self.step()

    def get_lr(self):
        """
        根据当前迭代次数计算学习率比例。
        """
        if self.last_epoch >= self.total_iters:
            return self.end_factor

        progress = self.last_epoch / self.total_iters
        return self.start_factor + progress * (self.end_factor - self.start_factor)

    def step(self):
        """
        更新学习率。
        """
        self.last_epoch += 1
        self.current_factor = self.get_lr()

        for param_group in self.optimizer.param_groups:
            param_group['lr'] = param_group['initial_lr'] * self.current_factor


# 示例代码
if __name__ == "__main__":
    import torch
    import matplotlib.pyplot as plt

    # 模型和优化器
    model = torch.nn.Linear(10, 2)
    optimizer = torch.optim.SGD([{'params': model.parameters(), 'initial_lr': 0.1}], lr=0.1)

    # 自定义调度器
    scheduler = CustomLinearLR(optimizer, start_factor=0.1, end_factor=1.0, total_iters=10)

    # 记录学习率
    lr_values = []
    for epoch in range(20):
        scheduler.step()
        lr_values.append(optimizer.param_groups[0]['lr'])

    # 绘制学习率曲线
    plt.plot(range(1, 21), lr_values, label="Learning Rate")
    plt.xlabel("Epoch")
    plt.ylabel("Learning Rate")
    plt.title("Custom Linear Learning Rate Scheduler")
    plt.axvline(x=10, color='red', linestyle='--', label='Total Iters: 10')
    plt.legend()
    plt.show()

绘制学习率变化图如下所示： 

 

二、 ChainedScheduler (Pytorch 1.10.0版本开始引入) 

  • 假设你有两个调度器：scheduler1 和 scheduler2。
  • ChainedScheduler 会先运行 scheduler1 的调度逻辑，直到其生命周期结束；然后接着运行 scheduler2 的调度逻辑。

2.1 ChainedScheduler 举例

import torch
from torch.optim import SGD
from torch.optim.lr_scheduler import ChainedScheduler, LinearLR, StepLR

# 优化器
optimizer = SGD([torch.zeros(1)], lr=0.1)

# 两个调度器
linear_scheduler = LinearLR(optimizer, start_factor=0.1, total_iters=5)  # 第1-5步学习率线性增加
step_scheduler = StepLR(optimizer, step_size=10, gamma=0.1)  # 第6步开始，每10步学习率乘0.1

# 将两个调度器组合
scheduler = ChainedScheduler([linear_scheduler, step_scheduler])

# 模拟更新
for epoch in range(20):
    optimizer.step()
    scheduler.step()  # 按顺序调用调度器
    print(f"Epoch {epoch + 1}, LR: {optimizer.param_groups[0]['lr']:.6f}")

2.2 ChainedScheduler 运行结果说明

  • 前 5 个 epoch，LinearLR 增加学习率（从 0.01 线性增长到 0.1）。
  • 第 6 个 epoch 开始，StepLR 开始生效，每 10 个 epoch 学习率减少一次。

三、StepLR 学习率调度器 

StepLR 是 PyTorch 中的一个学习率调度器，它在训练过程中以预定的步长（epoch 数量）来调整学习率。具体来说，StepLR 会在每经过一定数量的 epochs（由 step_size 参数指定）后，按给定的衰减因子（由 gamma 参数指定）减少学习率。这个调度器适用于逐步减小学习率的场景，通常用于训练时期较长的模型。

3.1 StepLR 学习率调度器的定义及参数

定义： 

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

参数：

  • optimizer: 必须是一个优化器对象，如 torch.optim.SGD 或 torch.optim.Adam。StepLR 会根据该优化器调整其学习率。
  • step_size: 每 step_size 个 epoch 就调整一次学习率。
  • gamma: 学习率的衰减因子。每 step_size 个 epoch 后，学习率会乘以 gamma，通常取一个小于 1 的值来减小学习率。
  • last_epoch: 上一个 epoch 的索引，默认值为 -1，表示从头开始。如果指定一个值，则学习率调整会从指定的 epoch 开始，通常在继续训练时使用。
  • verbose: 如果为 True，则每次学习率更新时都会打印出新的学习率。

3.2 工作原理

  • 每经过 step_size 个 epoch，学习率就会乘以 gamma。例如，如果初始学习率为 0.1，step_size 设置为 30，gamma 设置为 0.1，那么在第 30 个 epoch 后，学习率会变为 0.1 * 0.1 = 0.01，然后在第 60 个 epoch 后会再次变为 0.01 * 0.1 = 0.001，依此类推。

 3.3 StepLR 代码示例

import torch
import torch.optim as optim

# 假设你已经有一个模型和优化器
model = ...  # 定义模型
optimizer = optim.Adam(model.parameters(), lr=0.1)

# 创建 StepLR 调度器
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

# 在训练循环中使用
for epoch in range(100):
    # 训练代码
    # ...

    # 更新学习率
    scheduler.step()
    print(f'Epoch {epoch+1}, Learning Rate: {scheduler.get_last_lr()[0]}')

3.4 适用场景

  • 适合在训练过程中需要周期性降低学习率的情况。
  • 常用于训练周期较长时，逐步减小学习率帮助模型更好地收敛。

3.5 StepLR学习率走势图

代码如下：初始学习率为0.1，step_size为30，gamma系数为0.1 ，即每经过30个epoch学习率缩小十倍，即第30个epoch时学习率变为0.01，第60个epoch时学习率变为0.001。

import torch
import torch.optim as optim
import matplotlib.pyplot as plt

# 假设有一个模型和优化器
model = torch.nn.Linear(10, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 创建 StepLR 调度器
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

# 用于记录学习率的列表
lr_values = []

# 训练过程
for epoch in range(100):
    # 假设训练代码在此处
    # 例如：模型前向传播，损失计算，反向传播等
    # optimizer.zero_grad()
    # loss.backward()
    # optimizer.step()

    # 更新学习率
    scheduler.step()

    # 记录当前学习率
    lr_values.append(scheduler.get_last_lr()[0])

# 绘制学习率曲线
plt.plot(range(1, 101), lr_values, label="Learning Rate")
plt.xlabel('Epochs')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Curve - CosineAnnealingLR')
plt.legend()
plt.show()

根据上面的代码，StepLR 学习率调度器所产生的学习率走势图如下图所示。初始学习率为0.1，在第30个epoch时，学习率缩小为原来的1/10，变为0.01；在第60个epoch时，学习率变为0.001；在第90个epoch时，学习率变为0.0001。

 

3.6 小结

StepLR 是一种非常基础的学习率调度器，它通过定期降低学习率来促进模型的优化，尤其在长时间训练时帮助避免学习率过大导致的训练不稳定。

四、CosineAnnealingLR

CosineAnnealingLR 是 PyTorch 中的一种学习率调度器，它通过余弦退火（Cosine Annealing）策略调整学习率。具体来说，它会在训练过程中逐渐降低学习率，并且该过程遵循余弦函数的形状，学习率先从初始值开始，然后逐渐降低，直到结束时接近零。 

4.1 定义及参数解释 

定义： 

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

参数：

  • optimizer: 用于更新模型参数的优化器对象（如 torch.optim.SGD 或 torch.optim.Adam）。
  • T_max: 余弦退火周期的最大迭代次数（epoch）。即一个周期后学习率会回到最小值（eta_min）。如果训练总 epoch 数为 N，T_max 可以是 N，表示在整个训练过程中一次退火。
  • eta_min: 最小学习率。学习率将在训练结束时逐渐减小到该值。默认值为 0。
  • last_epoch: 上一个 epoch 的索引，默认值为 -1，表示从头开始。如果继续训练时可以指定为最后一个 epoch 索引。
  • verbose: 如果为 True，每次学习率更新时会打印学习率信息。

4.2 工作原理

  • 学习率从初始值 lr_max 逐渐减小，遵循余弦函数的曲线：在训练过程中，学习率会按照 lr = eta_min + (lr_max - eta_min) * (1 + cos(pi * epoch / T_max)) / 2 的公式调整。
  • 训练过程中，学习率的减小速度比较平缓，最后趋近于 eta_min。

4.3 代码示例

import torch
import torch.optim as optim

# 假设有一个模型和优化器
model = torch.nn.Linear(10, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 创建 CosineAnnealingLR 调度器，设置最大周期 T_max=100
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100, eta_min=0)

for epoch in range(100):
    # 假设训练代码在此处
    # ...

    # 调用 step 更新学习率
    scheduler.step()
    print(f'Epoch {epoch+1}, Learning Rate: {scheduler.get_last_lr()[0]}')

4.4 学习率变化示意

在周期内，学习率会从初始值逐渐减少，并且变化的方式是一个平滑的余弦曲线，最终接近最小学习率 eta_min。

4.5 适用场景

  • CosineAnnealingLR 适合用于需要逐渐减小学习率并在训练过程中保持一定程度随机性的场景。
  • 特别适合当训练周期较长时，能够平滑地降低学习率，帮助模型收敛并避免早期过拟合。
  • 这种调度方式也常见于一些高级训练策略（例如，warm restarts）中，其中学习率在多个周期内循环变化。

4.6 CosineAnnealingLR 学习率走势图

绘制余弦退火学习率变化走势图，代码如下： 
在代码中，初始学习率为0.1，

import torch
import torch.optim as optim
import matplotlib.pyplot as plt

# 假设有一个模型和优化器
model = torch.nn.Linear(10, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 创建 CosineAnnealingLR 调度器，设置最大周期 T_max=100
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100, eta_min=0)

# 用于记录学习率的列表
lr_values = []

# 训练过程
for epoch in range(100):
    # 假设训练代码在此处
    # 例如：模型前向传播，损失计算，反向传播等
    # optimizer.zero_grad()
    # loss.backward()
    # optimizer.step()

    # 更新学习率
    scheduler.step()

    # 记录当前学习率
    lr_values.append(scheduler.get_last_lr()[0])

# 绘制学习率曲线
plt.plot(range(1, 101), lr_values, label="Learning Rate")
plt.xlabel('Epochs')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Curve - CosineAnnealingLR')
plt.legend()
plt.show()

 得到如下学习率变化图：(左图T_max=100，右图T_max=10)


 

4.7 小结

CosineAnnealingLR 是一种有效的学习率调度方法，特别适用于较长时间训练的任务，通过平滑的余弦退火降低学习率，帮助模型在后期训练中更精确地收敛。

五.  MultiStepLR学习率调度器

5.1 定义 

MultiStepLR 是 PyTorch 中的一个学习率调度器，允许在训练期间根据指定的里程碑 (milestones) 阶段性地调整学习率。每当达到一个里程碑时，学习率会按照一个给定的衰减因子 (gamma) 缩减。

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

5.2 参数说明

  • optimizer: 目标优化器，例如 torch.optim.SGD 或 torch.optim.Adam。
  • milestones: 一个整数列表，表示训练期间的学习率下降的时刻（epoch 数）。
  • gamma: 学习率下降的倍数，默认值为 0.1。
  • last_epoch: 上一次更新时的 epoch 数，默认值为 -1，表示从头开始。
  • verbose: 如果为 True，则在每次更新时打印学习率变化的日志。

5.3 示例代码

以下是一个使用 MultiStepLR 的完整示例，并绘制学习率随 epoch 变化的曲线：

import torch
import torch.optim as optim
import matplotlib.pyplot as plt

# 假设有一个简单模型
model = torch.nn.Linear(10, 2)

# 使用 SGD 优化器
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 定义 MultiStepLR 调度器，里程碑为 [30, 80]，学习率每次减小为原来的 0.1
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[30, 80], gamma=0.1)

# 用于记录学习率的列表
lr_values = []

# 模拟 100 个 epoch 的训练过程
for epoch in range(100):
    # 训练代码可以在这里插入
    # optimizer.zero_grad()
    # loss.backward()
    # optimizer.step()
    
    # 更新学习率
    scheduler.step()

    # 记录当前学习率
    lr_values.append(scheduler.get_last_lr()[0])

# 绘制学习率曲线
plt.plot(range(1, 101), lr_values, label="Learning Rate")
plt.xlabel('Epochs')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Curve - MultiStepLR')
plt.axvline(x=30, color='red', linestyle='--', label='Milestone: 30')
plt.axvline(x=80, color='blue', linestyle='--', label='Milestone: 80')
plt.legend()
plt.show()

5.4 代码解释

  1. 定义调度器：

    • 里程碑设置为 [30, 80]，表示在第 30 和第 80 个 epoch 时，学习率分别乘以 gamma=0.1。

  2. 记录学习率：

    • 在每个 epoch 调用 scheduler.step() 更新学习率，并使用 scheduler.get_last_lr() 记录当前学习率。

  3. 绘制曲线：

    • 使用 matplotlib 绘制从第 1 个 epoch 到第 100 个 epoch 的学习率变化。
    • 在里程碑处（30 和 80）画虚线以标注学习率变化。

5.5 输出结果

输出的图表中：

  • 初始学习率为 0.1。
  • 第 30 个 epoch 时，学习率变为 0.01（0.1 * 0.1）。
  • 第 80 个 epoch 时，学习率进一步变为 0.001（0.01 * 0.1）。
  • 其余 epoch，学习率保持不变。

5.6 适用场景

MultiStepLR 常用于以下情况：

  1. 模型训练需要在特定的 epoch 阶段减小学习率。
  2. 通过学习率衰减提高收敛速度和模型性能。
  3. 在预定义训练计划中明确标注的学习率调整步骤。
PyTorch学习率调度器的使用方法详解
CyberNova的博客
09-08 314
以示例中的milestones=[10, 20, 30]和gamma=0.1为例，在第10、20、30个训练周期之后，学习率会分别变为初始学习率的0.1倍、0.01倍、0.001倍。例如，如果step_size=10，gamma=0.1，那么在第10、20、30个训练周期之后，学习率会分别变为初始学习率的0.1倍、0.01倍、0.001倍。在上述代码中，CosineAnnealingLR调度器会在每个训练周期结束后，按照余弦函数将学习率从初始学习率衰减到最小学习率。
pytorch 21 各种学习率调度器的使用
a486259的博客
02-22 1499
pytorch内置的学习率调度在lr_scheduler包下可以使用from torch.optim import lr_scheduler。为了更直观的了解各种调度器的学习率调整过程，现将各种学习率调度器的使用和学习率曲线进行绘图。其详细的使用方法可见以下官网地址https://pytorch.org/docs/1.9.1/search.html?q=lr_scheduler&check_keywords=yes&area=default，下面只简单介绍基本的参数列表和使用方法，及其调度曲
pytorch-scheduler（调度器）
始于足下
07-26 2158
scheduler（调度器）是一种用于调整优化算法中学习率的机制。学习率是控制模型参数更新幅度的关键超参数，而调度器根据预定的策略在训练过程中动态地调整学习率。优化器负责根据损失函数的梯度更新模型的参数，而调度器则负责调整优化过程中使用的特定参数，通常是学习率。调度器通过调整学习率帮助优化器更有效地搜索参数空间，避免陷入局部最小值，并加快收敛速度。调度器允许实现复杂的训练策略，学习率预热、周期性调整或突然降低学习率，这些策略对于优化器的性能至关重要。学习率绘图函数。
pytorch优化1：学习率调度器（优化策略），用来做学习率动态调整
qq_43942192的博客
03-07 2757
优点：使用余弦函数调整学习率，可以更平滑地调整学习率，在一定程度上避免震荡。- 优点：在指定的milestones上调整学习率，相对于StepLR更灵活。- 优点：根据验证集表现自动调整学习率，能够更好地应对训练过程中的波动。- 缺点：可能不够灵活，无法根据训练过程中的表现自动调整学习率。- 缺点：可能在某些情况下过于保守，导致学习率调整不够及时。- 优点：按指数衰减调整学习率，可以更快地降低学习率。- 优点：简单易用，可以按照指定的步数调整学习率。1. StepLR：按照给定的步数调整学习率。
学习率调度器——stepLR和MultiStepLR
小小老大MUTA的博客
03-12 526
pytorch中常用的学习率调度器——stepLR 和 MultistepLR
学习率调度器（Learning Rate Scheduler）
diudiumama的博客
02-10 308
学习率调度器（Learning Rate Scheduler）是一种在训练过程中动态调整学习率的工具。学习率是优化器中的一个超参数，它决定了模型参数在每次更新时的调整步幅。合适的学习率可以加速模型收敛，而不合适的学习率可能导致训练过程不稳定或收敛速度慢。
【PyTorch】动态调整学习率 torch.optim.lr_scheduler.StepLR 调度器
码农努力学习
12-12 1830
在深度学习中，学习率调度器（Learning Rate Scheduler） 是用来动态调整学习率的工具。它的主要目的是在训练过程中自动调整学习率，以提高训练的效率和效果。之所以称其为“调度器”，是因为它控制着学习率的调整和更新，类似于调度一个过程或者任务，它按照某种策略和规则来“调度”学习率，本文将详细介绍pytorch中动态调整学习率方法之一。
pytorch调节学习率方法
qq_36402529的博客
07-04 1358
pytorch调节学习率方法 torch.optim.lr_scheduler提供了几种根据epoch调节学习率的方法。 学习率调整在optim更新后，代码形式如下 >>> scheduler = ... # 设置scheduler >>> for epoch in range(100): >>> train(...) # 训练网
学习率调度器 PyTorch 版
最新发布
04-21
学习率调度器 PyTorch 版
pytorch实现查看当前学习率
09-16
例如，`StepLR`是一个常见的学习率调度器，它会在每个预设的步长（step_size）降低学习率。以下是如何使用`StepLR`的例子： ```python scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, ...
在pytorch中动态调整优化器的学习率方式
12-17
总的来说，动态调整学习率是深度学习中优化模型性能的一个常见技巧，PyTorch提供了灵活的方式来实现这一策略，无论是通过自定义函数还是内置的学习率调度器。同时，理解并正确应用各种优化器对于构建高效的深度学习...
-学习率调度器
m0_63642362的博客
06-10 1215
学习率调度器
学习率调度器简明教程
新缸中之脑
07-03 1526
在机器学习的背景下，学习率（learning rate）是一个超参数，它决定了优化算法（如梯度下降）在尝试最小化损失函数时进行的步长。现在，让我们继续讨论学习率调度程序。学习率调度器（learning rate scheduler）是一种在训练过程中调整学习率的方法，通常会随着训练的进展而降低学习率。这有助于模型在训练开始时当参数远离其最佳值时进行大量更新，并在稍后当参数更接近其最佳值时进行较小的更新，从而允许进行更多微调。实践中广泛使用了几种学习率调度器。
Pytorch的学习率调整器
JamesZYR的博客
12-20 358
调整学习率通常与实际算法同样重要。PyTorch 提供了多种学习率调度器，每种调度器都有其独特的优点和适用场景。
计算机视觉2.16：学习率调节器
你的深度学习小站
11-05 2151
Learning Rate Scheduler 之前在cifar-10数据集上训练了MiniVGGNet网络，为了缓和过拟合，我们在应用SGD时引入了学习率decay的概念。 本片文章将讨论学习率调度器的概念，有时也称为适应性学习率，通过在不同epoch上调整学习率，我们可以降低loss，提高精确度，在某种情况写甚至可以减少训练网络的时间。 我们可以将调整学习率的过程看作： 用较高的learning rate在早期的训练过程中找到一组合理的权重。 之后用较小的learning rate慢慢的调整权重，直到
PyTorch自定义学习率调度器实现指南
deephub
09-25 4937
实现自定义学习率调度器后，下一步是将其集成到训练流程中。# 定义模型（此处使用简单的线性模型作为示例）# 初始化优化器# 初始化自定义学习率调度器# 训练循环# 在每个epoch结束时更新学习率# 记录当前学习率（用于监控）定义模型和优化器。使用之前实现的初始化学习率调度器。在每个训练epoch中：- 执行标准的前向传播、损失计算和反向传播步骤。- 调用更新模型参数。- 在epoch结束时调用更新学习率。使用获取并记录当前学习率，用于监控训练过程。
PyTorch中的学习率调度器StepLR
Python领域优质萌新学习笔记
04-08 2831
中的学习率调度器，它实现了按步长调整学习率的策略。在训练过程中，学习率调度器会根据预定义的策略调整学习率。对象作为参数传递给优化器对象，我们可以在训练过程中动态地调整学习率，以帮助模型更好地适应训练数据。，它会自动调整学习率，以使训练更加稳定和高效。是一个学习率调度器对象，它将在训练过程中根据指定的策略调整学习率。对象是用于控制优化器对象中学习率的，每当训练到一个指定的。结束后，学习率调度器会自动调整学习率。中的一个学习率调度器，可以按步长调整学习率。是两个参数，用于控制学习率的调整。，即降低一个数量级。
学习率调度器
weixin_63681863的博客
12-16 950
【代码】优化学习率调度器。
学习率调整策略 | PyTorch 深度学习实战
Chatopera
02-07 849
前一篇文章，本系列文章 GitHub Repo:本篇文章内容来自于。
学习率调度器加到yolo
12-27
### 集成学习率调度器至YOLO模型 在YOLO模型训练过程中加入并配置学习率调度器能够显著提升模型性能和稳定性。具体实现方法如下： 对于YOLO11模型而言，在定义好模型结构之后，除了加载预训练权重外，还需要特别关注优化器的选择及其参数调整策略[^1]。 #### 定义优化器与学习率调度器 通常情况下，`optimizer`负责更新网络中的权重参数；而`scheduler`则用于动态调节每次迭代时使用的实际学习率。这里以PyTorch框架为例展示如何操作： ```python import torch.optim as optim from yolox.exp import get_exp_by_name exp = get_exp_by_name('yolo11s-obb') model = exp.get_model() # 设置基础学习率为0.01 base_lr = 0.01 # 使用SGD作为优化算法，并应用动量(momentum)和平滑项(weight_decay) optimizer = optim.SGD(model.parameters(), lr=base_lr, momentum=0.9, weight_decay=5e-4) # 实现OneCycleLR调度方式，total_steps应等于总的迭代次数（epoch数量乘以每轮次的步数） scheduler = optim.lr_scheduler.OneCycleLR(optimizer, max_lr=base_lr * 6., # 最大值可设为基础学习率的倍数 total_steps=len(train_loader)*epochs, pct_start=0.3, # 初始升温比例 anneal_strategy='cos', # 调整策略为余弦退火 ) ``` 上述代码片段展示了基于`torch.optim`库创建了一个带有`OneCycleLR`策略的学习率调度机制[^4]。此策略允许学习率先线性增长再逐渐减小，有助于提高最终收敛质量的同时防止早期过度震荡。 #### 应用Warmup技术 考虑到模型初期可能存在的不稳定性问题，可以在最开始几轮训练中实施渐增式加热（warm-up），即让学习率从小数值缓慢上升到正常水平。这可以通过自定义循环来完成，也可以利用某些高级API简化过程[^3]。 ```python for epoch in range(start_epoch, epochs): for i, (images, targets) in enumerate(data_loader): optimizer.zero_grad() outputs = model(images.cuda()) loss = criterion(outputs, targets.cuda()) loss.backward() optimizer.step() scheduler.step() # 更新学习率 if warmup and epoch == start_epoch: new_lr = base_lr * ((i + 1)/len(data_loader)) ** 4 for param_group in optimizer.param_groups: param_group['lr'] = new_lr print("Training completed.") ``` 这段伪代码说明了在一个完整的训练周期内，每当处理完一批数据后都会调用一次`scheduler.step()`来进行学习率的自动调整。而在首个epoch期间，则额外加入了简单的手动控制逻辑，实现了平滑过渡的效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值