# BEMA untuk Model Referensi

Fitur ini mengimplementasikan algoritma BEMA untuk memperbarui model referensi selama pelatihan DPO.

## Penggunaan

```python
from trl.experimental.bema_for_ref_model import BEMACallback, DPOTrainer
from datasets import load_dataset

dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")

bema_callback = BEMACallback(update_ref_model=True)

trainer = DPOTrainer(
    model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
    train_dataset=dataset,
    callbacks=[bema_callback],
)
trainer.train()
```

## DPOTrainer[[trl.DPOTrainer]]

#### trl.DPOTrainer[[trl.DPOTrainer]]

```python
trl.DPOTrainer(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/trl/blob/main/trl/experimental/bema_for_ref_model/dpo_trainer.py#L19)

#### train[[trl.DPOTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Sumber](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L1450)

**Parameter:**

resume_from_checkpoint (`str` atau `bool`, *opsional*) : Jika berupa `str`, path lokal ke checkpoint yang disimpan oleh instance `Trainer` sebelumnya. Jika berupa `bool` dan bernilai `True`, muat checkpoint terakhir di *args.output_dir* yang disimpan oleh instance `Trainer` sebelumnya. Jika ada, pelatihan akan dilanjutkan dari state model/optimizer/scheduler yang dimuat di sini.

trial (`optuna.Trial` atau `dict[str, Any]`, *opsional*) : Jalur percobaan atau kamus hiperparameter untuk pencarian hiperparameter.

ignore_keys_for_eval (`list[str]`, *opsional*) : Daftar kunci dalam output model Anda (jika berupa kamus) yang harus diabaikan saat mengumpulkan prediksi untuk evaluasi selama pelatihan.

**Mengembalikan:** `~trainer_utils.TrainOutput`

Objek yang berisi jumlah langkah global, kerugian pelatihan, dan metrik.

Titik masuk utama pelatihan.

#### save_model[[trl.DPOTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Sumber](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L4077)

Akan menyimpan model, sehingga Anda dapat memuatnya kembali menggunakan `from_pretrained()`.

Hanya akan menyimpan dari proses utama.

#### push_to_hub[[trl.DPOTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L4337)

**Parameter:**

commit_message (`str`, *opsional*, defaultnya `"End of training"`) : Pesan untuk commit saat push.

blocking (`bool`, *opsional*, defaultnya `True`) : Apakah fungsi harus hanya mengembalikan nilai setelah `git push` selesai.

token (`str`, *opsional*, defaultnya `None`) : Token dengan izin tulis untuk menimpa argumen asli Trainer.

revision (`str`, *opsional*) : Revisi git untuk di-commit. Secara default menggunakan head dari cabang "main".

private (`bool`, *opsional*) : Apakah membuat repo menjadi privat saat dibuat. Bawaan adalah `args.hub_private_repo`. Tidak berpengaruh jika repo sudah ada.

kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke `~Trainer.create_model_card`.

**Mengembalikan:**

URL repositori tempat model didorong jika `blocking=False`, atau objek `Future` yang melacak kemajuan commit jika `blocking=True`.

Unggah `self.model` dan `self.processing_class` ke 🤗 model hub di repo `self.args.hub_model_id`.

## BEMACallback[[trl.BEMACallback]]

#### trl.BEMACallback[[trl.BEMACallback]]

```python
trl.BEMACallback(update_freq: int = 400, ema_power: float = 0.5, bias_power: float = 0.2, lag: int = 10, update_after: int = 0, multiplier: float = 1.0, min_ema_multiplier: float = 0.0, device: str = 'cpu', update_ref_model: bool = False, ref_model_update_freq: int = 400, ref_model_update_after: int = 0)
```

[Sumber](https://github.com/huggingface/trl/blob/main/trl/experimental/bema_for_ref_model/callback.py#L59)

**Parameter:**

update_freq (`int`, *opsional*, default `400`) : Perbarui bobot BEMA setiap X langkah. Dinotasikan sebagai  \\( \phi \\) dalam makalah.

ema_power (`float`, *opsional*, default `0.5`) : Daya untuk faktor peluruhan EMA. Dilambangkan dengan \\( \kappa \\) dalam makalah. Untuk menonaktifkan EMA, atur ini ke `0.0`.

bias_power (`float`, *opsional*, default `0.2`) : Daya untuk faktor penskalaan BEMA. Dilambangkan dengan \\( \eta \\) dalam makalah. Nilai besar (mis. `8.0`) membuat \\( \alpha_t \\) meluruh ke `0`, mendekati koreksi bias yang dinonaktifkan; `0.0` sebaliknya mengunci \\( \alpha_t \\) pada `1` untuk setiap langkah (koreksi maksimum, tanpa peluruhan).

lag (`int`, *opsional*, default `10`) : Offset awal dalam jadwal weight decay yang mengontrol kehalusan tahap awal dengan bertindak sebagai usia awal virtual untuk pembaruan. Dilambangkan sebagai \\( \rho \\) dalam makalah.

update_after (`int`, *opsional*, default `0`) : Waktu burn-in sebelum mulai memperbarui bobot BEMA. Dilambangkan dengan \\( \tau \\) dalam makalah.

multiplier (`float`, *opsional*, default `1.0`) : Nilai awal untuk faktor peluruhan EMA. Dilambangkan sebagai  \\( \gamma \\) dalam makalah.

min_ema_multiplier (`float`, *opsional*, defaultnya `0.0`) : Nilai minimum untuk faktor peluruhan EMA.

device (`str`, *opsional*, defaultnya `"cpu"`) : Perangkat yang digunakan untuk buffer BEMA, misalnya `"cpu"` atau `"cuda"`. Perhatikan bahwa dalam kebanyakan kasus, perangkat ini HARUS BERBEDA dari perangkat yang digunakan untuk pelatihan guna menghindari OOM.

update_ref_model (`bool`, *opsional*, defaultnya `False`) : Apakah akan memperbarui model referensi dengan bobot BEMA. Hal ini membuat versi tertunda dan halus dari model utama sebagai model referensi.

ref_model_update_freq (`int`, *opsional*, defaultnya `400`) : Perbarui model referensi dengan bobot BEMA setiap sejumlah langkah ini.

ref_model_update_after (`int`, *opsional*, defaultnya `0`) : Jumlah langkah yang harus ditunggu sebelum mulai memperbarui model referensi.

[TrainerCallback](https://huggingface.co/docs/transformers/main/en/main_classes/callback#transformers.TrainerCallback) yang mengimplementasikan [BEMA](https://huggingface.co/papers/2508.00180) (Bias-Corrected Exponential Moving Average) oleh [Adam Block](https://huggingface.co/abblock) dan [Cyril Zhang](https://huggingface.co/cyrilzhang). Kode dari https://github.com/abblock/bema di bawah lisensi MIT.

BEMA menghitung bobot model yang berskala seperti:

$$ \theta_t' = \alpha_t \cdot (\theta_t - \theta_0) + \text{EMA}_t $$

di mana \\( \theta_t \\) adalah bobot model saat ini, \\( \theta_0 \\) adalah tangkapan bobot model pada langkah `update_after` pertama, \\( \text{EMA}_t  \\) adalah rata-rata bergerak eksponensial dari bobot model, dan \\( \alpha_t \\) adalah faktor penskalaan yang meluruh seiring dengan jumlah langkah \\( t \\) sebagai

$$ \alpha_t = (\rho + \gamma \cdot t)^{-\eta}. $$

EMA dihitung sebagai:

$$ \text{EMA}_t = (1 - \beta_t) \cdot \text{EMA}_{t-1} + \beta_t \cdot \theta_t $$

di mana \\( \beta_t \\) adalah faktor peluruhan yang meluruh seiring dengan jumlah langkah \\( t \\) sebagai

$$ \beta_t = (\rho + \gamma \cdot t)^{-\kappa}. $$

Contoh:

```python
>>> from trl import BEMACallback

>>> trainer = Trainer(..., callbacks=[BEMACallback()])
```