# 优化

`.optimization` 模块提供：

- 一种权重衰减固定的优化器，可用于微调模型，以及
- 多个以继承自 `_LRSchedule` 的调度对象形式存在的调度：
- 一个梯度累积类，用于累积多个批次的梯度

## AdaFactor[[transformers.Adafactor]]

#### transformers.Adafactor[[transformers.Adafactor]]

```python
transformers.Adafactor(params, lr = None, eps = (1e-30, 0.001), clip_threshold = 1.0, decay_rate = -0.8, beta1 = None, weight_decay = 0.0, scale_parameter = True, relative_step = True, warmup_init = False)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L1057)

**参数：**

params (`Iterable[nn.parameter.Parameter]`) : 要优化的参数迭代器，或定义参数组的字典。

lr (`float`, *可选*) : 外部学习率。

eps (`tuple[float, float]`，*可选*，默认为 `(1e-30, 0.001)`)：分别用于平方梯度和参数尺度的正则化常数

clip_threshold (`float`，*可选*，默认值为 1.0)：最终梯度更新的均方根阈值

decay_rate (`float`，*可选*，默认值为 -0.8)：用于计算平方运行平均值的系数

beta1 (`float`, *可选*) : 用于计算梯度移动平均的系数

weight_decay (`float`，*可选*，默认值为 0.0)：权重衰减（L2 惩罚）

scale_parameter (`bool`，*可选*，默认为 `True`)：如果为 True，学习率将按均方根进行缩放

relative_step (`bool`，*可选*，默认为 `True`)：如果为 True，则计算基于时间的学习率，而不是使用外部学习率

warmup_init (`bool`，*可选*，默认为 `False`)：时间相关的学习率计算取决于是否使用预热初始化

AdaFactor 的 PyTorch 实现可以直接替换 Adam，原始 fairseq 代码：https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py

论文：*Adafactor: Adaptive Learning Rates with Sublinear Memory Cost* https://huggingface.co/papers/1804.04235 请注意，该优化器会根据 `scale_parameter`、`relative_step` 和 `warmup_init` 选项在内部调整学习率。若要使用手动（外部）学习率调度，应设置 `scale_parameter=False` 和 `relative_step=False`。

此实现支持低精度（FP16、bfloat）值，但我们尚未对其进行充分测试。

推荐的 T5 微调设置（/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Ft5-finetuning-tips%2F684%2F3%EF%BC%89%EF%BC%9A

- 不建议在不使用 LR warmup 或 clip_threshold 的情况下进行训练。

  - 使用计划好的学习率预热至固定学习率
  - 使用 clip_threshold=1.0（https://huggingface.co/papers/1804.04235）
- 禁用相对更新
- 使用 scale_parameter=False
- 诸如梯度裁剪之类的额外优化器操作不应与 Adafactor 同时使用

示例：

```python
Adafactor(model.parameters(), scale_parameter=False, relative_step=False, warmup_init=False, lr=1e-3)
```

其他人报告了以下组合效果良好：

```python
Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
```

使用 [Trainer](/docs/transformers/v5.23.0/zh/main_classes/trainer#transformers.Trainer) 时，如果设置 `lr=None`，通常需要使用 `AdafactorSchedule`。

调度器如下：

```python
from transformers.optimization import Adafactor, AdafactorSchedule

optimizer = Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
lr_scheduler = AdafactorSchedule(optimizer)
trainer = Trainer(..., optimizers=(optimizer, lr_scheduler))
```

用法：

```python
# replace AdamW with Adafactor
optimizer = Adafactor(
    model.parameters(),
    lr=1e-3,
    eps=(1e-30, 1e-3),
    clip_threshold=1.0,
    decay_rate=-0.8,
    beta1=None,
    weight_decay=0.0,
    relative_step=False,
    scale_parameter=False,
    warmup_init=False,
)
```

#### 步骤[[transformers.Adafactor.step]]

```python
step(closure = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L1202)

**参数：**

closure (callable, 可选)：一个闭包，用于重新评估模型并返回损失。

执行单个优化步骤

## 计划

### SchedulerType[[transformers.SchedulerType]]

#### transformers.SchedulerType[[transformers.SchedulerType]]

