PyTorch中，动态调整学习率（Learning Rate Scheduling），也可以根据损失函数的损失数值自动调整学习率

在PyTorch中，动态调整学习率（Learning Rate Scheduling）是一种常用的技术，

用于在训练过程中根据一定的策略调整学习率，以优化模型的训练效果和收敛速度。以下是一些常见的学习率调整策略：

1. **固定步长衰减（Step Decay）**：
在训练过程中，每隔一定的epoch数，学习率会乘以一个小于1的衰减系数。

```python
import torch

scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
for epoch in range(num_epochs):
train(...)
validate(...)
scheduler.step()
```

2. **指数衰减（Exponential Decay）**：
学习率按照指数函数衰减。

```python
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9)
for epoch in range(num_epochs):
train(...)
validate(...)
scheduler.step()
```

3. **余弦退火（Cosine Annealing）**：
学习率按照余弦函数的形式进行调整，通常用于达到更好的收敛效果。

```python
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)
for epoch in range(num_epochs):
train(...)
validate(...)
scheduler.step()
```

4. **余弦退火与重启（Cosine Annealing With Warm Restarts）**：
在每次达到最小学习率后，学习率会重置到初始值，并重新开始余弦退火。

```python
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=10, T_mult=2)
for epoch in range(num_epochs):
train(...)
validate(...)
scheduler.step()
```

5. **学习率查找器（Learning Rate Finder）**：
在训练开始前，快速地遍历不同的学习率，以找到最佳的学习率范围。

```python
from torch.optim.lr_scheduler import _LRScheduler

class LRFinder(_LRScheduler):
def __init__(self, optimizer, end_lr=10, num_it=100, last_epoch=-1):
self.end_lr = end_lr
self.num_it = num_it
self.start_lr = 1e-7
super(LRFinder, self).__init__(optimizer, last_epoch)

def get_lr(self):
return [self.start_lr + (base_lr - self.start_lr) * (self.end_lr - self.start_lr) * (i / self.num_it) for i, base_lr in enumerate(self.base_lrs)]

def step(self, epoch=None):
for param_group, lr in zip(self.optimizer.param_groups, self.get_lr()):
param_group['lr'] = lr

# 使用
lr_finder = LRFinder(optimizer)
for i in range(lr_finder.num_it):
lr_finder.step()
train(...)
```

6. **自定义学习率调整**：
你也可以根据需要自定义学习率调整策略。

```python
def custom_lr(epoch):
if epoch < 10:
return 0.1
elif epoch < 20:
return 0.01
else:
return 0.001

for epoch in range(num_epochs):
current_lr = custom_lr(epoch)
for param_group in optimizer.param_groups:
param_group['lr'] = current_lr
train(...)
validate(...)
```

在实际应用中，你可以根据模型的具体情况和训练目标选择合适的学习率调整策略。记得在每次epoch结束后调用`scheduler.step()`来更新学习率。

在PyTorch中，确实可以根据损失函数的变化来动态调整学习率。

这种策略通常被称为自适应学习率调整，其中最著名的是`ReduceLROnPlateau`。这个调度器会监控一个指标（通常是验证集上的损失），如果在一定数量的epochs（`patience`参数）内该指标没有改善，学习率就会按照给定的因子（`factor`参数）进行衰减。

以下是如何使用`ReduceLROnPlateau`的一个例子：

```python
from torch.optim.lr_scheduler import ReduceLROnPlateau

# 假设optimizer是你选择的优化器
optimizer = torch.optim.Adam(model.parameters(), lr=initial_lr)

# 设置ReduceLROnPlateau调度器
scheduler = ReduceLROnPlateau(optimizer, 'min', factor=0.1, patience=10, verbose=True)

for epoch in range(num_epochs):
# 训练模型 ...

# 计算验证集上的损失
val_loss = validate(model, val_loader)

# 调用scheduler.step()并传入验证集上的损失
scheduler.step(val_loss)
```

在这个例子中，`'min'`模式表示当验证集上的损失停止下降时，学习率会降低。`factor=0.1`表示学习率会乘以0.1，`patience=10`表示如果验证集损失在连续10个epochs内没有改善，则降低学习率。

还有一些其他的学习率调整策略，如`StepLR`、`ExponentialLR`和`CosineAnnealingLR`，它们根据epoch数来调整学习率，而不是基于损失函数的变化。

但是，如果你想要更直接地根据损失函数的变化来调整学习率，`ReduceLROnPlateau`是一个很好的选择。

