图解Pytorch学习率衰减策略（一）

写在前面

    在深度学习中，学习率是一个非常重要的超参数，它控制了模型在每次权重更新时的步长。学习率衰减策略是指在训练过程中逐步减少学习率，从而使得模型更稳定地收敛到最优解。以下是几种常见的学习率衰减方法，以及它们的使用场景和具体实现。

一、LinearLR

    线性地调整学习率。它会根据设定的初始学习率、结束学习率和训练轮数，从初始学习率逐步线性地过渡到结束学习率。这个调度器通常用于训练开始时的学习率调整，帮助模型更稳定地收敛。

示例：

import torch
import matplotlib.pyplot as plt

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

# 设置线性学习率调度器
scheduler = torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=1.0, end_factor=0.1, total_iters=20)

# 记录学习率
lrs = []

for epoch in range(20):
    # 模拟一次训练步骤
    optimizer.zero_grad()
    output = model(torch.randn(10))
    loss = output.sum()
    loss.backward()
    optimizer.step()

    # 更新学习率
    scheduler.step()

    # 打印和记录学习率
    lr = scheduler.get_last_lr()[0]
    print(f'Epoch {epoch + 1}: Learning Rate = {lr}')
    lrs.append(lr)

# 绘制学习率曲线
plt.plot(range(1, 21), lrs, marker='o')
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Schedule')
plt.grid(True)
plt.show()

参数：

    start_factor: 学习率的初始缩放因子，通常是相对于初始学习率的比例。例如，如果start_factor为1.0，学习率将保持为优化器初始学习率。
     end_factor: 学习率的最终缩放因子，表示训练结束时学习率的比例。例如，如果end_factor为0.1，最终的学习率将是初始学习率的10%。
     total_iters: 迭代的总次数，即从start_factor过渡到end_factor的周期数。在这里，我们设置为20次迭代。

学习率变化曲线：

使用场景：

    很通用的方法，能适应各种任务，但大多用在简单模型。

推荐程度：推荐，简单模型可以用。

二、StepLR

  一种简单且常用的分段衰减策略，适用于大多数模型和任务。它通过在预设的步数后按固定比例衰减学习率，帮助模型在训练的不同阶段调整优化速度。

示例：

import torch
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR
import matplotlib.pyplot as plt

# 创建一个简单的模型
class SimpleModel(torch.nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = torch.nn.Linear(10, 1)

    def forward(self, x):
        return self.fc(x)

# 初始化模型、优化器和学习率调度器
model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 初始学习率为 0.01

# StepLR 学习率调度器
scheduler = StepLR(optimizer, step_size=2, gamma=0.9)  # 每 2 个 epoch 将学习率衰减 0.1

# 模拟一个训练过程
num_epochs = 20
num_batches = 10  # 每轮训练的批次数
lr_history = []
for epoch in range(num_epochs):
    print(f"\nEpoch {epoch + 1}/{num_epochs}")

    for batch in range(num_batches):
        # 模拟前向传递
        inputs = torch.randn(64, 10)  # 批次大小 64，特征维度 10
        targets = torch.randn(64, 1)
        outputs = model(inputs)
        loss = torch.nn.functional.mse_loss(outputs, targets)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 更新学习率
    scheduler.step()

    # 打印每轮的学习率
    current_lr = optimizer.param_groups[0]['lr']
    lr_history.append(current_lr)
    print(f"End of Epoch {epoch + 1}: Current Learning Rate: {current_lr:.6f}")

# 绘制学习率曲线
plt.figure(figsize=(10, 6))
plt.plot(range(num_epochs), lr_history, marker='o')
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Schedule')
plt.grid(True)
plt.show()

参数：

    step_size: 每隔多少个 epoch 衰减一次学习率。
     gamma: 衰减系数，通常小于1。

学习率变化曲线：

使用场景：

** **适用于需要在训练过程中定期调整学习率的情况，尤其是在训练初期用较大的学习率快速收敛，后期减小学习率以细化优化的场景。在经典的卷积神经网络（CNN），如 ResNet、VGG 等，尤其在图像分类等任务中表现稳定。

推荐程度：推荐，原理简单、效果稳定。

三、MultiStepLR

    类似于 StepLR，但允许在不同 epoch 设置不同的学习率衰减点，提供更精细的控制。

示例：

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

# 定义一个简单的模型
model = nn.Linear(10, 2)

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

# 定义 MultiStepLR 学习率调度器
scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[10, 20, 30], gamma=0.1)

# 训练循环
num_epochs = 35
lr_history = []
for epoch in range(num_epochs):
    # 模拟一个训练步骤
    optimizer.zero_grad()
    outputs = model(torch.randn(5, 10))
    loss = outputs.sum()
    loss.backward()
    optimizer.step()

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

    # 调度器更新学习率
    scheduler.step()