```python
transformers.SchedulerType(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_utils.py#L561)

`lr_scheduler_type` 参数在 [TrainingArguments](/docs/transformers/v5.23.0/zh/main_classes/trainer#transformers.TrainingArguments) 中可用的调度器名称。默认使用 "linear"。内部实现中，[Trainer](/docs/transformers/v5.23.0/zh/main_classes/trainer#transformers.Trainer) 会获取 `get_linear_schedule_with_warmup` 调度器。调度器类型：
- "线性" = [get_linear_schedule_with_warmup()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup)
- "cosine" = [get_cosine_schedule_with_warmup()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_cosine_schedule_with_warmup)
- "cosine_with_restarts" = [get_cosine_with_hard_restarts_schedule_with_warmup()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_cosine_with_hard_restarts_schedule_with_warmup)
- "polynomial" = [get_polynomial_decay_schedule_with_warmup()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_polynomial_decay_schedule_with_warmup)
- "constant" =  [get_constant_schedule()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_constant_schedule)
- "constant_with_warmup" = [get_constant_schedule_with_warmup()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_constant_schedule_with_warmup)
- "inverse_sqrt" = [get_inverse_sqrt_schedule()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_inverse_sqrt_schedule)
- "reduce_lr_on_plateau" = [get_reduce_on_plateau_schedule()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_reduce_on_plateau_schedule)
- "cosine_with_min_lr" = [get_cosine_with_min_lr_schedule_with_warmup()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_cosine_with_min_lr_schedule_with_warmup)
- "cosine_warmup_with_min_lr" = [get_cosine_with_min_lr_schedule_with_warmup_lr_rate()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate)
- "warmup_stable_decay" = [get_wsd_schedule()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_wsd_schedule)
- "greedy" = [get_greedy_schedule()](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.get_greedy_schedule)

### get_scheduler[[transformers.get_scheduler]]

#### transformers.get_scheduler[[transformers.get_scheduler]]

```python
transformers.get_scheduler(name: str | SchedulerType, optimizer: Optimizer, num_warmup_steps: int | None = None, num_training_steps: int | None = None, scheduler_specific_kwargs: dict | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L960)

**参数：**

name (`str` 或 `SchedulerType`)：要使用的调度器名称。

optimizer (`torch.optim.Optimizer`)：训练期间将使用的优化器。

num_warmup_steps (`int`, *可选*) : 预热步数。并非所有调度器都需要此参数（因此该参数为可选），如果未设置且调度器类型要求该参数，函数将抛出错误。

num_training_steps (`int``, *可选*)：要执行的训练步数。并非所有调度器都需要此参数（因此该参数为可选），如果未设置且调度器类型要求该参数，函数将抛出错误。

scheduler_specific_kwargs (`dict`, *可选*) : 用于 cosine with restarts 等调度器的额外参数。调度器类型与调度器参数不匹配会导致调度器函数抛出 TypeError。

统一 API，用于根据名称获取任意调度器。

### get_constant_schedule[[transformers.get_constant_schedule]]

#### transformers.get_constant_schedule[[transformers.get_constant_schedule]]

```python
transformers.get_constant_schedule(optimizer: Optimizer, last_epoch: int = -1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L39)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

使用优化器中设置的学习率，创建一个恒定学习率的调度器。

### get_constant_schedule_with_warmup[[transformers.get_constant_schedule_with_warmup]]

#### transformers.get_constant_schedule_with_warmup[[transformers.get_constant_schedule_with_warmup]]

```python
transformers.get_constant_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, last_epoch: int = -1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L80)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个学习率调度器，其学习率保持恒定，但在之前有一个预热阶段，在该阶段中，学习率从 0 线性增加到在优化器中设置的初始学习率。

### get_cosine_schedule_with_warmup[[transformers.get_cosine_schedule_with_warmup]]

#### transformers.get_cosine_schedule_with_warmup[[transformers.get_cosine_schedule_with_warmup]]

```python
transformers.get_cosine_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L143)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

num_training_steps (`int`) : 训练步数的总数。

num_cycles (`float`，*可选*，默认值为 0.5)：余弦调度中的波数（默认行为是遵循半余弦曲线，从最大值递减至 0）。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个学习率调度器，其学习率经过一个预热阶段后，按照余弦函数的值从优化器中设置的初始学习率衰减至 0；在预热阶段内，学习率从 0 线性增加至优化器中设置的初始学习率。