在实际应用中，你可能需要根据模型的具体表现和训练目标来调整`ReduceLROnPlateau`的参数，以达到最佳的训练效果。

在PyTorch中，根据模型在验证集上的表现来调整学习率的衰减因子，通常使用`ReduceLROnPlateau`调度器。这个调度器会监控一个指标（通常是验证集上的损失），如果在一定数量的epochs内该指标没有改善，学习率就会按照给定的因子进行衰减。

以下是如何使用`ReduceLROnPlateau`的一个例子：

```python
from torch.optim.lr_scheduler import ReduceLROnPlateau

# 假设optimizer是你选择的优化器
optimizer = torch.optim.Adam(model.parameters(), lr=initial_lr)

# 设置ReduceLROnPlateau调度器
scheduler = ReduceLROnPlateau(optimizer, 'min', factor=0.1, patience=10, verbose=True)

在这个例子中，`'min'`模式表示当验证集上的损失停止下降时，学习率会降低。`factor=0.1`表示学习率会乘以0.1，`patience=10`表示如果验证集损失在连续10个epochs内没有改善，则降低学习率。`verbose=True`表示会打印学习率变化的信息。

你可以根据模型的具体表现和训练目标来调整`ReduceLROnPlateau`的参数，例如`factor`和`patience`，以达到最佳的训练效果。记得在每个epoch结束后，使用验证集的损失来调用`scheduler.step()`，以便根据模型的表现动态调整学习率。

在PyTorch中，除了`ReduceLROnPlateau`之外，还有多种学习率调度器（Scheduler）可以用于根据模型在验证集上的表现来调整学习率。以下是一些推荐的调度器：

1. **StepLR**：按照给定的步数（`step_size`）逐步降低学习率，每次衰减的倍数由`gamma`参数决定。

2. **MultiStepLR**：在指定的milestones（如epoch数）降低学习率，衰减倍数由`gamma`参数决定。

3. **ExponentialLR**：按照指数衰减的方式逐步降低学习率，衰减率由`gamma`参数决定。

4. **CosineAnnealingLR**：使用余弦退火策略逐步降低学习率，模拟退火过程，使得学习率在某个周期内先减少后增加。

5. **LambdaLR**：允许用户定义一个函数，根据epoch数动态调整学习率。

6. **CyclicLR**：根据循环学习率策略调整学习率，学习率会在设定的范围内周期性变化。

7. **OneCycleLR**：根据1Cycle策略调整学习率，该策略在训练过程中先增加后减少学习率，有助于模型快速收敛。

8. **CosineAnnealingWarmRestarts**：与`CosineAnnealingLR`类似，但是会在学习率降到最低后重新开始新的周期，有助于模型跳出局部最优。

这些调度器可以根据训练过程中的不同需求和模型表现来选择使用。例如，如果模型在验证集上的损失不再显著下降，可以使用`ReduceLROnPlateau`来降低学习率，以便模型能够在更低的学习率下细致搜索最优解。而`CosineAnnealingLR`和`OneCycleLR`等策略则适用于需要周期性调整学习率的场景。

在使用这些调度器时，通常在每个epoch结束后调用`scheduler.step()`来更新学习率。如果是`ReduceLROnPlateau`，则需要传入验证集的损失值作为参数。其他调度器则根据其策略自动调整学习率，无需额外参数。

选择合适的学习率调度器并调整其参数，可以帮助模型在训练过程中更好地收敛，提高模型的性能。

在PyTorch中，自定义学习率调度器的参数通常涉及到两个方面：一是使用现有的学习率调度器（Scheduler）类并通过其提供的参数进行配置，二是创建完全自定义的学习率调度器。

### 使用现有学习率调度器的参数

PyTorch中的每个学习率调度器都提供了一系列的参数，可以通过设置这些参数来调整学习率的行为。以下是一些常见的学习率调度器及其参数的例子：

1. **StepLR**
```python
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
```

2. **MultiStepLR**
```python
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[30, 80], gamma=0.1)
```

3. **ExponentialLR**
```python
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95)
```

4. **CosineAnnealingLR**
```python
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50, eta_min=0)
```

5. **ReduceLROnPlateau**
```python
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', factor=0.1, patience=10)
```

6. **LambdaLR**
```python
lambda1 = lambda epoch: epoch // 10
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)
```

### 创建完全自定义的学习率调度器

如果现有的学习率调度器不能满足需求，可以通过继承`torch.optim.lr_scheduler._LRScheduler`基类来创建自定义的学习率调度器。自定义调度器需要重写`get_lr()`方法，该方法返回一个学习率列表，列表中的每个元素对应优化器中参数组的当前学习率。

下面是一个简单的自定义学习率调度器的例子：

```python
from torch.optim.lr_scheduler import _LRScheduler

