# Referans Model için BEMA

Bu özellik, DPO eğitimi sırasında referans modelin güncellenmesi için BEMA algoritmasını uygular.

## Kullanım

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

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.1/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)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L1450)

**Parametreler:**

resume_from_checkpoint (`str` veya `bool`, *isteğe bağlı*) : `str` ise, önceki bir `Trainer` örneği tarafından kaydedilen bir kontrol noktasının yerel yolu. `bool` ise ve `True` değerine eşitse, önceki bir `Trainer` örneği tarafından *args.output_dir* içinde kaydedilen son kontrol noktasını yükler. Mevcut ise, eğitim burada yüklenen model/optimizer/scheduler durumlarından devam eder.

trial (`optuna.Trial` veya `dict[str, Any]`, *isteğe bağlı*) : Hiperparametre araması için deneme çalışması veya hiperparametre sözlüğü.

ignore_keys_for_eval (`list[str]`, *isteğe bağlı*) : Modelinizin çıktısında (bir sözlükse) eğitim sırasında değerlendirme için tahminleri toplarken yok sayılması gereken anahtarların listesi.

**Dönüş:** `~trainer_utils.TrainOutput`

Küresel adım sayısını, eğitim kaybını ve metrikleri içeren nesne.

Ana eğitim giriş noktası.

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

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

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L4077)

Modeli kaydeder, böylece `from_pretrained()` kullanarak yeniden yükleyebilirsiniz.

Yalnızca ana süreçten kaydedecektir.

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

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L4337)

**Parametreler:**

commit_message (`str`, *isteğe bağlı*, varsayılan `"End of training"`) : İterlerken gönderilecek mesaj.

blocking (`bool`, *isteğe bağlı*, varsayılan `True`) : Fonksiyonun yalnızca `git push` işlemi tamamlandığında mı dönmeli.

token (`str`, *isteğe bağlı*, varsayılan `None`) : Trainer'ın orijinal argümanlarını üzerine yazma iznine sahip jeton.

revision (`str`, *isteğe bağlı*) : Taahhüt edilecek git revizyonu. Varsayılan olarak "main" dalının başıdır.

private (`bool`, *isteğe bağlı*) : Oluşturulduğunda depoyu özel yapılıp yapılmayacağını belirtir. Varsayılan olarak `args.hub_private_repo` değerini kullanır. Depo zaten mevcutsa etkisi yoktur.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : `~Trainer.create_model_card`'e iletilen ek anahtar kelime argümanları.

**Dönüş:**

`blocking=False` ise modelin itildiği depoyun URL'si, `blocking=True` ise commit'in ilerlemesini izleyen bir `Future` nesnesi.

`self.model` ve `self.processing_class` öğelerini `self.args.hub_model_id` deposundaki 🤗 model hub'ına yükleyin.

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

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.1/trl/experimental/bema_for_ref_model/callback.py#L59)

**Parametreler:**

update_freq (`int`, *opsiyonel*, varsayılan `400`) : BEMA ağırlıklarını her X adımda günceller. Makalede buna  \\( \phi \\) denir.

ema_power (`float`, *opsiyonel*, varsayılan `0.5`) : EMA sönümleme katsayısı için güç. Makalede \\( \kappa \\) ile gösterilir. EMA'yı devre dışı bırakmak için bunu `0.0` olarak ayarlayın.

bias_power (`float`, *opsiyonel*, varsayılan `0.2`) : BEMA ölçekleme faktörü için güç. Makalede \\( \eta \\) ile gösterilir. Büyük bir değer (ör. `8.0`), \\( \alpha_t \\)'nin `0`'a sönümlenmesine neden olarak önyargı düzeltmesinin devre dışı bırakılmasını yaklaşık olarak sağlar; `0.0` ise her adımda \\( \alpha_t \\)'yi `1`'de sabitler (maksimum, sönümlenmemiş düzeltme).

lag (`int`, *opsiyonel*, varsayılan `10`) : Güncellemeler için sanal bir başlangıç yaşı olarak davranarak erken aşamadaki pürüzsüzlüğü kontrol eden ağırlık çürümesi zamanlamasındaki başlangıç ofseti. Makalede \\( \rho \\) ile gösterilir.

update_after (`int`, *opsiyonel*, varsayılan `0`) : BEMA ağırlıklarını güncellemeye başlamadan önceki ısınma süresi. Makalede \\( \tau \\) ile gösterilir.

multiplier (`float`, *opsiyonel*, varsayılan `1.0`) : EMA sönümleme katsayısının başlangıç değeri. Makalede \\( \gamma \\) olarak gösterilir.

min_ema_multiplier (`float`, *isteğe bağlı*, varsayılan `0.0`) : EMA sönümleme katsayısı için minimum değer.

device (`str`, *isteğe bağlı*, varsayılan `"cpu"`) : BEMA tamponları için kullanılacak cihaz, örn. `"cpu"` veya `"cuda"`. Çoğu durumda, OOM (bellek taşması) sorununu önlemek için bu cihazın eğitimde kullanılan cihazdan FARKLI OLMASI GEREKTİĞİNİ unutmayın.

update_ref_model (`bool`, *isteğe bağlı*, varsayılan `False`) : Referans modelin BEMA ağırlıklarıyla güncellenip güncellenmeyeceğini belirtir. Bu, referans model olarak ana modelin gecikmeli ve yumuşatılmış bir versiyonunu oluşturur.

ref_model_update_freq (`int`, *isteğe bağlı*, varsayılan `400`) : Referans modeli, BEMA ağırlıklarıyla bu kadar adımda bir günceller.

ref_model_update_after (`int`, *isteğe bağlı*, varsayılan `0`) : Referans modelin güncellenmeye başlamadan önce beklenmesi gereken adım sayısı.

[Adam Block](https://huggingface.co/abblock) ve [Cyril Zhang](https://huggingface.co/cyrilzhang) tarafından [BEMA](https://huggingface.co/papers/2508.00180) (Bias-Corrected Exponential Moving Average) uygulayan bir [TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerCallback). MIT lisansı altında https://github.com/abblock/bema adresinden alınan kod.

BEMA, şu şekilde ölçeklenen model ağırlıklarını hesaplar:

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

burada \\( \theta_t \\) mevcut model ağırlıklarını, \\( \theta_0 \\) ilk `update_after` adımındaki model ağırlıkları anlık görüntüsünü, \\( \text{EMA}_t  \\) model ağırlıklarının üstel hareketli ortalamasını ve \\( \alpha_t \\) adım sayısı \\( t \\) ile azalan bir ölçekleme faktörünü ifade eder

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

EMA şu şekilde hesaplanır:

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

burada \\( \beta_t \\) adım sayısı \\( t \\) ile azalan bir sönümleme katsayısıdır

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

Örnek:

```python
>>> from trl import BEMACallback

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