### get_cosine_with_hard_restarts_schedule_with_warmup[[transformers.get_cosine_with_hard_restarts_schedule_with_warmup]]

#### transformers.get_cosine_with_hard_restarts_schedule_with_warmup[[transformers.get_cosine_with_hard_restarts_schedule_with_warmup]]

```python
transformers.get_cosine_with_hard_restarts_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: int = 1, last_epoch: int = -1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L188)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

num_training_steps (`int`) : 训练步数的总数。

num_cycles (`int`，*可选*，默认为 1)：要使用的硬重启次数。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个学习率调度器，在预热阶段，学习率从 0 线性增加到优化器中设置的初始学习率；随后，学习率按照余弦函数的值，从优化器中设置的初始学习率衰减至 0，并包含多次硬重启。

### get_cosine_with_min_lr_schedule_with_warmup[[transformers.get_cosine_with_min_lr_schedule_with_warmup]]

#### transformers.get_cosine_with_min_lr_schedule_with_warmup[[transformers.get_cosine_with_min_lr_schedule_with_warmup]]

```python
transformers.get_cosine_with_min_lr_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1, min_lr: float | None = None, min_lr_rate: float | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L337)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

num_training_steps (`int`) : 训练步数的总数。

num_cycles (`float`，*可选*，默认值为 0.5)：余弦调度中的波数（默认行为是遵循半余弦曲线，从最大值递减至 0）。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

min_lr (`float`, *可选*) : 余弦调度结束后要达到的最小学习率。

min_lr_rate (`float`, *可选*) : 作为初始学习率比例的最小学习率。如果设置了该值，则不应设置 `min_lr`。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个学习率调度器，其学习率在经过一段预热期后，按照余弦函数的值从优化器中设置的初始学习率衰减至 min_lr；在预热期内，学习率从 0 线性增加到优化器中设置的初始学习率。

### get_cosine_with_min_lr_schedule_with_warmup_lr_rate[[transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate]]

#### transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate[[transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate]]

```python
transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1, min_lr: float | None = None, min_lr_rate: float | None = None, warmup_lr_rate: float | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L414)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

num_training_steps (`int`) : 训练步数的总数。

num_cycles (`float`，*可选*，默认值为 0.5)：余弦调度中的波数（默认行为是遵循半余弦曲线，从最大值递减至 0）。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

min_lr (`float`, *可选*) : 余弦调度结束后要达到的最小学习率。

min_lr_rate (`float`, *可选*) : 作为初始学习率比例的最小学习率。如果设置了该值，则不应设置 `min_lr`。

warmup_lr_rate (`float`, *可选*) : 作为起始学习率比例的最小学习率。如果未设置，`warmup_lr_rate` 将被视为 float(1/num_warmup_steps)。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个学习率调度器，其学习率在经过一段预热期后，按照余弦函数的值从优化器中设置的初始学习率衰减至 min_lr；在预热期内，学习率从 0 线性增加到优化器中设置的初始学习率。

### GreedyLR[[transformers.GreedyLR]]

#### transformers.GreedyLR[[transformers.GreedyLR]]

```python
transformers.GreedyLR(optimizer: Optimizer, mode: str = 'min', factor: float = 0.95, patience: int = 10, threshold: float = 1e-06, threshold_mode: str = 'abs', cooldown: int = 0, warmup: int = 0, min_lr: float | list[float] = 0.001, max_lr: float | list[float] = 1.0, eps: float = 1e-08, verbose: bool = False, smooth: bool = False, window_size: int = 50, reset_start: int = 500)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L621)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

mode (`str`，*可选*，默认为 `"min"`)：'min' 或 'max' 之一。在 'min' 模式下，当指标停止下降时，学习率将被降低；在 'max' 模式下，当指标停止上升时，学习率将被降低。

factor (`float`, *可选*，默认为 0.95)：用于调整学习率的因子。当训练进入平台期时，学习率乘以该因子；当性能提升时，学习率除以该因子。该值必须小于 1.0。

patience (`int`，*可选*，默认为 10)：学习率调整前，连续没有改进的 epoch 数量。

threshold (`float`，*可选*，默认值为 1e-06)：用于衡量新最优值的阈值。

