# 最適化

`.optimization` モジュールは以下を提供します:

- weight decayが固定されたオプティマイザーで、モデルのファインチューニングに使用でき、
- `_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/main/src/transformers/optimization.py#L1057)

**パラメータ:**

params (`Iterable[nn.parameter.Parameter]`) : 最適化対象のパラメータのイテラブル、またはパラメータグループを定義する辞書。

lr (`float`, *任意*) : 外部学習率です。

eps (`tuple[float, float]`、*optional*、デフォルトは`(1e-30, 0.001)`) : 二乗勾配とパラメータスケールに対する正則化定数

clip_threshold (`float`、*任意*、デフォルト値は 1.0) : 最終的な勾配更新の二乗平均平方根（RMS）の閾値

decay_rate (`float`、*任意*、デフォルトは -0.8) : 二乗の移動平均を計算するために使用される係数

beta1 (`float`, *任意*) : グラデーションの移動平均を計算するために使用される係数

weight_decay (`float`、*任意*、デフォルトは 0.0) : ウェイトディケイ（L2 正則化）

scale_parameter (`bool`、*任意*、デフォルトは`True`) : True の場合、学習率は二乗平均平方根（RMS）でスケーリングされます

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のファインチューニング設定（https://discuss.huggingface.co/t/t5-finetuning-tips/684/3）：

- LR warmupやclip_thresholdなしでのトレーニングは推奨されません。

  - スケジュールされたLRウォームアップを固定LRに変更
  - 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)
```