class CustomScheduler(_LRScheduler):
def __init__(self, optimizer, my_param1, my_param2, ...):
self.my_param1 = my_param1
self.my_param2 = my_param2
# ...其他初始化代码
super(CustomScheduler, self).__init__(optimizer)

def get_lr(self):
# 根据自定义的策略计算学习率
return [self.custom_strategy(base_lr, self.last_epoch) for base_lr in self.base_lrs]

def custom_strategy(self, base_lr, epoch):
# 自定义学习率调整策略
if epoch < 10:
return base_lr * (0.1 ** self.my_param1)
else:
return base_lr * (0.1 ** self.my_param2)
```

使用自定义调度器：

```python
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
scheduler = CustomScheduler(optimizer, my_param1=2, my_param2=3)
```

在训练循环中，你需要在每个epoch结束后调用`scheduler.step()`来更新学习率。

通过自定义学习率调度器，你可以实现几乎任何你想要的学习率调整策略，为模型的训练提供更多的灵活性。

在PyTorch中，有多种学习率调度器（Scheduler）可以支持根据模型在验证集上的表现动态调整学习率。以下是一些支持这种功能的调度器：

1. **ReduceLROnPlateau**：这是一个自适应学习率调整调度器，它会在验证指标（如损失）在指定的`patience`周期内没有改善时，降低学习率。`factor`参数用于指定学习率衰减的倍数。例如，如果`factor`设置为0.1，则学习率将乘以0.1进行衰减。`mode`参数可以设置为'min'或'max'，分别对应监控指标是否停止减少或增加。

2. **LambdaLR**：这个调度器允许你定义一个函数，根据当前的epoch数动态调整学习率。你可以设计自己的衰减函数，例如指数衰减或自定义衰减策略。

3. **MultiplicativeLR**：这个调度器会乘以一个因子来调整学习率，这个因子可以在每个epoch后由你定义的函数确定。

4. **CyclicLR**：这个调度器会周期性地调整学习率，使其在设定的最小和最大值之间变化。这种策略有助于模型在训练过程中跳出局部最优。

5. **OneCycleLR**：这个调度器实现了One Cycle策略，它在一个epoch内先增加后减少学习率，有助于模型快速收敛。

6. **CosineAnnealingLR**和**CosineAnnealingWarmRestarts**：这两个调度器使用余弦退火策略来调整学习率，它们在训练过程中创建一个余弦波形的学习率变化。

使用这些调度器时，通常在每个epoch结束后调用`scheduler.step()`来更新学习率。对于`ReduceLROnPlateau`，你需要传入验证集的损失值作为参数。其他调度器则根据其策略自动调整学习率，无需额外参数。

你可以根据模型的具体表现和训练目标来选择合适的学习率调整策略。例如，如果你发现模型在验证集上的性能停滞不前，可以尝试使用`ReduceLROnPlateau`来降低学习率，以期模型能够在更低的学习率下继续学习并改善性能。

下面是转载自 https://blog.csdn.net/AI_dataloads/article/details/134127621

它们可以被分为三类：

(1)有序调整: 等间隔调整(Step)，多间隔调整(MultiStep)，指数哀减(Exponential)，余弦退火(CosineAnnealing);

(2)自适应调整: 依训练状况机而变，通过监测某个指标的变化情况(loss、accuracy)，当该指标不怎么变化时，就是调整学习率的时机(ReduceLROnPlateau);

(3)自定义调整:通过自定义关于epoch的lambda函数调整学习率(LambdaLR)。

其中，最重要的是有序调整，下面进行详细介绍：

1、等间隔调整：torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma, last_epoch=-1)

optimizer（必需参数）：这是要调整学习率的优化器对象，通常是 torch.optim.Optimizer 的一个实例。StepLR 调度器将会修改该优化器的学习率。

step_size（必需参数）：表示学习率下降的周期数。当训练周期的数量达到 step_size 的倍数时，学习率将按照 gamma 的值进行降低。例如，如果 step_size 为 30，那么学习率将在第 30、60、90，以及之后的周期进行降低。

gamma（必需参数）：衰减因子，用于指定学习率下降的倍数。在每个周期结束时，学习率将乘以 gamma 的值以降低学习率。通常，gamma 的值是小于 1 的浮点数，以降低学习率，例如，0.1 表示学习率减小为原来的 10%。

last_epoch（可选参数，默认为 -1）：这个参数表示最后一个训练周期的索引。如果不提供此参数，它会被初始化为 -1，然后在每次学习率更新后自动递增。

2、多间隔调整：torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-1)

optimizer（必需参数）：这是要调整学习率的优化器对象，通常是 torch.optim.Optimizer 的一个实例。MultiStepLR 调度器将会修改该优化器的学习率。

milestones（必需参数）：这是一个列表，其中包含了一系列训练周期的索引，学习率在这些周期结束时会降低。例如，如果 milestones 是 [30, 50, 80]，那么学习率将在第 30、50、80 个周期结束时降低。

gamma（可选参数，默认为 0.1）：衰减因子，用于指定学习率下降的倍数。在每个里程碑处，学习率将乘以 gamma 的值以降低学习率。通常，gamma 的值是小于 1 的浮点数，以降低学习率，例如，0.1 表示学习率减小为原来的 10%。

3、指数哀减：torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-1)

optimizer（必需参数）：这是要调整学习率的优化器对象，通常是 torch.optim.Optimizer 的一个实例。ExponentialLR 调度器将会修改该优化器的学习率。

gamma（必需参数）：衰减因子，用于指定学习率下降的倍数。在每个训练周期结束时，学习率将乘以 gamma 的值以降低学习率。通常，gamma 的值是小于 1 的浮点数，以降低学习率。例如，如果 gamma 为 0.9，学习率将每个周期降低为原来的 90%。

4、余弦退火：torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=0, last_epoch=-1)

optimizer（必需参数）：这是要调整学习率的优化器对象，通常是 torch.optim.Optimizer 的一个实例。CosineAnnealingLR 调度器将会修改该优化器的学习率。

T_max（必需参数）：这是一个整数，表示学习率在一个周期内变化的次数。一个完整的周期是指学习率从最大值开始下降到 eta_min（下面介绍）再上升到最大值的过程。T_max 决定了一个完整周期的长度。

eta_min（可选参数，默认为 0）：这是学习率在一个周期内的最小值，通常是一个小的非负数。学习率将在一个周期内从最大值下降到 eta_min，然后再上升到最大值。这有助于避免学习率过小，从而防止训练提前停止或陷入局部最小值。

下面就是四种有序调整函数的学习率(lr)对于训练次数(epoch)的变化曲线：

损失函数损失数值不变化到时候，应该增加学习率还是减小学习率

当损失函数的损失数值不再发生变化时，这通常意味着模型已经达到了当前学习率下的收敛状态，或者可能陷入了局部最优。在这种情况下，是否增加或减小学习率取决于你想要模型达到的效果和当前的训练阶段。以下是一些可能的策略：

1. **减小学习率**：
- 如果模型在训练集上的损失不再下降，但在验证集上的表现仍然不佳，减小学习率可能有助于模型更细致地逼近最优解，避免在最优点附近“跳跃”。
- 小的学习率可以帮助模型在当前区域进行更精细的搜索，可能有助于跳出局部最优，找到更好的全局最优解。

2. **增加学习率**：
- 如果模型在训练集上的损失不再下降，并且已经通过了充分的训练（例如，训练了很长时间或者已经收敛），增加学习率可能有助于模型跳出当前的局部最优，进行更广泛的搜索。
- 然而，增加学习率通常伴随着风险，因为过大的学习率可能导致模型训练不稳定，甚至发散。

3. **其他策略**：
- **学习率退火（Annealing）**：逐渐减小学习率，这是一种常见的策略，可以帮助模型在训练后期稳定下来。
- **学习率预热（Warmup）**：在训练初期逐渐增加学习率，然后在后期逐渐减小，这有助于模型在初期快速收敛，后期稳定下来。
- **自适应学习率调整**：使用如`ReduceLROnPlateau`这样的调度器，当验证集上的损失不再改善时，自动减小学习率。

在实际操作中，通常建议先尝试减小学习率，因为过大的学习率可能导致模型训练不稳定。如果减小学习率后模型仍然没有改善，可以考虑使用更复杂的学习率调整策略，或者检查模型架构、数据预处理等其他因素是否需要优化。此外，可以尝试使用不同的优化算法，或者引入正则化、 Dropout 等技术来提高模型的泛化能力。