threshold_mode (`str`，*可选*，默认为 `"abs"`)：'rel' 或 'abs' 之一。

cooldown (`int`，*可选*，默认为 0)：学习率降低后，恢复正常操作前等待的 epoch 数。

warmup (`int`，*可选*，默认为 0)：在 LR 增加后，恢复正常操作前需要等待的 epoch 数。

min_lr (`float` 或 `list[float]`，*可选*，默认为 0.001)：学习率的下限。

max_lr (`float` 或 `list[float]`，*可选*，默认为 1.0)：学习率的上限。

eps (`float`，*可选*，默认值为 1e-08)：应用于学习率的最小衰减。

verbose (`bool`，*可选*，默认为 `False`)：如果为 True，则每次更新时向 stdout 打印一条消息。

smooth (`bool`，*可选*，默认为 `False`)：如果为 True，则对指标应用流式平均平滑。

window_size (`int`，*可选*，默认值为 50)：当 smooth=True 时，用于计算流式平均值的窗口大小。

reset_start (`int`，*可选*，默认值为 500)：在重置为初始状态之前，在 min_lr 处等待的步数。

一种根据训练指标做出响应的自适应学习率调度器。

GreedyLR 会根据训练表现动态调整学习率：
- 当指标持续改善时，增加学习率（除以因子）
- 当指标趋于平稳时降低学习率（乘以指定因子）

这与余弦退火等传统调度器不同，它根据实际的训练动态做出响应，而不是遵循预设的调度计划。

参考文献：`GreedyLR: A Novel Adaptive Learning Rate Scheduler <https://arxiv.org/abs/2512.14527>`_

示例：
```python
>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
>>> scheduler = GreedyLR(optimizer, mode="min", patience=10)
>>> for epoch in range(100):
...     train(...)
...     val_loss = validate(...)
...     scheduler.step(val_loss)
```

#### get_last_lr[[transformers.GreedyLR.get_last_lr]]

```python
get_last_lr()
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L855)

返回当前调度器最后计算的学习率。

#### load_state_dict[[transformers.GreedyLR.load_state_dict]]

```python
load_state_dict(state_dict: dict[str, Any])
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L892)

从字典加载状态。

#### state_dict[[transformers.GreedyLR.state_dict]]

```python
state_dict()
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L859)

以字典形式返回调度器的状态。

#### 步骤[[transformers.GreedyLR.step]]

```python
step(metrics: float, epoch: int | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L749)

**参数：**

metrics (`float`) : 用于学习率调整决策的指标值。

epoch (`int`, *可选*) : 当前 epoch 编号。如果为 None，则使用内部计数器。

根据给定的指标执行一次调度器步骤。

### get_greedy_schedule[[transformers.get_greedy_schedule]]

#### transformers.get_greedy_schedule[[transformers.get_greedy_schedule]]

```python
transformers.get_greedy_schedule(optimizer: Optimizer, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L928)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

kwargs (`dict`, *可选*) : 传递给调度器的额外参数。有关可能的参数，请参阅 [GreedyLR](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.GreedyLR)。

**返回值：**

使用合适的调度策略的 [GreedyLR](/docs/transformers/v5.23.0/zh/main_classes/optimizer_schedules#transformers.GreedyLR)。

创建一个自适应学习率调度器，根据训练指标调整 LR。

### get_linear_schedule_with_warmup[[transformers.get_linear_schedule_with_warmup]]

#### transformers.get_linear_schedule_with_warmup[[transformers.get_linear_schedule_with_warmup]]

```python
transformers.get_linear_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, last_epoch = -1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L107)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

num_training_steps (`int`) : 训练步数的总数。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个学习率调度器，在预热阶段内，学习率从 0 线性增加到优化器中设置的初始学习率；预热结束后，学习率从该初始值线性衰减至 0。

### get_polynomial_decay_schedule_with_warmup[[transformers.get_polynomial_decay_schedule_with_warmup]]

#### transformers.get_polynomial_decay_schedule_with_warmup[[transformers.get_polynomial_decay_schedule_with_warmup]]