`lr=None` を [Trainer](/docs/transformers/main/ja/main_classes/trainer#transformers.Trainer) と一緒に使用する場合は、`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/main/src/transformers/optimization.py#L1202)

**パラメータ:**

closure (callable, 任意) : モデルを再評価して損失を返すクロージャ。

1回の最適化ステップを実行します

## スケジュール

### 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/main/src/transformers/trainer_utils.py#L561)

[TrainingArguments](/docs/transformers/main/ja/main_classes/trainer#transformers.TrainingArguments)のパラメータ`lr_scheduler_type`に指定するスケジューラー名です。デフォルトでは"linear"が使用されます。内部では、[Trainer](/docs/transformers/main/ja/main_classes/trainer#transformers.Trainer)から`get_linear_schedule_with_warmup`スケジューラーを取得します。スケジューラーの種類:
- "linear" = [get_linear_schedule_with_warmup()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup)
- "cosine" = [get_cosine_schedule_with_warmup()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_cosine_schedule_with_warmup)
- "cosine_with_restarts" = [get_cosine_with_hard_restarts_schedule_with_warmup()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_cosine_with_hard_restarts_schedule_with_warmup)
- "polynomial" = [get_polynomial_decay_schedule_with_warmup()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_polynomial_decay_schedule_with_warmup)
- "constant" =  [get_constant_schedule()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_constant_schedule)
- "constant_with_warmup" = [get_constant_schedule_with_warmup()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_constant_schedule_with_warmup)
- "inverse_sqrt" = [get_inverse_sqrt_schedule()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_inverse_sqrt_schedule)
- "reduce_lr_on_plateau" = [get_reduce_on_plateau_schedule()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_reduce_on_plateau_schedule)
- "cosine_with_min_lr" = [get_cosine_with_min_lr_schedule_with_warmup()](/docs/transformers/main/ja/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/main/ja/main_classes/optimizer_schedules#transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate)
- "warmup_stable_decay" = [get_wsd_schedule()](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.get_wsd_schedule)
- "greedy" = [get_greedy_schedule()](/docs/transformers/main/ja/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/main/src/transformers/optimization.py#L960)

**パラメータ:**

name (`str` または `SchedulerType`) : 使用するスケジューラーの名前。

optimizer (`torch.optim.Optimizer`) : 学習中に使用されるオプティマイザー。

num_warmup_steps (`int`, *optional*) : 実行するウォームアップステップ数です。すべてのスケジューラーでこの引数は必須ではありません（そのため引数はオプションになっています）。未設定のまま、かつスケジューラーの種類がそれを要求している場合は、関数がエラーを送出します。

num_training_steps (`int``, *任意*) : 実行するトレーニングステップの数です。すべてのスケジューラでこの引数は必須ではありません（そのため引数は任意になっています）。未設定のまま、かつスケジューラの種類がその値を必要とする場合は、関数がエラーを送出します。

scheduler_specific_kwargs (`dict`、*省略可能*) : cosine with restarts などのスケジューラ用の追加パラメータです。スケジューラの種類とスケジューラのパラメータが一致しない場合、スケジューラ関数から TypeError が発生します。

Unified 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/main/src/transformers/optimization.py#L39)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

optimizerで設定された学習率を使用して、一定の学習率でスケジュールを作成します。

### 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/main/src/transformers/optimization.py#L80)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

num_warmup_steps (`int`) : ウォームアップフェーズのステップ数。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

最適化器で設定された初期 lr から 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/main/src/transformers/optimization.py#L143)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

num_warmup_steps (`int`) : ウォームアップフェーズのステップ数。

num_training_steps (`int`) : トレーニングステップの総数。

num_cycles (`float`、*optional*、デフォルトは 0.5) : コサインスケジュールにおける波の数（デフォルトでは、半コサインに従って最大値から 0 へ減少する）。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

オプティマイザーに設定された初期 lr から 0 まで、コサイン関数の値に従って減少する学習率のスケジュールを作成します。この際、0 からオプティマイザーに設定された初期 lr まで線形に増加するウォームアップ期間を設けます。

### 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/main/src/transformers/optimization.py#L188)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

num_warmup_steps (`int`) : ウォームアップフェーズのステップ数。

num_training_steps (`int`) : トレーニングステップの総数。

num_cycles (`int`、*optional*、デフォルトは 1) : 使用するハードリスタートの回数。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

optimizerで設定された初期lrから0までの値を、コサイン関数の値に従って減少させるスケジュールを作成します。このスケジュールには、0からoptimizerで設定された初期lrまで線形に増加するウォームアップ期間の後に、複数のハードリスタートが含まれます。

### 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/main/src/transformers/optimization.py#L337)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

num_warmup_steps (`int`) : ウォームアップフェーズのステップ数。

num_training_steps (`int`) : トレーニングステップの総数。

num_cycles (`float`、*optional*、デフォルトは 0.5) : コサインスケジュールにおける波の数（デフォルトでは、半コサインに従って最大値から 0 へ減少する）。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

min_lr (`float`, *任意*) : コサインスケジュールの後に到達する最小学習率。

min_lr_rate (`float`, *任意*) : 初期学習率に対する最小学習率の比率です。設定した場合、`min_lr` は設定しないでください。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

optimizerで設定された初期lrからmin_lrまで、コサイン関数の値に従って減少する学習率のスケジュールを作成します。この際、ウォームアップ期間中は0からoptimizerで設定された初期lrまで線形に増加します。

### 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/main/src/transformers/optimization.py#L414)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

num_warmup_steps (`int`) : ウォームアップフェーズのステップ数。

num_training_steps (`int`) : トレーニングステップの総数。

num_cycles (`float`、*optional*、デフォルトは 0.5) : コサインスケジュールにおける波の数（デフォルトでは、半コサインに従って最大値から 0 へ減少する）。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

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`を使用します。

optimizerで設定された初期lrからmin_lrまで、コサイン関数の値に従って減少する学習率のスケジュールを作成します。この際、ウォームアップ期間中は0からoptimizerで設定された初期lrまで線形に増加します。

### 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/main/src/transformers/optimization.py#L621)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

mode (`str`、*任意*、デフォルトは`"min"`) : 'min'または'max'のいずれかです。'min'モードでは、メトリックの減少が止まったときにLRが減少し、'max'モードでは増加が止まったときにLRが減少します。

factor (`float`, *optional*, デフォルトは 0.95) : 学習率を調整するための係数です。プラトー（停滞）時に学習率は factor で乗算され、改善時には factor で除算されます。1.0 未満である必要があります。

patience (`int`、*optional*、デフォルトは 10) : 改善がなかったエポック数。この回数を超えると学習率が調整されます。

threshold (`float`、*任意*、デフォルトは 1e-06) : 新しい最適解を測定するための閾値。

threshold_mode (`str`、*任意*、デフォルトは`"abs"`) : 'rel'または'abs'のいずれか。

cooldown (`int`、*任意*、デフォルトは 0) : LR が削減された後、通常の動作を再開するまで待機するエポック数。

warmup (`int`、*任意*、デフォルトは 0) : LR が増加した後に通常動作を再開するまで待機するエポック数。

min_lr (`float` または `list[float]`、*任意*、デフォルト値は 0.001) : 学習率の下限値です。

max_lr (`float` または `list[float]`、*任意*、デフォルト値は 1.0) : 学習率の上限値。

eps (`float`、*任意*、デフォルトは 1e-08) : lr に適用される最小の減衰量。

verbose (`bool`、*任意*、デフォルトは`False`) : True の場合、各更新時に標準出力にメッセージを表示します。

smooth (`bool`、*任意*、デフォルトは`False`) : True の場合、メトリクスにストリーミング平均スムージングを適用します。

window_size (`int`, *optional*, デフォルトは 50) : smooth=True の場合、ストリーミング平均のウィンドウサイズです。

reset_start (`int`、*任意*、デフォルトは 500) : 初期状態にリセットする前に min_lr で待機するステップ数。

学習メトリクスに応じて反応する適応型学習率スケジューラ。

GreedyLR は、トレーニングの性能に基づいて学習率を動的に調整します:
- メトリクスが一貫して改善した場合にLRを増加させます（係数で割る）
- メトリクスが頭打ちになるとLRを減少させます（係数を乗算）

これは、コサインアニーリングのような従来のスケジューラーとは異なり、事前に決められたスケジュールに従うのではなく、実際のトレーニングの動向に応じて動作します。

参考文献: `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/main/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/main/src/transformers/optimization.py#L892)

辞書から状態を読み込みます。

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

```python
state_dict()
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L859)

スケジューラーの状態を辞書として返します。

#### ステップ[[transformers.GreedyLR.step]]

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

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L749)

**パラメータ:**

metrics (`float`) : LR調整の判断に使用するメトリックの値。

epoch (`int`、*optional*) : 現在のエポック番号。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/main/src/transformers/optimization.py#L928)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

kwargs (`dict`, *任意*) : スケジューラに渡す追加のパラメータです。使用可能なパラメータについては [GreedyLR](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.GreedyLR) を参照してください。

**戻り値:**

適切なスケジュールで[GreedyLR](/docs/transformers/main/ja/main_classes/optimizer_schedules#transformers.GreedyLR)を使用します。

学習指標に基づいて学習率を調整する適応型学習率スケジューラを作成します。

### 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/main/src/transformers/optimization.py#L107)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

num_warmup_steps (`int`) : ウォームアップフェーズのステップ数。

num_training_steps (`int`) : トレーニングステップの総数。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

…

### 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/main/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) : トレーニングを再開する際の最後のエポックのインデックス。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

*lr_end*で定義される最終学習率まで、オプティマイザーに設定された初期学習率から多項式減衰で減少するスケジュールを作成します。この際、0からオプティマイザーに設定された初期学習率まで線形に増加するウォームアップ期間を設けます。

注: *power*は、fairseqの実装と同様にデフォルトで1.0です。fairseqの実装は、https://github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/optimization.py#L37 にある元のBERT実装に基づいています。

### 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/main/src/transformers/optimization.py#L296)

**パラメータ:**

optimizer (`~torch.optim.Optimizer`) : 学習率のスケジュールを設定するオプティマイザー。

num_warmup_steps (`int`) : ウォームアップフェーズのステップ数。

timescale (`int`、*任意*、デフォルトは `num_warmup_steps`) : 時間スケール。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

オプティマイザーで設定された初期lrから、lrを0から初期lrまで線形に増加させるウォームアップ期間を経て、逆平方根の学習率スケジュールを作成します。

### 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/main/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/main/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`, *optional*) : 安定フェーズのステップ数。`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`、*optional*、デフォルトは 0.5) : コサインスケジュールにおける波の数（デフォルトでは、半コサインに従って最大値から 0 へ減少する）。

last_epoch (`int`、*任意*、デフォルトは -1) : トレーニングを再開する際の最後のエポックのインデックス。

**戻り値:**

適切なスケジュールを指定して`torch.optim.lr_scheduler.LambdaLR`を使用します。

3段階の学習率を持つスケジュールを作成します：
1. warmup: warmup_type に従い、初期学習率の min_lr_ratio 倍から初期学習率まで段階的に増加させます。
2. stable: 一定の学習率。
3. decay: 初期学習率から、decay_typeに従って初期学習率のmin_lr_ratio倍まで減少します。

