# Optimasi

Modul `.optimization` menyediakan:

- optimizer dengan weight decay yang tetap, yang dapat digunakan untuk fine-tuning model, dan
- beberapa jadwal dalam bentuk objek jadwal yang mewarisi dari `_LRSchedule`:
- kelas akumulasi gradien untuk mengakumulasi gradien dari beberapa batch

## 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L1057)

**Parameter:**

params (`Iterable[nn.parameter.Parameter]`) : Iterable dari parameter yang akan dioptimalkan atau kamus yang mendefinisikan grup parameter.

lr (`float`, *opsional*) : Laju belajar eksternal.

eps (`tuple[float, float]`, *opsional*, defaultnya `(1e-30, 0.001)`) : Konstanta regularisasi untuk gradien kuadrat dan skala parameter, masing-masing

clip_threshold (`float`, *opsional*, default 1.0) : Ambang batas akar rata-rata kuadrat (root mean square) dari pembaruan gradien akhir

decay_rate (`float`, *opsional*, default -0.8) : Koefisien yang digunakan untuk menghitung rata-rata berjalan dari kuadrat

beta1 (`float`, *opsional*) : Koefisien yang digunakan untuk menghitung rata-rata berjalan (running average) dari gradien

weight_decay (`float`, *opsional*, default 0.0) : Weight decay (penalti L2)

scale_parameter (`bool`, *opsional*, default `True`) : Jika True, learning rate diskalakan berdasarkan root mean square

relative_step (`bool`, *opsional*, default `True`) : Jika True, learning rate yang bergantung pada waktu akan dihitung alih-alih menggunakan learning rate eksternal

warmup_init (`bool`, *opsional*, default `False`) : Perhitungan laju pembelajaran yang bergantung pada waktu bergantung pada apakah inisialisasi pemanasan sedang digunakan

Implementasi AdaFactor pytorch dapat digunakan sebagai pengganti langsung untuk kode fairseq asli Adam: https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py

Paper: *Adafactor: Adaptive Learning Rates with Sublinear Memory Cost* https://huggingface.co/papers/1804.04235 Perhatikan bahwa optimizer ini secara internal menyesuaikan learning rate berdasarkan opsi `scale_parameter`, `relative_step`, dan `warmup_init`. Untuk menggunakan jadwal learning rate manual (eksternal), Anda harus mengatur `scale_parameter=False` dan `relative_step=False`.

Implementasi ini menangani nilai presisi rendah (FP16, bfloat), tetapi kami belum mengujinya secara menyeluruh.