```python
transformers.get_polynomial_decay_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, lr_end = 1e-07, power = 1.0, last_epoch = -1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L242)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

num_training_steps (`int`) : 训练步数的总数。

lr_end (`float`，*可选*，默认值为 1e-7)：结束学习率。

power (`float`，*可选*，默认值为 1.0)：幂因子。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个学习率调度器，在预热阶段内，学习率从 0 线性增加到优化器中设置的初始学习率；预热结束后，学习率以多项式衰减的方式从优化器中设置的初始学习率降低至由 *lr_end* 定义的最终学习率。

注意：*power* 的默认值为 1.0，与 fairseq 的实现一致，而 fairseq 的实现又基于原始 BERT 实现，参见 https://github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/optimization.py#L37

### get_inverse_sqrt_schedule[[transformers.get_inverse_sqrt_schedule]]

#### transformers.get_inverse_sqrt_schedule[[transformers.get_inverse_sqrt_schedule]]

```python
transformers.get_inverse_sqrt_schedule(optimizer: Optimizer, num_warmup_steps: int, timescale: int | None = None, last_epoch: int = -1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L296)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

timescale (`int`，*可选*，默认为 `num_warmup_steps`)：时间比例。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个采用平方根倒数学习率的调度器，在预热阶段将学习率从 0 线性增加到优化器中设置的初始学习率，之后按平方根倒数规律衰减。

### get_reduce_on_plateau_schedule[[transformers.get_reduce_on_plateau_schedule]]

#### transformers.get_reduce_on_plateau_schedule[[transformers.get_reduce_on_plateau_schedule]]

```python
transformers.get_reduce_on_plateau_schedule(optimizer: Optimizer, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L56)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

kwargs (`dict`, *可选*) : 传递给调度器的额外参数。有关可能的参数，请参阅 `torch.optim.lr_scheduler.ReduceLROnPlateau`。

**返回值：**

`torch.optim.lr_scheduler.ReduceLROnPlateau` 配合适当的调度策略。

创建一个学习率调度器，在指标停止改善时降低恒定的学习率。

### get_wsd_schedule[[transformers.get_wsd_schedule]]

#### transformers.get_wsd_schedule[[transformers.get_wsd_schedule]]

```python
transformers.get_wsd_schedule(optimizer: Optimizer, num_warmup_steps: int, num_decay_steps: int, num_training_steps: int | None = None, num_stable_steps: int | None = None, warmup_type: str = 'linear', decay_type: str = 'cosine', min_lr_ratio: float = 0, num_cycles: float = 0.5, last_epoch: int = -1)
```

[来源](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/optimization.py#L508)

**参数：**

optimizer (`~torch.optim.Optimizer`)：要为其安排学习率的优化器。

num_warmup_steps (`int`) : 预热阶段的步数。

num_decay_steps (`int`) : 衰减阶段的步数。

num_training_steps (`int`, *可选*) : 训练总步数。这是预热、稳定和衰减步数的总和。如果未提供 `num_stable_steps`，则稳定阶段将为 `num_training_steps - num_warmup_steps - num_decay_steps`。

num_stable_steps (`int`, *可选*) : 稳定阶段的步数。请确保 `num_warmup_steps + num_stable_steps + num_decay_steps` 等于 `num_training_steps`，否则其他阶段的步数将默认使用最小学习率。

warmup_type (`str`，*可选*，默认为 "linear")：要使用的预热类型。可以是 'linear'、'cosine' 或 '1-sqrt'。

decay_type (`str`，*可选*，默认为 "cosine")：要使用的衰减类型。可以是 'linear'、'cosine' 或 '1-sqrt'。

min_lr_ratio (`float`, *可选*，默认为 0)：最小学习率，表示为初始学习率的比率。

num_cycles (`float`，*可选*，默认值为 0.5)：余弦调度中的波数（默认行为是遵循半余弦曲线，从最大值递减至 0）。

last_epoch (`int`，*可选*，默认值为 -1)：恢复训练时最后一个 epoch 的索引。

**返回值：**

使用适当的调度策略的 `torch.optim.lr_scheduler.LambdaLR`。

创建一个具有三个阶段的学习率计划：
1. warmup：按照 warmup_type，将学习率从初始学习率的 min_lr_ratio 倍逐步提升至初始学习率。
2. stable：恒定学习率。
3. decay：按照 decay_type 从初始学习率衰减至初始学习率的 min_lr_ratio 倍。