# 绘制学习率曲线
plt.figure(figsize=(10, 6))
plt.plot(range(num_epochs), lr_history, marker='o')
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Schedule')
plt.grid(True)
plt.show()

参数：
milestones: 一个包含多个 epoch 的列表，在这些 epoch 时学习率会乘以 gamma。
gamma: 学习率衰减因子。

学习率变化曲线：

使用场景：
适用于需要在训练中进行多次学习率调整的任务，例如warmup训练或者某些特定数据集。

推荐程度：推荐，不过得把握好衰减点。

四、ExponentialLR

    ExponentialLR 的**每个 epoch **将学习率按固定的指数衰减因子 gamma 进行调整。相比于 StepLR，它的衰减更平滑，适合需要持续减小学习率的任务。

示例：

import torch
import torch.optim as optim
from torch.optim.lr_scheduler import ExponentialLR
import matplotlib.pyplot as plt

# 创建一个简单的模型
class SimpleModel(torch.nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = torch.nn.Linear(10, 1)

    def forward(self, x):
        return self.fc(x)

# 初始化模型、优化器和学习率调度器
model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.1)  # 初始学习率为 0.1

# ExponentialLR 学习率调度器
scheduler = ExponentialLR(optimizer, gamma=0.5)  # 学习率衰减因子 gamma = 0.5

# 模拟一个训练过程
num_epochs = 10
num_batches = 10  # 每轮训练的批次数
lr_history = []
for epoch in range(num_epochs):
    print(f"\nEpoch {epoch + 1}/{num_epochs}")

    for batch in range(num_batches):
        # 模拟前向传递
        inputs = torch.randn(64, 10)  # 批次大小 64，特征维度 10
        targets = torch.randn(64, 1)
        outputs = model(inputs)
        loss = torch.nn.functional.mse_loss(outputs, targets)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 更新学习率
    scheduler.step()

    # 打印每轮的学习率
    current_lr = optimizer.param_groups[0]['lr']
    lr_history.append(current_lr)
    print(f"End of Epoch {epoch + 1}: Current Learning Rate: {current_lr:.6f}")

# 绘制学习率曲线
plt.figure(figsize=(10, 6))
plt.plot(range(num_epochs), lr_history, marker='o')
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Schedule')
plt.grid(True)
plt.show()

参数：
gamma: 衰减系数，表示每个 epoch 后学习率乘以的因子。

学习率变化曲线：

使用场景：
常用于循环神经网络（RNN）及其变种（如 LSTM、GRU）。适合没有固定的衰减周期的训练过程。适合处理文本序列或时间序列数据。
推荐程度：推荐，比StepLR更平滑。

五、CosineAnnealingLR

    CosineAnnealingLR 利用余弦函数的特点，使学习率在训练过程中按照一个周期性变化的余弦曲线来衰减，即学习率从大到小再到大反复变化。通常用于长时间训练任务，能在训练后期有效避免学习率过快下降。

示例：

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

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

# 初始化CosineAnnealingLR调度器
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=20)

# 存储学习率
lrs = []

# 进行训练
for epoch in range(80):
    # 模拟训练步骤
    optimizer.step()
    scheduler.step()

    # 获取当前学习率
    current_lr = optimizer.param_groups[0]['lr']
    lrs.append(current_lr)

    # 打印学习率
    print(f'Epoch {epoch + 1}: Learning Rate = {current_lr}')

# 绘制学习率曲线
plt.plot(range(1, 81), lrs, marker='o')
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Schedule with CosineAnnealingLR')
plt.grid(True)
plt.show()

参数：
T_max: 一个周期内的最大 epoch 数。
eta_min: 最小学习率。

学习率变化曲线：

使用场景：
适用于训练需要长时间进行的大型模型，如 Transformer 模型（BERT, GPT）和计算机视觉任务中的大型 CNN。在图像分类任务中效果显著。

推荐程度：非常推荐，使用的很广泛。

六、ReduceLROnPlateau

    ReduceLROnPlateau 是基于验证集表现来调整学习率的一种方法。当模型的验证集指标（如损失）在一段时间内没有改善时，学习率会自动减小。

示例：

import torch
import torch.optim as optim
from torch.optim.lr_scheduler import ReduceLROnPlateau
import matplotlib.pyplot as plt

# 创建一个简单的模型
class SimpleModel(torch.nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = torch.nn.Linear(10, 1)

    def forward(self, x):
        return self.fc(x)

# 初始化模型、优化器和学习率调度器
model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 初始学习率为 0.01

# ReduceLROnPlateau 学习率调度器（基于验证准确度）
scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=2, verbose=True)
# ReduceLROnPlateau 学习率调度器（基于验证损失）
# scheduler_loss = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=2, verbose=True)