Pengaturan finetuning T5 yang direkomendasikan (https://discuss.huggingface.co/t/t5-finetuning-tips/684/3):

- Pelatihan tanpa LR warmup atau clip_threshold tidak disarankan.

  - gunakan pemanasan LR terjadwal ke LR tetap
  - gunakan clip_threshold=1.0 (https://huggingface.co/papers/1804.04235)
- Nonaktifkan pembaruan relatif
- Gunakan scale_parameter=False
- Operasi optimizer tambahan seperti pemotongan gradien (gradient clipping) tidak boleh digunakan bersamaan dengan Adafactor

Contoh:

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

Lainnya melaporkan bahwa kombinasi berikut bekerja dengan baik:

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

Saat menggunakan `lr=None` dengan [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer), Anda kemungkinan besar perlu menggunakan `AdafactorSchedule`

scheduler sebagai berikut:

```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))
```

Penggunaan:

```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,
)
```

#### langkah[[transformers.Adafactor.step]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L1202)

**Parameter:**

closure (callable, opsional) : Sebuah closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi

## Jadwal

### SchedulerType[[transformers.SchedulerType]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_utils.py#L561)

Nama scheduler untuk parameter `lr_scheduler_type` di [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments). Secara default, menggunakan "linear". Secara internal, ini mengambil scheduler `get_linear_schedule_with_warmup` dari [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer). Jenis scheduler:
- "linear" = [get_linear_schedule_with_warmup()](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup)
- "cosine" = [get_cosine_schedule_with_warmup()](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.get_cosine_schedule_with_warmup)
- "cosine_with_restarts" = [get_cosine_with_hard_restarts_schedule_with_warmup()](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.get_cosine_with_hard_restarts_schedule_with_warmup)
- "polynomial" = [get_polynomial_decay_schedule_with_warmup()](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.get_polynomial_decay_schedule_with_warmup)
- "constant" =  [get_constant_schedule()](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.get_constant_schedule)
- "constant_with_warmup" = [get_constant_schedule_with_warmup()](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.get_constant_schedule_with_warmup)
- "inverse_sqrt" = [get_inverse_sqrt_schedule()](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.get_inverse_sqrt_schedule)
- "reduce_lr_on_plateau" = [get_reduce_on_plateau_schedule()](/docs/transformers/main/id/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/id/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/id/main_classes/optimizer_schedules#transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate)
- "warmup_stable_decay" = [get_wsd_schedule()](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.get_wsd_schedule)
- "greedy" = [get_greedy_schedule()](/docs/transformers/main/id/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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L960)

**Parameter:**

name (`str` atau `SchedulerType`) : Nama scheduler yang akan digunakan.

optimizer (`torch.optim.Optimizer`) : Optimizer yang akan digunakan selama pelatihan.

num_warmup_steps (`int`, *opsional*) : Jumlah langkah pemanasan yang akan dilakukan. Hal ini tidak diwajibkan oleh semua scheduler (sehingga argumen ini bersifat opsional); fungsi akan melempar error jika tidak diset dan jenis scheduler membutuhkannya.

num_training_steps (`int``, *opsional*) : Jumlah langkah pelatihan yang akan dilakukan. Hal ini tidak diwajibkan oleh semua scheduler (sehingga argumen ini bersifat opsional); fungsi akan melempar error jika nilai ini tidak diset dan jenis scheduler membutuhkannya.

scheduler_specific_kwargs (`dict`, *opsional*) : Parameter tambahan untuk scheduler seperti cosine with restarts. Ketidakcocokan antara jenis scheduler dan parameter scheduler akan menyebabkan fungsi scheduler melempar TypeError.

API terpadu untuk mendapatkan penjadwal apa pun dari namanya.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L39)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buat jadwal dengan tingkat pembelajaran konstan, menggunakan tingkat pembelajaran yang diatur di 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L80)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buat jadwal dengan tingkat pembelajaran konstan yang didahului oleh periode pemanasan, di mana tingkat pembelajaran meningkat secara linear antara 0 dan lr awal yang diatur di optimizer.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L143)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

num_training_steps (`int`) : Total jumlah langkah pelatihan.

num_cycles (`float`, *opsional*, default 0.5) : Jumlah gelombang dalam jadwal kosinus (defaultnya hanya menurunkan dari nilai maksimum ke 0 mengikuti setengah kosinus).

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buatlah jadwal dengan learning rate yang menurun mengikuti nilai fungsi kosinus dari lr awal yang diatur di optimizer hingga 0, setelah periode warmup di mana learning rate meningkat secara linear dari 0 ke lr awal yang diatur di optimizer.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L188)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

num_training_steps (`int`) : Total jumlah langkah pelatihan.

num_cycles (`int`, *opsional*, default 1) : Jumlah hard restart yang akan digunakan.

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buatlah jadwal dengan learning rate yang menurun mengikuti nilai fungsi kosinus dari lr awal yang disetel di optimizer hingga 0, dengan beberapa hard restart, setelah periode warmup di mana learning rate meningkat secara linear dari 0 hingga lr awal yang disetel di optimizer.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L337)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

num_training_steps (`int`) : Total jumlah langkah pelatihan.

num_cycles (`float`, *opsional*, default 0.5) : Jumlah gelombang dalam jadwal kosinus (defaultnya hanya menurunkan dari nilai maksimum ke 0 mengikuti setengah kosinus).

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

min_lr (`float`, *opsional*) : Laju pembelajaran minimum yang akan dicapai setelah jadwal kosinus.

min_lr_rate (`float`, *opsional*) : Laju pembelajaran minimum sebagai rasio dari laju pembelajaran awal. Jika diatur, `min_lr` tidak boleh diatur.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buat jadwal dengan learning rate yang menurun mengikuti nilai fungsi kosinus antara lr awal yang diatur di optimizer ke min_lr, setelah periode warmup di mana learning rate meningkat secara linear antara 0 dan lr awal yang diatur di optimizer.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L414)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

num_training_steps (`int`) : Total jumlah langkah pelatihan.

num_cycles (`float`, *opsional*, default 0.5) : Jumlah gelombang dalam jadwal kosinus (defaultnya hanya menurunkan dari nilai maksimum ke 0 mengikuti setengah kosinus).

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

min_lr (`float`, *opsional*) : Laju pembelajaran minimum yang akan dicapai setelah jadwal kosinus.

min_lr_rate (`float`, *opsional*) : Laju pembelajaran minimum sebagai rasio dari laju pembelajaran awal. Jika diatur, `min_lr` tidak boleh diatur.

warmup_lr_rate (`float`, *opsional*) : Laju pembelajaran minimum sebagai rasio dari laju pembelajaran awal. Jika tidak diatur, `warmup_lr_rate` akan diperlakukan sebagai float(1/num_warmup_steps).

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buat jadwal dengan learning rate yang menurun mengikuti nilai fungsi kosinus antara lr awal yang diatur di optimizer ke min_lr, setelah periode warmup di mana learning rate meningkat secara linear antara 0 dan lr awal yang diatur di optimizer.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L621)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

mode (`str`, *opsional*, default `"min"`) : Salah satu dari 'min' atau 'max'. Dalam mode 'min', LR akan dikurangi ketika metrik berhenti menurun; dalam mode 'max' ketika metrik berhenti meningkat.

factor (`float`, *opsional*, default 0.95) : Faktor yang digunakan untuk menyesuaikan learning rate. LR dikalikan dengan faktor saat plateau dan dibagi dengan faktor saat ada perbaikan. Harus < 1.0.

patience (`int`, *opsional*, default 10) : Jumlah epoch tanpa peningkatan setelahnya laju pembelajaran akan disesuaikan.

threshold (`float`, *opsional*, default 1e-06) : Ambang batas untuk mengukur optimum baru.

threshold_mode (`str`, *opsional*, default `"abs"`) : Salah satu dari 'rel' atau 'abs'.

cooldown (`int`, *opsional*, default 0) : Jumlah epoch yang harus ditunggu sebelum melanjutkan operasi normal setelah LR dikurangi.

warmup (`int`, *opsional*, default 0) : Jumlah epoch yang harus ditunggu sebelum melanjutkan operasi normal setelah LR ditingkatkan.

min_lr (`float` atau `list[float]`, *opsional*, default 0.001) : Batas bawah untuk learning rate.

max_lr (`float` atau `list[float]`, *opsional*, default 1.0) : Batas atas untuk learning rate.

eps (`float`, *opsional*, default 1e-08) : Decay minimal yang diterapkan ke lr.

verbose (`bool`, *opsional*, default `False`) : Jika True, mencetak pesan ke stdout untuk setiap pembaruan.

smooth (`bool`, *opsional*, default `False`) : Jika True, menerapkan penghalusan rata-rata streaming ke metrik.

window_size (`int`, *opsional*, default 50) : Ukuran jendela untuk rata-rata streaming saat smooth=True.

reset_start (`int`, *opsional*, default 500) : Jumlah langkah untuk menunggu pada min_lr sebelum direset ke keadaan awal.

Penjadwal laju pembelajaran adaptif yang merespons metrik pelatihan.

GreedyLR secara dinamis menyesuaikan tingkat pembelajaran berdasarkan kinerja pelatihan:
- Meningkatkan LR saat metrik membaik secara konsisten (dibagi dengan faktor)
- Menurunkan LR saat metrik stagnan (dikalikan dengan faktor)

Hal ini berbeda dari scheduler tradisional seperti cosine annealing karena merespons dinamika pelatihan yang sebenarnya, bukan mengikuti jadwal yang telah ditentukan sebelumnya.

Referensi: `GreedyLR: A Novel Adaptive Learning Rate Scheduler <https://arxiv.org/abs/2512.14527>`_

Contoh:
```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()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L855)

Kembalikan tingkat pembelajaran terakhir yang dihitung oleh penjadwal saat ini.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L892)

Muat state dari kamus.

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

```python
state_dict()
```

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

Kembalikan status scheduler sebagai kamus.

#### langkah[[transformers.GreedyLR.step]]

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

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

**Parameter:**

metrics (`float`) : Nilai metrik yang digunakan untuk keputusan penyesuaian LR.

epoch (`int`, *opsional*) : Nomor epoch saat ini. Jika None, menggunakan penghitung internal.

Lakukan langkah penjadwal berdasarkan metrik yang diberikan.

### get_greedy_schedule[[transformers.get_greedy_schedule]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L928)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

kwargs (`dict`, *opsional*) : Parameter tambahan yang diteruskan ke scheduler. Lihat [GreedyLR](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.GreedyLR) untuk parameter yang mungkin.

**Mengembalikan:**

[GreedyLR](/docs/transformers/main/id/main_classes/optimizer_schedules#transformers.GreedyLR) dengan jadwal yang sesuai.

Buat penjadwal laju pembelajaran adaptif yang menyesuaikan LR berdasarkan metrik pelatihan.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L107)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

num_training_steps (`int`) : Total jumlah langkah pelatihan.

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buat jadwal dengan learning rate yang menurun secara linear dari lr awal yang diatur di optimizer hingga 0, setelah periode warmup di mana learning rate meningkat secara linear dari 0 ke lr awal yang diatur di optimizer.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L242)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

num_training_steps (`int`) : Total jumlah langkah pelatihan.

lr_end (`float`, *opsional*, default 1e-7) : LR akhir.

power (`float`, *opsional*, default 1.0) : Faktor daya.

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buat jadwal dengan learning rate yang menurun secara peluruhan polinomial dari lr awal yang diatur di optimizer menuju end lr yang didefinisikan oleh *lr_end*, setelah periode warmup di mana learning rate meningkat secara linear dari 0 ke lr awal yang diatur di optimizer.

Catatan: *power* secara default bernilai 1.0, sebagaimana pada implementasi fairseq, yang pada gilirannya didasarkan pada implementasi BERT asli di 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L296)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

timescale (`int`, *opsional*, default `num_warmup_steps`) : Skala waktu.

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buat jadwal dengan learning rate akar kuadrat terbalik, dari lr awal yang diatur di optimizer, setelah periode warmup yang meningkatkan lr secara linear dari 0 ke lr awal yang diatur di optimizer.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L56)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

kwargs (`dict`, *opsional*) : Parameter tambahan yang akan diteruskan ke scheduler. Lihat `torch.optim.lr_scheduler.ReduceLROnPlateau` untuk parameter yang mungkin.

**Mengembalikan:**

`torch.optim.lr_scheduler.ReduceLROnPlateau` dengan jadwal yang sesuai.

Buat jadwal dengan tingkat pembelajaran konstan yang menurun ketika metrik berhenti membaik.

### 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L508)

**Parameter:**

optimizer (`~torch.optim.Optimizer`) : Optimizer yang akan dijadwalkan laju belajarnya.

num_warmup_steps (`int`) : Jumlah langkah untuk fase pemanasan.

num_decay_steps (`int`) : Jumlah langkah untuk fase peluruhan.

num_training_steps (`int`, *opsional*) : Total jumlah langkah pelatihan. Ini adalah jumlah dari langkah warmup, stable, dan decay. Jika `num_stable_steps` tidak diberikan, fase stable akan menjadi `num_training_steps - num_warmup_steps - num_decay_steps`.

num_stable_steps (`int`, *opsional*) : Jumlah langkah untuk fase stabil. Pastikan bahwa `num_warmup_steps + num_stable_steps + num_decay_steps` sama dengan `num_training_steps`, jika tidak, langkah-langkah lainnya akan menggunakan tingkat pembelajaran minimum secara default.

warmup_type (`str`, *opsional*, defaultnya "linear") : Jenis warmup yang akan digunakan. Bisa berupa 'linear', 'cosine', atau '1-sqrt'.

decay_type (`str`, *opsional*, defaultnya "cosine") : Jenis peluruhan yang akan digunakan. Bisa berupa 'linear', 'cosine', atau '1-sqrt'.

min_lr_ratio (`float`, *opsional*, default 0) : Laju pembelajaran minimum sebagai rasio dari laju pembelajaran awal.

num_cycles (`float`, *opsional*, default 0.5) : Jumlah gelombang dalam jadwal kosinus (defaultnya hanya menurunkan dari nilai maksimum ke 0 mengikuti setengah kosinus).

last_epoch (`int`, *opsional*, default -1) : Indeks epoch terakhir saat melanjutkan pelatihan.

**Mengembalikan:**

`torch.optim.lr_scheduler.LambdaLR` dengan jadwal yang sesuai.

Buat jadwal dengan learning rate yang memiliki tiga tahap:
1. warmup: meningkatkan dari min_lr_ratio kali learning rate awal hingga learning rate awal mengikuti warmup_type.
2. stabil: laju pembelajaran konstan.
3. decay: penurunan dari learning rate awal menjadi min_lr_ratio kali learning rate awal mengikuti decay_type.