# 模拟一个训练过程
num_epochs = 20
num_batches = 10  # 每轮训练的批次数
lr_history = []
for epoch in range(num_epochs):
    print(f"\nEpoch {epoch + 1}/{num_epochs}")

    # 模拟训练阶段
    model.train()
    for batch in range(num_batches):
        # 模拟前向传递
        inputs = torch.randn(64, 10)  # 批次大小 64，特征维度 10
        targets = torch.randn(64, 1)
        outputs = model(inputs)
        loss = torch.nn.functional.mse_loss(outputs, targets)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 模拟验证阶段
    model.eval()
    with torch.no_grad():
        val_inputs = torch.randn(64, 10)  # 验证集的批次
        val_targets = torch.randn(64, 1)
        val_outputs = model(val_inputs)
        val_loss = torch.nn.functional.mse_loss(val_outputs, val_targets)

        # 计算准确度
        val_predictions = torch.round(val_outputs)
        accuracy = (val_predictions == val_targets).float().mean().item()

    # 更新学习率调度器（基于验证准确度）
    scheduler.step(accuracy)
    # 更新学习率调度器（基于验证损失）
    # scheduler.step(val_loss)

    # 打印每轮的学习率
    current_lr = optimizer.param_groups[0]['lr']
    lr_history.append(current_lr)
    print(f"End of Epoch {epoch + 1}: Current Learning Rate (based on accuracy): {current_lr:.6f}")

# 绘制学习率曲线
plt.figure(figsize=(10, 6))
plt.plot(range(num_epochs), lr_history, marker='o')
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Schedule')
plt.grid(True)
plt.show()

参数：
mode: ‘min’ 或 ‘max’，分别表示目标是最小化或最大化某个指标。
factor: 学习率的衰减因子。
patience: 当指定 epoch 数内指标未改善时，才进行学习率衰减。

学习率变化曲线：

使用场景：
适合在训练过程中可能遇到瓶颈的任务，如复杂的时间序列预测、GAN 训练，以及需要动态调整学习率的场景。

推荐程度：推荐，能根据模型表现自动调整学习率。

七、OneCycleLR

    根据 "1cycle" 策略，先逐步增加学习率，然后在训练的后期快速减小学习率，这种方式能在训练初期提供更快的收敛速度，同时在后期细化模型。

示例：

import torch
import torch.optim as optim
from torch.optim.lr_scheduler import OneCycleLR
import matplotlib.pyplot as plt

# 创建一个简单的模型
class SimpleModel(torch.nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = torch.nn.Linear(10, 1)

    def forward(self, x):
        return self.fc(x)

# 初始化模型、优化器和学习率调度器
model = SimpleModel()
initial_lr = 0.1
optimizer = optim.SGD(model.parameters(), lr=initial_lr)  # 初始学习率为 0.1

# OneCycleLR 学习率调度器
num_epochs = 20
num_batches = 10  # 每轮训练的批次数
max_lr = 0.1  # 最大学习率
scheduler = OneCycleLR(optimizer, max_lr=max_lr, steps_per_epoch=1, epochs=num_epochs)

# 存储学习率的历史
lr_history = []

# 模拟一个训练过程
for epoch in range(num_epochs):
    print(f"\nEpoch {epoch + 1}/{num_epochs}")

    for batch in range(num_batches):
        # 模拟前向传递
        inputs = torch.randn(64, 10)  # 批次大小 64，特征维度 10
        targets = torch.randn(64, 1)
        outputs = model(inputs)
        loss = torch.nn.functional.mse_loss(outputs, targets)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 更新学习率
    scheduler.step()

    # 记录学习率
    current_lr = optimizer.param_groups[0]['lr']
    lr_history.append(current_lr)
    print(f"End of Epoch {epoch + 1}: Current Learning Rate: {current_lr:.6f}")

# 绘制学习率曲线
plt.figure(figsize=(20, 6))
plt.plot(lr_history, marker='o')
plt.xlabel('Iteration')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Schedule with OneCycleLR')
plt.grid(True)
plt.show()

参数：

    max_lr (float or list): 每个参数组在周期内的最高学习率。

    total_steps (int): 循环的总步数。注意，如果这里是None，那么必须通过提供epochs和step_per_epoch的值来推断它。

    steps_per_epoch (int): 每个epoch要训练的步数。如果total_steps是None，则与epoch一起用来推断循环中的总步数。

    epochs：需要训练多少个时代。

学习率变化曲线：

使用场景：
适合从头开始训练的大型模型，尤其是 ResNet、Transformer 等，需要高效训练的情况下。

推荐程度：推荐，能平衡训练的前期和后期需求。

    第一部分先介绍到这里，关注不迷路(*^▽^*)

    第二部分链接：https://blog.csdn.net/xian0710830114/article/details/141096768

关注订阅号了解更多精品文章

交流探讨、商务合作请加微信