# RLOO Eğiticisi

[![model badge](https://img.shields.io/badge/All_models-RLOO-blue)](https://huggingface.co/models?other=rloo,trl)

## Genel Bakış

TRL, dil modellerinin eğitimi için RLOO Trainer'ı destekler; bu, [Arash Ahmadian](https://huggingface.co/ArashAhmadian), Chris Cremer, [Matthias Gallé](https://huggingface.co/mgalle), [Marzieh Fadaee](https://huggingface.co/MarziehFadaee), [Julia Kreutzer](https://huggingface.co/JuliaKreutzerCohere), [Ahmet Üstün](https://huggingface.co/ahmetu) ve [Sara Hooker](https://huggingface.co/sarahooker) tarafından yazılan [Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMs](https://huggingface.co/papers/2402.14740) makalesinde açıklanan yöntemdir.

Makalenin özeti aşağıdaki gibidir:

> İnsan Geri Bildiriminden Pekiştirmeli Öğrenme (RLHF) biçimindeki yapay zeka hizalama, yüksek performanslı büyük dil modelleri için giderek daha kritik bir bileşen olarak ele alınmaktadır. Yakın tarihli literatür, Yakınsak Politika Optimizasyonu'nu (PPO) RLHF'nin RL kısmı için standart yöntem olarak konumlandırmıştır. Ancak bu yöntem, hem yüksek hesaplama maliyeti hem de hassas hiperparametre ayarı gerektirmektedir. PPO'nun geliştirilmesine yol açan çoğu motivasyonel ilkenin RLHF bağlamında pratik bir endişe olmadığını öne sürüyor ve performansı koruyan hatta artıran, hesaplama açısından daha az maliyetli bir yöntem savunuyoruz. İnsan tercihlerinden hizalama formülasyonunu RL bağlamında yeniden inceliyoruz. Sadelik bir kılavuz ilke olarak benimsenerek, PPO'nun birçok bileşeninin RLHF bağlamında gereksiz olduğunu ve çok daha basit REINFORCE tarzı optimizasyon varyantlarının hem PPO'yu hem de DPO ve RAFT gibi yeni önerilen “RL'siz” yöntemleri geride bıraktığını gösteriyoruz. Çalışmamız, LLM hizalama özelliklerine özenli bir uyarlamanın, düşük maliyetle çevrimiçi RL optimizasyonundan faydalanmayı mümkün kıldığını göstermektedir.

Bu eğitim sonrası yöntemi [Costa Huang](https://github.com/vwxyzjn) tarafından katkıda bulunmuş ve daha sonra [Shirin Yamani](https://huggingface.co/ShirinYamani) tarafından yeniden yapılandırılmıştır.

## Hızlı başlangıç

Bu örnek, RLOO yöntemiyle bir modelin nasıl eğitileceğini göstermektedir. [DeepMath-103K veri setindeki](https://huggingface.co/datasets/trl-lib/DeepMath-103K) istemlerle bir [Qwen 0.5B Instruct modelini](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct) eğitiyoruz. Veri setindeki verilere buradan bakabilirsiniz:

<iframe src="https://huggingface.co/datasets/trl-lib/DeepMath-103K/embed/viewer/default/train?row=0" frameborder="0" width="100%" height="560px"
>

Aşağıda modeli eğitmek için kullanılan betik yer almaktadır. `accuracy_reward`, `pip install trl[math_verify]` komutuyla kurabileceğiniz math-verify gerektirir.

```python
# train_rloo.py
from datasets import load_dataset
from trl import RLOOTrainer
from trl.rewards import accuracy_reward

dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

trainer = RLOOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=accuracy_reward,
    train_dataset=dataset,
)
trainer.train()
```

Aşağıdaki komutu kullanarak betiği çalıştırın:

```bash
torchrun --nproc_per_node 8 train_rloo.py
```

## RLOO yönteminin derinlemesine incelenmesi

RLOO, eğitim sırasında eğitilmiş modelin kendisi tarafından üretilen verileri kullanarak iteratif olarak iyileşen bir çevrimiçi öğrenme algoritmasıdır. RLOO hedefinin arkasındaki sezgi, modelin referans politikaya yakın kalmasını sağlarken üretilen tamamlamaların avantajını en üst düzeye çıkarmaktır. RLOO'nun nasıl çalıştığını anlamak için dört ana adıma ayrılabilir: **tamamlamaların üretilmesi**, **avantajın hesaplanması**, **KL ayrımının tahmin edilmesi** ve **kaybın hesaplanması**.

![RLOO](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/rloo.png)

### Tamamlamalar oluşturma

Her eğitim adımında, bir istem partisi örnekleriz ve her istem için bir dizi  \\( G \\) tamamlama ( \\( o_i \\) olarak gösterilir) üretiriz.

### Ödülü hesaplama

RLOO'da ödül, iki bileşenden oluşur: ödül modeli (veya ödül fonksiyonu) tarafından sağlanan ödül ve politikanın sabit bir referans politikadan çok fazla sapmasını caydıran bir KL cezası

1. Her bir  \\( G \\) üretilen dizi  \\( o_i = (o_{i,1}, \dots, o_{i,T}) \\) için, bir sorguya  \\( q \\) bağlı olarak, bir ödül modeli  \\( R(o_i, q) \\) kullanarak bir skaler ödül hesaplarız.
2. Eşzamanlı olarak, mevcut politika \\( \pi_\theta \\) ile sabit referans politika \\( \pi_{\text{ref}} \\) arasındaki KL sapmasını dizin üzerinde tahmin ederiz. \\( o_i \\) dizisi için KL tahmini şudur:

$$ \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta\|\pi_{\mathrm{ref}}\right] = \sum_{t=1}^T \log \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\mathrm{ref}}(o_{i,t} \mid q, o_{i,<t})}. $$

Sıraya \\( o_i \\) atanan nihai ödül şudur:

$$ r_i = R(o_i, q) - \beta \, \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta \|\pi_{\mathrm{ref}}\right], $$

burada \\( \beta > 0 \\) KL cezasının şiddetini kontrol eder.

> [!TIP]
> Saf çevrimiçi bir ayar (`num_iterations = 1`, varsayılan) durumunda, veriler mevcut politika tarafından üretilir. Bu durumda, KL cezası doğrudan mevcut politika kullanılarak hesaplanır.
>
> Daha genel bir ayar (ör. her batch için birden fazla gradyan adımı) durumunda, veriler bunun yerine daha önceki bir anlık görüntü \\( \pi_{\text{old}} \\) tarafından üretilir. Cezanın örneklem dağılımıyla tutarlı kalmasını sağlamak için KL, bu politika ile ilgili olarak tanımlanır:
>
> \\( \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \,\|\, \pi_{\text{ref}}\right]. \\)
>
> Eşdeğer olarak, örneklenen bir dizi için \\( o \\), Monte Carlo tahmini şudur:
>
> \\( \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \|\pi_{\mathrm{ref}}\right] = \sum_{t=1}^T \log \frac{\pi_{\text{old}}(o_{i,t} \mid q, o_{i,<t})}{\pi_{\mathrm{ref}}(o_{i,t} \mid q, o_{i,<t})}. \\)

### Avantajın hesaplanması

Her tamamlama için ödül hesaplandıktan sonra, mevcut örnek hariç tutularak aynı batch'teki diğer tüm örneklerin ortalama ödülü olarak bir taban (baseline) hesaplanır. Bu taban, politika gradyanı tahmininin varyansını azaltmak için kullanılır. Her tamamlama için avantaj (advantage), kendi ödülü ile bu leave-one-out tabanı arasındaki fark olarak elde edilir.

Resmi olarak, G tamamlama içeren bir parti için tamamlama baz çizgisi şudur: $$ b_i = \frac{1}{G-1} \sum_{j \neq i} r_j $$

ardından her tamamlama için avantaj, ödülü ile taban değer arasındaki fark olarak hesaplanır:

$$
A_i = r_i - b_i
$$

### Kaybın hesaplanması

REINFORCE kaybı basitçe şu şekilde tanımlanır:

$$ \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \hat{A}_i \, \log \pi_\theta(o_i \mid q) $$

Uygulamada, aynı batch üzerinde birden fazla gradyan adımı atmak, eylemleri mevcut parametrelere göre fiilen off-policy hale getirir. Bunu düzeltmek için önem örneklemesi oranını (importance sampling ratio) tanıtırız. Örneklemleme ile gradyan adımları arasında politika değiştiğinde aşırı büyük güncellemeleri önlemek için bu oranı kırpma (clip) işlemine tabi tutarız:

$$ \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \min \left( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} \hat{A}_i, \, \text{clip}\left(\frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)}, 1-\epsilon, 1+\epsilon\right) \hat{A}_i \right) $$

Tamamen çevrimiçi, tek adımlı bir ayarlamada (varsayılan), \\( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} = 1 \\) olur ve bu, standart REINFORCE'a indirgenir.

> [!NOTE]
> GRPO'dan farklı olarak RLOO, KL terimi üzerinden gradyan geri yayılımı yapmaz. Burada KL tamamen ödül şekillendirme için kullanılır: `no_grad` altında hesaplanır ve skaler ödül \\( r_i \\) içine katılır; bu da koparılmış avantaj \\( \hat{A}_i \\) haline gelir.
>
> Diğer bir deyişle, politika içine giren tek yol, önem oranı terimi \\( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} \\)'dir ve KL terimi politika içine geri yayılmaz.
>
> Buna karşın, [GRPO](grpo_trainer) hedefine, mevcut politika \\( \pi_\theta \\) ile anlık olarak hesaplanan açık ve türevlenebilir bir KL terimi ekler; bu nedenle gradyanı hem oran teriminden hem de KL cezasından geçer.

## Kaydedilen metrikler

Eğitim ve değerlendirme sırasında aşağıdaki metrikleri kaydederiz:

- `num_tokens`: Hem istemler hem de tamamlamalar dahil olmak üzere şu ana kadar işlenen toplam token sayısı.
- `step_time`: Eğitim adımının (üretim dahil) ortalama süresi (saniye cinsinden).
- `completions/mean_length`: Üretilen tamamlamaların ortalama uzunluğu.
- `completions/min_length`: Üretilen tamamlamaların minimum uzunluğu.
- `completions/max_length`: Üretilen tamamlamaların maksimum uzunluğu.
- `completions/mean_terminated_length`: EOS ile sonlanan üretilen tamamlamaların ortalama uzunluğu.
- `completions/min_terminated_length`: EOS ile sonlanan üretilen tamamlamaların en küçük uzunluğu.
- `completions/max_terminated_length`: EOS ile sonlanan üretilen tamamlamaların maksimum uzunluğu.
- `completions/clipped_ratio`: Kesilen (kırpılan) tamamlamaların oranı.
- `rewards/{reward_func_name}/mean`: Belirli bir ödül fonksiyonundan gelen ortalama ödül.
- `rewards/{reward_func_name}/std`: Belirli bir ödül fonksiyonundan gelen ödülün standart sapması.
- `reward`: Fonksiyonlar üzerinden ödüllerin toplanmasının ardından (ağırlıkları `reward_weights` ile) elde edilen genel ortalama ödül.
- `reward_std`: Fonksiyonlar üzerinden toplanan ödül standart sapması (`reward_weights` ile ağırlıklandırılmış), tam batch üzerinde hesaplanır.
- `frac_reward_zero_std`: Üretim grubundaki örneklerin, ödül standart sapması sıfır olan (bu, o istem için çeşitliliğin az olduğunu, yani tüm yanıtların doğru veya yanlış olduğunu gösterir) oranı.
- `entropy`: Üretilen tamamlamalar boyunca token tahminlerinin ortalama entropisi. (`mask_truncated_completions=True` ise, maskelenmiş dizilerin tokenları hariç tutulur.)
- `aux_loss`: Bir Mixture-of-Experts modelinin, `router_aux_loss_coef` ile ölçeklenip kayba eklenmeden önceki yük dengeleme yardımcı kaybı. Sadece model bir MoE modeli olduğunda ve `router_aux_loss_coef` sıfır olmadığında kaydedilir.
- `kl`: Model ile referans model arasındaki ortalama KL sapması, üretilen tamamlamalar üzerinden hesaplanır. Yalnızca `beta` sıfırdan farklıysa kaydedilir.
- `clip_ratio/region_mean`: Güven bölgesi içinde kalacak şekilde RLOO hedefinin kırpıldığı (clipped) dizi olasılıklarının oranı:  \\( \text{clip}\left( r_{i}(\theta), 1 - \epsilon_\mathrm{low}, 1 + \epsilon_\mathrm{high} \right)\,, \quad r_{i}(\theta) = \frac{\pi_\theta(o_{i} \mid q)}{\pi_{\theta_{\text{old}}}(o_{i} \mid q)} \\). Daha yüksek bir değer, daha fazla örneğin kırpıldığı (clipped) anlamına gelir ve bu da $\pi_\theta$ politikasının ne kadar değişebileceğini kısıtlar.
- `clip_ratio/low_mean`: Güven bölgesinin alt sınırında kırpılan dizi olasılıklarının ortalama oranı:  \\(r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}\\).
- `clip_ratio/low_min`: Güven bölgesinin alt sınırındaki tamamlama başına en küçük kırpma göstergesi:  \\(r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}\\).
- `clip_ratio/high_mean`: Güven bölgesinin üst sınırında kırpılan dizi olasılıklarının ortalama oranı:  \\(r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}\\).
- `clip_ratio/high_max`: Güven bölgesinin üst sınırındaki tamamlama başına en büyük kırpma göstergesi:  \\(r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}\\).

## Özelleştirme

### vLLM destekli üretim ile eğitimi hızlandırın

Eğitim sırasında çevrimiçi yöntemler kullanıldığında üretim genellikle ana darboğazdır. Üretimi hızlandırmak için LLM'ler için yüksek verimli, düşük gecikmeli bir çıkarım motoru olan [vLLM](https://github.com/vllm-project/vllm)'yi kullanabilirsiniz. Bunu etkinleştirmek için önce paketi şu şekilde yükleyin

```shell
pip install trl[vllm]
```

Eğitim sırasında vLLM kullanımı için iki yöntemi destekliyoruz: **sunucu modu** ve **colocate modu**.

#### Seçenek 1: Colocate modu

Bu modda, vLLM eğitimci sürecinin içinde çalışır ve eğitim modeliyle GPU belleğini paylaşır. Bu, ayrı bir sunucu başlatılmasını önler ve GPU kullanımını artırabilir, ancak eğitim GPU'larında bellek çakışmasına yol açabilir. Bu, varsayılan moddur.

```python
from trl import RLOOConfig

training_args = RLOOConfig(
    ...,
    use_vllm=True,  # vllm_mode="colocate" by default
)
```

#### Seçenek 2: Sunucu modu

Bu modda, vLLM ayrı bir süreçte (ve ayrı GPU'lar kullanarak) çalışır ve eğitimciyle HTTP üzerinden iletişim kurar. Bu, çıkarım için ayrılmış GPU'larınız varsa idealdir.

1. **vLLM sunucusunu başlatın**:

   ```bash
   VLLM_SERVER_DEV_MODE=1 vllm serve <model_name> \
       --weight-transfer-config '{"backend": "nccl"}' \
       --logprobs-mode processed_logprobs \
       --max-logprobs -1
   ```

2. **Eğitim betiğinizde sunucu modunu etkinleştirin**:

   ```python
   from trl import RLOOConfig

   training_args = RLOOConfig(
       ...,
       use_vllm=True,
       vllm_mode="server",
   )
   ```

> [!WARNING]
> Sunucunun eğitimciyle farklı GPU'lar kullandığından emin olun, aksi takdirde NCCL hatalarıyla karşılaşabilirsiniz. Kullanılacak GPU'ları `CUDA_VISIBLE_DEVICES` ortam değişkeniyle belirleyebilirsiniz.

> [!TIP]
> Model boyutuna ve eğitim için genel GPU bellek gereksinimlerine bağlı olarak, düşük kullanım oranı veya bellek taşması hatalarını önlemek için [RLOOConfig](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOConfig) içindeki `vllm_gpu_memory_utilization` parametresini ayarlamanız gerekebilir.
>
> Model yapılandırmanıza ve deney ayarlarınıza dayalı olarak önerilen GPU bellek kullanımını tahmin etmenize yardımcı olmak için bir [HF Space](https://huggingface.co/spaces/trl-lib/recommend-vllm-memory) sunuyoruz. `vllm_gpu_memory_utilization` önerisini almak için aşağıdaki gibi kullanmanız yeterlidir:
>
> 
>
> Önerilen değer ortamınızda işe yaramıyorsa, istikrarı sağlamak için önerilen değere küçük bir pay (ör. +0.05 veya +0.1) eklemenizi öneririz.
>
> Hâlâ bellek dışı (out-of-memory) hataları alıyorsanız `vllm_enable_sleep_mode` değerini True olarak ayarlayın; bu durumda vllm parametreleri ve önbellek, optimizasyon adımı sırasında dışa aktarılır. Daha fazla bilgi için [vLLM Sleep Mode ile Bellek Kullanımını Azaltma](reducing_memory_usage#vllm-sleep-mode) başlıklı bölümü inceleyin.

> [!TIP]
> Varsayılan olarak RLOO, vLLM için `MASTER_ADDR=localhost` ve `MASTER_PORT=12345` değerlerini kullanır, ancak bu değerleri ortam değişkenlerini buna göre ayarlayarak geçersiz kılabilirsiniz.

Daha fazla bilgi için [vLLM ile eğitimi hızlandırma](speeding_up_training#vllm-for-fast-generation-in-online-methods) başlıklı bölümü inceleyin.

### RLOO ölçeğinde: birden fazla düğümde 70B+ Model eğitimi

**Qwen2.5-72B** gibi büyük modelleri eğitirken, eğitimin birden çok GPU ve düğüm arasında verimli ve ölçeklenebilir olması için birkaç temel optimizasyona ihtiyaç duyarsınız. Bunlar şunları içerir:

- **DeepSpeed ZeRO Stage 3**: ZeRO, model durumlarını (ağırlıklar, gradyanlar, optimizör durumları) birden fazla GPU ve CPU arasında dağıtmak için veri paralelliğinden yararlanarak her cihazdaki bellek ve hesaplama gereksinimlerini azaltır. Büyük modeller tek bir GPU'ya sığmadığından, bu tür modellerin eğitimi için ZeRO Stage 3 kullanılması gerekir. Daha fazla ayrıntı için [DeepSpeed Integration](deepspeed_integration) bölümüne bakın.
- **torchrun**: PyTorch'un başlatıcısı, her düğümde GPU başına bir süreç başlatır ve bunları ortak bir buluşma noktası üzerinden birbirine bağlar. Daha fazla ayrıntı için [Eğitimi Dağıtma](distributing_training) bölümüne bakın.
- **vLLM**: Üretim hızını artırmak için vLLM'in nasıl kullanılacağını görmek için önceki bölüme bakın.

Aşağıda, RLOO ile 70B parametreli bir modelin birden fazla düğümde eğitilmesi için örnek bir SLURM betiği yer almaktadır. Bu betik, modeli 4 düğümde eğitir ve vLLM destekli üretim için 5. düğümü kullanır.

```sh
#!/bin/bash
#SBATCH --nodes=5
#SBATCH --gres=gpu:8

# Get the list of allocated nodes
NODELIST=($(scontrol show hostnames $SLURM_JOB_NODELIST))

# Assign the first 4 nodes for training and the 5th node for vLLM
TRAIN_NODES="${NODELIST[@]:0:4}"  # Nodes 0, 1, 2, 3 for training
VLLM_NODE="${NODELIST[4]}"  # Node 4 for vLLM

# Run training on the first 4 nodes (Group 1)
srun --nodes=4 --ntasks=4 --nodelist="${NODELIST[@]:0:4}" torchrun \
     --nnodes 4 \
     --nproc_per_node 8 \
     --node_rank $SLURM_PROCID \
     --rdzv_backend c10d \
     --rdzv_endpoint ${NODELIST[0]}:29500 \
     train_rloo.py \
     --server_ip $VLLM_NODE &

# Run vLLM server on the 5th node (Group 2)
srun --nodes=1 --ntasks=1 --nodelist="${NODELIST[4]}" env VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen2.5-72B --tensor-parallel-size 8 \
    --weight-transfer-config '{"backend": "nccl"}' \
    --logprobs-mode processed_logprobs \
    --max-logprobs -1 &

wait
```

```python
import argparse

from datasets import load_dataset
from trl import RLOOTrainer, RLOOConfig

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--vllm_server_host", type=str, default="", help="The server IP")
    args = parser.parse_args()

    # Example dataset from TLDR
    dataset = load_dataset("trl-lib/tldr", split="train")

    # Dummy reward function: count the number of unique characters in the completions
    def reward_num_unique_chars(completions, **kwargs):
        return [len(set(c)) for c in completions]

    training_args = RLOOConfig(
        output_dir="Qwen2.5-72B-RLOO",
        per_device_train_batch_size=4,
        bf16=True,
        deepspeed="examples/deepspeed_configs/zero3.json",
        use_vllm=True,
        vllm_mode="server",
        vllm_server_host=args.vllm_server_host.replace("ip-", "").replace("-", "."),  # from ip-X-X-X-X to X.X.X.X
    )

    trainer = RLOOTrainer(model="Qwen/Qwen2.5-72B", args=training_args, reward_funcs=reward_num_unique_chars, train_dataset=dataset)
    trainer.train()

if __name__=="__main__":
    main()
```

### Özel bir ödül fonksiyonu kullanma

[RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer), yoğun ödül modelleri yerine özel ödül işlevlerinin kullanılmasını destekler. Uyumluluğu sağlamak için ödül işlevinizin aşağıdaki gereksinimleri karşılaması gerekir:

Ödül işlevleri, senkron Python çağrılabilirleri veya asenkron `async def` koro-rutinleri olabilir. Birden fazla asenkron ödül işlevi sağladığınızda, bunlar eşzamanlı olarak beklenir (`asyncio.gather` aracılığıyla paralel çalıştırılır) böylece gecikmeleri üst üste gelir.

1. **Girdi argümanları**:
   - Fonksiyon aşağıdakileri anahtar kelime argümanları olarak kabul etmelidir:
     - `prompts` (istemleri içerir),
     - `completions` (üretilen tamamlamaları içerir),
     - `completion_ids` (tokenize edilmiş tamamlamaları içerir),
     - `trainer_state` ([TrainerState](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerState)): Eğiticinin (trainer) mevcut durumu. Bu, eğitim ilerlemesine göre ödülün ayarlandığı müfredat öğrenimi (curriculum learning) gibi dinamik ödül fonksiyonlarını uygulamak için kullanılabilir.
     - `log_extra`: tamamlamalar tablosuna ek sütunlar eklemek için kullanılabilen `log_extra(column: str, values: list)` çağrılabilir bir nesne. Örnek 6'ya bakın.
     - `log_metric`: `kl`, `entropy` vb. metriklerin yanı sıra skaler metrikleri grafik olarak günlüğe kaydetmek için kullanılan, çağrılabilir `log_metric(name: str, value: float)`. Örnek 6'ya bakın.
     - Veri setinin sahip olabileceği tüm sütun adları (`prompt` hariç). Örneğin, veri seti `ground_truth` adında bir sütun içeriyorsa, fonksiyon `ground_truth` anahtar kelime argümanı olarak çağrılır.

     Bu gerekliliğe uymak için en kolay yol, fonksiyon imzasında `**kwargs` kullanmaktır.
   - Veri seti biçimine bağlı olarak girdi değişecektir:
     - [standart biçim](dataset_formats#standard) için `prompts` ve `completions` dizeleri listeleri olacaktır.
     - [sohbet formatı](dataset_formats#conversational) için `prompts` ve `completions`, mesaj sözlüklerinden oluşan listeler olacaktır.

2. **Dönüş değeri**: İşlev, birer tamamlamaya karşılık gelen ödülü temsil eden birer ondalık sayıdan oluşan bir liste döndürmelidir.

#### Örnek 1: Daha uzun tamamlamaları ödüllendirin

Aşağıda, daha uzun tamamlamaları ödüllendiren standart bir biçim için ödül fonksiyonu örneği verilmiştir:

```python
def reward_func(completion_ids, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of token count)."""
    return [float(len(ids)) for ids in completion_ids]
```

Bunu şu şekilde test edebilirsiniz:

```python
>>> prompts = ["The sky is", "The sun is"]  # not used in the reward function, but the trainer will pass it
>>> completions = [" blue.", " in the sky."]  # not used in the reward function, but the trainer will pass it
>>> completion_ids = [[6303, 13], [304, 279, 12884, 13]]
>>> reward_func(prompts=prompts, completions=completions, completion_ids=completion_ids)
[2.0, 4.0]
```

#### Örnek 1.1: Daha uzun tamamlamaları ödüllendir (karakter sayısına dayalı)

Önceki örnekle aynı, ancak bu sefer ödül fonksiyonu token sayısı yerine karakter sayısına dayanıyor.

```python
def reward_func(completions, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of character count)."""
    return [float(len(completion)) for completion in completions]
```

Bunu şu şekilde test edebilirsiniz:

```python
>>> prompts = ["The sky is", "The sun is"]
>>> completions = [" blue.", " in the sky."]
>>> completion_ids = [[6303, 13], [304, 279, 12884, 13]]  # not used in the reward function, but the trainer will pass it
>>> reward_func(prompts=prompts, completions=completions, completion_ids=completion_ids)
[6.0, 12.0]
```

#### Örnek 2: Belirli bir biçimde tamamlamaları ödüllendirme

Aşağıda, tamamlamanın belirli bir formata sahip olup olmadığını kontrol eden bir ödül fonksiyonu örneği yer almaktadır. Bu örnek, [DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning](https://huggingface.co/papers/2501.12948) makalesinde kullanılan _format reward_ fonksiyonundan ilham alınmıştır. İstemlerin ve tamamlamaların yapılandırılmış mesajlardan oluştuğu bir sohbet formatı için tasarlanmıştır.

```python
import re

def format_reward_func(completions, **kwargs):
    """Reward function that checks if the completion has a specific format."""
    pattern = r"^<think>.*?</think><answer>.*?</answer>$"
    completion_contents = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, content) for content in completion_contents]
    return [1.0 if match else 0.0 for match in matches]
```

Bu fonksiyonu şu şekilde test edebilirsiniz:

```python
>>> prompts = [
...     [{"role": "user", "content": "What is the result of (1 + 2) * 4?"}],
...     [{"role": "user", "content": "What is the result of (3 + 1) * 2?"}],
... ]
>>> completions = [
...     [{"role": "assistant", "content": "<think>The sum of 1 and 2 is 3, which we multiply by 4 to get 12.</think><answer>(1 + 2) * 4 = 12</answer>"}],
...     [{"role": "assistant", "content": "The sum of 3 and 1 is 4, which we multiply by 2 to get 8. So (3 + 1) * 2 = 8."}],
... ]
>>> format_reward_func(prompts=prompts, completions=completions)
[1.0, 0.0]
```

#### Örnek 3: Referansa dayalı tamamlamaları ödüllendirme

Aşağıda, tamamlamanın doğru olup olmadığını kontrol eden bir ödül fonksiyonu örneği yer almaktadır. Bu örnek, [DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning](https://huggingface.co/papers/2501.12948) makalesinde kullanılan _accuracy reward_ fonksiyonundan ilham alınmıştır. Bu örnek, veri setinin `ground_truth` adlı bir sütun içerdiği [standard format](dataset_formats#standard) için tasarlanmıştır.

```python
import re

def reward_func(completions, ground_truth, **kwargs):
    # Regular expression to capture content inside \boxed{}
    matches = [re.search(r"\\boxed\{(.*?)\}", completion) for completion in completions]
    contents = [match.group(1) if match else "" for match in matches]
    # Reward 1 if the content is the same as the ground truth, 0 otherwise
    return [1.0 if c == gt else 0.0 for c, gt in zip(contents, ground_truth)]
```

Bu fonksiyonu şu şekilde test edebilirsiniz:

```python
>>> prompts = ["Problem: Solve the equation $2x + 3 = 7$. Solution:", "Problem: Solve the equation $3x - 5 = 10$."]
>>> completions = [r" The solution is \boxed{2}.", r" The solution is \boxed{6}."]
>>> ground_truth = ["2", "5"]
>>> reward_func(prompts=prompts, completions=completions, ground_truth=ground_truth)
[1.0, 0.0]
```

#### Örnek 4: Çoklu görev ödül işlevleri

Aşağıda, [RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer) ile birden fazla ödül fonksiyonunun kullanımına dair bir örnek yer almaktadır. Bu örnekte, iki görev özel ödül fonksiyonu tanımlanır: `math_reward_func` ve `coding_reward_func`. `math_reward_func`, matematik problemlerini doğruluklarına göre ödüllendirirken, `coding_reward_func` kodlama problemlerini çözümün çalışıp çalışmadığına göre ödüllendirir.

```python
from datasets import Dataset
from trl import RLOOTrainer

# Define a dataset that contains both math and coding problems
dataset = Dataset.from_list(
    [
        {"prompt": "What is 2+2?", "task": "math"},
        {"prompt": "Write a function that returns the sum of two numbers.", "task": "code"},
        {"prompt": "What is 3*4?", "task": "math"},
        {"prompt": "Write a function that returns the product of two numbers.", "task": "code"},
    ]
)

# Math-specific reward function
def math_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "math":
            # Calculate math-specific reward
            correct = check_math_solution(prompt, completion)
            reward = 1.0 if correct else -1.0
            rewards.append(reward)
        else:
            # Return None for non-math tasks
            rewards.append(None)
    return rewards

# Coding-specific reward function
def coding_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "code":
            # Calculate coding-specific reward
            works = test_code_solution(prompt, completion)
            reward = 1.0 if works else -1.0
            rewards.append(reward)
        else:
            # Return None for non-coding tasks
            rewards.append(None)
    return rewards

# Use both task-specific reward functions
trainer = RLOOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=[math_reward_func, coding_reward_func],
    train_dataset=dataset,
)

trainer.train()
```

Bu örnekte `math_reward_func` ve `coding_reward_func`, hem matematik hem de kodlama problemleri içeren karışık bir veri setiyle çalışacak şekilde tasarlanmıştır. Veri setindeki `task` sütunu, her probleme hangi ödül fonksiyonunun uygulanacağını belirlemek için kullanılır. Veri setindeki bir örnek için ilgili bir ödül fonksiyonu yoksa, ödül fonksiyonu `None` döndürür ve [RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer) geçerli fonksiyonlar ve görevlerle devam eder. Bu, [RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer)'ın farklı uygulama alanlarına sahip birden fazla ödül fonksiyonunu işleyebilmesini sağlar.

[RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer)'in, ödül fonksiyonları tarafından döndürülen `None` ödüllerini yoksayacağını ve yalnızca ilgili fonksiyonlar tarafından döndürülen ödüleri dikkate alacağını unutmayın. Bu, modelin yalnızca ilgili görevler üzerinde eğitilmesini ve ilgili ödül fonksiyonu olmayan görevlerin yoksayılmasını sağlar.

#### Örnek 5: Asenkron ödül işlevleri

Özel ödül fonksiyonları ayrıca `async def` koro-rutinleri olarak da tanımlanabilir. Ödülünüz yavaş GÇ'ye (örneğin, uzak bir servise çağrı yapma) bağlıysa bu işe yarar. Birden çok asenkron ödül fonksiyonu geçirdiğinizde [RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer) bunları eşzamanlı olarak çalıştırır ve gecikmeleri üst üste bindirir.

Aşağıda, I/O yoğun bir işlemi simüle eden asenkron bir ödül fonksiyonunun minimal bir örneği yer almaktadır:

```python
import asyncio

async def async_reward_func(prompts, completions, **kwargs):
    # Simulate an I/O-bound call (e.g., HTTP request, database lookup)
    await asyncio.sleep(0.01)
    # Simple toy reward: 1.0 if the completion is non-empty, else 0.0
    return [1.0 if completion else 0.0 for completion in completions]
```

#### Örnek 6: Ek sütunlar ve metrikler kaydetme

Aşağıda, tamamlamalar tablosuna ek sütunlar ve skaler metrikleri grafikler olarak kaydeden bir ödül fonksiyonu örneği yer almaktadır.

```python
import re

def reward_func(completions, ground_truth, log_extra=None, log_metric=None, **kwargs):
    extracted = [re.search(r"\\boxed\{(.*?)\}", c) for c in completions]
    extracted = [m.group(1) if m else None for m in extracted]
    rewards = [1.0 if e == gt else 0.0 for e, gt in zip(extracted, ground_truth)]

    if log_extra:
        log_extra("golden_answer", list(ground_truth))
        log_extra("extracted_answer", [e or "[none]" for e in extracted])

    if log_metric:
        log_metric("accuracy", sum(rewards) / len(rewards))

    return rewards
```

#### Ödül fonksiyonunu eğitimciye (trainer) iletme

Özel ödül fonksiyonunuzu kullanmak için bunu [RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer) sınıfına aşağıdaki gibi iletin:

```python
from trl import RLOOTrainer

trainer = RLOOTrainer(
    reward_funcs=reward_func,
    ...,
)
```

Birden fazla ödül fonksiyonunu bir liste olarak iletebilirsiniz; bu liste hem senkron hem de asenkron fonksiyonlar içerebilir:

```python
from trl import RLOOTrainer

trainer = RLOOTrainer(
    reward_funcs=[reward_func, async_reward_func1, async_reward_func2],
    ...,
)
```

ve ödül, her bir fonksiyondan gelen ödüllerin toplamı olarak veya yapılandırmada `reward_weights` sağlanırsa ağırlıklı toplam olarak hesaplanır.

[RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer)'in farklı türlerde birden fazla ödül fonksiyonunu desteklediğini unutmayın. Daha fazla ayrıntı için parametre dokümantasyonuna bakın.

## Görsel Dil Modellerinin Eğitimi

RLOO, hem metin hem de görüntü içeren çok modlu veri setlerinde Görüntü-Dil Modelleri (VLM) eğitimi destekler.

### Desteklenen Modeller

Test edildi:

- **Gemma3** — örn. `google/gemma-3-4b-it`
- **LLaVA-NeXT** — örn. `llava-hf/llava-v1.6-mistral-7b-hf`
- **Qwen2-VL** — örn. `Qwen/Qwen2-VL-2B-Instruct`
- **Qwen2.5-VL** — örn. `Qwen/Qwen2.5-VL-3B-Instruct`
- **SmolVLM2** — örn. `HuggingFaceTB/SmolVLM2-2.2B-Instruct`

> [!TIP]
> Tüm VLM'lerle uyumluluk garanti edilmemektedir. Bir modelin desteklenmesi gerektiğini düşünüyorsanız, GitHub'da bir sorun (issue) açmaktan çekinmeyin — ya da daha iyisi, gerekli değişiklikleri içeren bir çekme isteği (pull request) gönderin.

### Hızlı Başlangıç

Bir VLM'yi ince ayar yapmak için [rloo\_vlm.py](https://github.com/huggingface/trl/blob/main/examples/rloo_visual_math/rloo_visual_math.py) dosyasını kullanın. [`lmms-lab/multimodal-open-r1-8k-verified`](https://huggingface.co/datasets/lmms-lab/multimodal-open-r1-8k-verified) üzerinde eğitim için örnek komut:

```bash
torchrun --nproc_per_node 8 examples/rloo_visual_math/rloo_visual_math.py \
  --deepspeed examples/deepspeed_configs/zero3.json \
  --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
  --output_dir rloo-Qwen2.5-VL-3B-Instruct \
  --learning_rate 1e-5 \
  --dtype bfloat16 \
  --max_completion_length 1024 \
  --use_vllm \
  --vllm_mode colocate \
  --use_peft \
  --lora_target_modules "q_proj", "v_proj" \
  --log_completions
```

### Yapılandırma İpuçları

- Görüntü-dil projeksiyon katmanlarında LoRA kullanın
- Bellek kullanımını azaltmak için 4-bit kuantizasyonu etkinleştirin
- VLM'ler bellek yoğun — daha küçük batch boyutlarıyla başlayın
- Çoğu model vLLM ile uyumludur (`server` ve `colocate` modları)

### Veri Seti Biçimi

Her eğitim örneği şunları içermelidir:

- `prompt`: İşleyicinin sohbet şablonu aracılığıyla biçimlendirilmiş metin
- `image`/`images`: PIL Image veya PIL Image listesi

Trainer, modelin görüntü işleyicisi aracılığıyla görüntüden tensöre dönüşümü otomatik olarak yönetir.

## RLOOTrainer[[trl.RLOOTrainer]]

#### trl.RLOOTrainer[[trl.RLOOTrainer]]

```python
trl.RLOOTrainer(model: str | PreTrainedModel | PeftModel, reward_funcs: str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]] | list[str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]]], args: trl.trainer.rloo_config.RLOOConfig | None = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, reward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.2/trl/trainer/rloo_trainer.py#L113)

**Parametreler:**

model (`str` veya [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) veya [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.PeftModel)) : Eğitilecek model. Şunlardan biri olabilir:  - huggingface.co üzerindeki bir model deposunda barındırılan önceden eğitilmiş bir modelin *model kimliği* olan bir dize veya [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained) kullanılarak kaydedilmiş model ağırlıklarını içeren bir *dizin* yolu, örn. `'./my_model_directory/'`. Model, `args.model_init_kwargs` içindeki anahtar kelime argümanlarıyla `<ModelArchitecture>.from_pretrained` (burada `<ModelArchitecture>`, model yapılandırmasından türetilir) kullanılarak yüklenir. `dtype`, `args.model_init_kwargs` içinde belirtilmediyse, varsayılan olarak `float32` olur. Bu, (Transformers v5'ten itibaren) dtype'ın model yapılandırmasından çıkarıldığı [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained) işlevinden farklıdır. - Bir [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) nesnesi. Yalnızca nedensel dil modelleri desteklenir. - Bir [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.PeftModel) nesnesi. Yalnızca nedensel dil modelleri desteklenir.

reward_funcs (`RewardFunc | list[RewardFunc]`) : Ödül hesaplama için kullanılacak ödül işlevleri. Ödüllerin hesaplanması için tüm ödül işlevleri, istemler (prompts) ve tamamlamalar (completions) ile çağrılır ve ödüller toplanır. Aşağıdakilerden biri olabilir:  - Tek bir ödül işlevi, örneğin: - Bir dize: huggingface.co üzerindeki bir model deposunda barındırılan önceden eğitilmiş bir modelin *model kimliği* (model ID) veya [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained) kullanılarak kaydedilmiş model ağırlıklarını içeren bir *dizin* yolu, örneğin `'./my_model_directory/'`. Model, `num_labels=1` ve `args.model_init_kwargs` içindeki anahtar kelime argümanları ile [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForSequenceClassification.from_pretrained) kullanılarak yüklenir. - Bir [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) nesnesi: Yalnızca dizi sınıflandırma modelleri desteklenir. - Özel bir ödül işlevi: İşlev, istemler ve üretilen tamamlamalarla birlikte veri setindeki ek sütunlarla sağlanır. Bir ödül listesi döndürmelidir. Özel ödül işlevleri senkron veya asenkron olabilir ve ödülün o örnekler için geçerli olmadığı durumlarda `None` döndürebilir. Bu, farklı ödül işlevlerinin farklı türdeki örnekler için uygulandığı çoklu görev eğitiminde (multi-task training) faydalıdır. Bir ödül işlevi bir örnek için `None` döndürdüğünde, o ödül işlevi o örnek için ödül hesabından hariç tutulur. Daha fazla ayrıntı için [Özel bir ödül işlevi kullanma](#using-a-custom-reward-function) bölümüne bakın.  Eğitmenin (trainer) durumu da ödül işlevine iletilir. Eğitmenin durumu, [TrainerState](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerState) örneğidir ve ödül işlevinin imzasındaki `trainer_state` argümanına erişilerek erişilebilir. - Ödül işlevleri listesi, her öğe bağımsız olarak yukarıdaki türlerden herhangi biri olabilir. Listede farklı türlerin karıştırılması (örneğin, bir dize model kimliği ve özel bir ödül işlevi) izin verilir.

args ([RLOOConfig](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOConfig), *isteğe bağlı*) : Bu eğitimci için yapılandırma. `None` ise varsayılan yapılandırma kullanılır.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) veya [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : Eğitim için kullanılacak veri seti. `"prompt"` adlı bir sütun içermelidir. Veri setindeki ek sütunlar yok sayılır. Örneklerin biçimi şu iki seçenekten biri olabilir:  - [Standart](dataset_formats#standard): Her örnek düz metin içerir. - [Konuşma](dataset_formats#conversational): Her örnek yapılandırılmış mesajlar (ör. rol ve içerik) içerir.  `train_dataset` bir [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset) ise (ör. bir akış veri seti), uzunluğu çıkarılamadığı ve eğitim döngüsünü sınırlamak ile öğrenme oranı zamanlayıcısını yapılandırmak için toplam eğitim adım sayısının bilinmesi gerektiğinden, `max_steps` eğitim argümanlarında tanımlanmalıdır.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset), [DatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.DatasetDict), [IterableDatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDatasetDict) veya `dict[str, Dataset | IterableDataset]`) : Değerlendirme için kullanılacak veri seti. `train_dataset` ile aynı gereksinimleri karşılaması gerekir.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), [ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.ProcessorMixin), *isteğe bağlı*) : Verileri işlemek için kullanılan işleme sınıfı. Dolgu tarafı "left" olarak ayarlanmalıdır. `None` ise, işleme sınıfı [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained) ile modelin adından yüklenir. Bir dolgu belirteci, `tokenizer.pad_token`, ayarlanmalıdır. İşleme sınıfı bir dolgu belirteci ayarlamadıysa, varsayılan olarak `tokenizer.eos_token` kullanılır.

reward_processing_classes ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) veya `list[PreTrainedTokenizerBase]`, *isteğe bağlı*) : `reward_funcs` içinde belirtilen ödül fonksiyonlarına karşılık gelen işleme sınıfları. Şu şekillerden biri olabilir:  - Tek bir işleme sınıfı: `reward_funcs` yalnızca bir ödül fonksiyonu içerdiğinde kullanılır. - İşleme sınıfları listesi: `reward_funcs` içindeki ödül fonksiyonlarının sırası ve uzunluğuyla eşleşmelidir. `None` olarak ayarlanırsa veya [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) olan bir öğeye karşılık gelen listenin öğesi `None` ise, modelin tokenizer'ı [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained) kullanılarak otomatik olarak yüklenir. `reward_funcs` içindeki özel ödül fonksiyonları (yani [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) olmayanlar) için, `reward_processing_classes` içindeki karşılık gelen girdiler yok sayılır.

callbacks ([TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerCallback) listesi, *isteğe bağlı*) : Eğitim döngüsünü özelleştirmek için geri çağrılar listesi. Bunlar, [burada](https://huggingface.co/docs/transformers/main_classes/callback) ayrıntıları verilen varsayılan geri çağrılar listesine eklenecektir. Kullanılan varsayılan geri çağrılardan birini kaldırmak istiyorsanız, [remove_callback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer.remove_callback) yöntemini kullanın.

optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *opsiyonel*, varsayılan `(None, None)`) : Kullanılacak optimizörün ve zamanlayıcının yer aldığı bir tuple. Modeliniz üzerinde bir `AdamW` örneği ve `args` tarafından kontrol edilen [get_linear_schedule_with_warmup](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) tarafından verilen bir zamanlayıcı olarak varsayılan değerlere sahip olacaktır.

quantization_config ([BitsAndBytesConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/quantization#transformers.BitsAndBytesConfig), *isteğe bağlı*) : Model bir model tanımlayıcısından yüklenirken kullanılan kuantizasyon yapılandırması. QLoRA eğitimi için `peft_config` ile birleştirin. Model zaten örneklenmişse yok sayılır.

peft_config ([PeftConfig](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/config#peft.PeftConfig), *isteğe bağlı*) : Modeli sarmak için kullanılan PEFT yapılandırması. `None` ise model sarılmaz.

Reinforce Leave One Out (RLOO) yöntemi için Trainer. Bu algoritma ilk olarak [Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMs](https://huggingface.co/papers/2402.14740) makalesinde önerilmiştir.

Örnek:

```python
>>> from trl import RLOOTrainer
>>> from trl.rewards import accuracy_reward
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

>>> trainer = RLOOTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     reward_funcs=accuracy_reward,
...     train_dataset=dataset,
... )
>>> trainer.train()
```

#### train[[trl.RLOOTrainer.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.2/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.RLOOTrainer.save_model]]

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

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.2/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.RLOOTrainer.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.2/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.

## RLOOConfig[[trl.RLOOConfig]]

#### trl.RLOOConfig[[trl.RLOOConfig]]

```python
trl.RLOOConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 1e-06, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool | None = False, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, router_aux_loss_coef: float | None = None, disable_dropout: bool = False, num_generations: int | None = 2, num_generations_eval: int | None = None, max_completion_length: int | None = 512, ds3_gather_for_generation: bool = True, shuffle_dataset: bool | None = True, pad_to_multiple_of: int | str | None = 'auto', generation_batch_size: int | None = None, steps_per_generation: int | None = None, temperature: float = 1.0, top_p: float = 1.0, top_k: int = 0, min_p: float | None = None, generation_kwargs: dict | str | None = None, chat_template_kwargs: dict | str | None = None, repetition_penalty: float = 1.0, cache_implementation: str | None = None, use_vllm: bool = False, vllm_mode: str = 'colocate', vllm_model_impl: str = 'vllm', vllm_enable_sleep_mode: bool = False, vllm_structured_outputs_regex: str | None = None, vllm_server_base_url: str | None = None, vllm_server_host: str = '0.0.0.0', vllm_server_port: int = 8000, vllm_server_timeout: float = 240.0, vllm_group_port: int = 51216, vllm_gpu_memory_utilization: float = 0.3, vllm_max_model_length: int | None = None, vllm_tensor_parallel_size: int = 1, beta: float = 0.05, num_iterations: int = 1, epsilon: float = 0.2, epsilon_high: float | None = None, reward_weights: list[float] | None = None, normalize_advantages: bool = False, reward_clip_range: tuple[float, float] | None = None, mask_truncated_completions: bool = False, sync_ref_model: bool = False, ref_model_mixup_alpha: float = 0.6, ref_model_sync_steps: int = 512, log_completions: bool = False, log_multimodal: bool = True, num_completions_to_print: int | None = None, log_unique_prompts: bool = False, use_transformers_continuous_batching: bool = False, transformers_continuous_batching_config: dict | str | None = None, use_transformers_paged: bool = False)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.2/trl/trainer/rloo_config.py#L23)

**Modeli ve referans modeli kontrol eden parametreler:**

model_init_kwargs (`str` veya `dict[str, Any]`, *isteğe bağlı*) : [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) için anahtar kelime argümanları, [RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer)'in `model` argümanı bir dize olarak verildiğinde kullanılır. `revision` değeri, işleme sınıfları yüklenirken de kullanılır.

trust_remote_code (`bool`, *isteğe bağlı*, varsayılan `False`) : Hub'dan özel Python kodu içeren modellerin ve tokenizer'ların yüklenmesine izin verilip verilmeyeceğini belirtir. [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) ve [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained) fonksiyonlarına iletilir. Ödül modeli ve ödül tokenizer'ı yüklemelerine de uygulanır.

router_aux_loss_coef (`float`, *opsiyonel*) : Mixture-of-Experts (MoE) modelleri için yük dengeleme yardımcı kaybının katsayısı, eğitim kaybına bu ağırlıkla eklenir. Ayarlanmadığında, model yapılandırmasında beyan edilen değer kullanılır. Devre dışı bırakmak için `0.0` olarak ayarlayın. MoE olmayan bir modelle kullanıldığında hata verir.

disable_dropout (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelde dropout'un devre dışı bırakılıp bırakılmayacağını belirtir. Bu, referans model ile eğitim sırasında faydalıdır, çünkü modelin aynı giriş için farklı logprobs üretmesini engeller.

**Veri ön işleme sürecini kontrol eden parametreler:**

remove_unused_columns (`bool`, *isteğe bağlı*, varsayılan `False`) : Veri setinde yalnızca `"prompt"` sütununun korunup korunmayacağını belirtir. `"prompts"` ve `"completions"` dışında herhangi bir sütun gerektiren özel bir ödül işlevi kullanıyorsanız, bu değeri `False` olarak bırakmalısınız.

num_generations (`int`, *isteğe bağlı*, varsayılan `2`) : Her istem için örneklenmesi gereken nesil sayısı. Etkili parti boyutu (num_processes * per_device_batch_size * gradient_accumulation_steps) bu değere tam bölünmelidir.

num_generations_eval (`int`, *opsiyonel*) : Değerlendirme sırasında örneklenmesi gereken nesil sayısı. Bu, hesaplama tasarrufu sağlamak için değerlendirme sırasında daha az nesil kullanılmasına olanak tanır. `None` ise `num_generations` değeri kullanılır.

max_completion_length (`int` veya `None`, *isteğe bağlı*, varsayılan `512`) : Üretilen tamamlamanın maksimum uzunluğu.

ds3_gather_for_generation (`bool`, *isteğe bağlı*, varsayılan `True`) : Bu ayar DeepSpeed ZeRO-3 için geçerlidir. Etkinleştirilirse, üretim için politika model ağırlıkları toplanır ve üretim hızı artırılır. Ancak bu seçeneğin devre dışı bırakılması, tek bir GPU'nun VRAM kapasitesini aşan modellerin eğitimine olanak tanır; bunun bedeli ise daha yavaş bir üretimdir. Bu seçeneğin devre dışı bırakılması, vLLM üretimiyle uyumlu değildir.

shuffle_dataset (`bool`, *isteğe bağlı*, varsayılan `True`) : Eğitim veri setinin karıştırılıp karıştırılmayacağını belirtir.

pad_to_multiple_of (`int` veya `str`, *isteğe bağlı*, varsayılan `"auto"`) : Ayarlanırsa, prompt kimlikleri ve tamamlama kimlikleri bu değerin katına yastıklanır. `"auto"`, Neuron (AWS Trainium) üzerinde her giriş şekli için bir kez derlendiğinden 128'in katına yastıklar, başka yerlerde yastıklama yapmaz.

**Üretimi kontrol eden parametreler:**

generation_batch_size (`int`, *isteğe bağlı*) : Üretim için kullanılacak parti boyutu. `None` ise, etkin eğitim parti boyutuna ayarlanır: `per_device_train_batch_size * num_processes * steps_per_generation`. Başka bir deyişle, her optimizasyon adımı için bir üretim partisi işlenir. `steps_per_generation` ile birbirini dışlar.

steps_per_generation (`int`, *isteğe bağlı*) : Üretim başına adım sayısı. `None` ise, varsayılan olarak `gradient_accumulation_steps` değerini alır. `generation_batch_size` ile birlikte kullanılamaz.

temperature (`float`, *isteğe bağlı*, varsayılan `1.0`) : Örnekleme için sıcaklık. Sıcaklık ne kadar yüksekse, tamamlamalar o kadar rastgele olur.

top_p (`float`, *opsiyonel*, varsayılan `1.0`) : Dikkate alınacak üst tokenların kümülatif olasılığını kontrol eden bir `float`. (0, 1] aralığında olmalıdır. Tüm tokenları dikkate almak için `1.0` olarak ayarlayın.

top_k (`int`, *opsiyonel*, varsayılan `0`) : top-k filtreleme için en yüksek olasılığa sahip kaç sözlük token'ının tutulacağı. `0` ise top-k filtreleme devre dışıdır ve tüm token'lar dikkate alınır.

min_p (`float`, *isteğe bağlı*) : En olası token'ın olasılığıyla ölçeklenecek olan minimum token olasılığı. `0.0` ile `1.0` arasında bir değer olmalıdır. Tipik değerler `0.01-0.2` aralığındadır.

generation_kwargs (`dict[str, Any]`, *isteğe bağlı*) : Tamamlamalar örneklenirken [GenerationConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/text_generation#transformers.GenerationConfig)'e (transformers kullanılıyorsa) veya `SamplingParams`'e (vLLM kullanılıyorsa) iletilecek ek anahtar kelime argümanları. Üretim davranışını daha da özelleştirmek için, örneğin `suppress_tokens`, `num_beams` gibi ayarları yapmak için kullanılabilir. Diğer üretim parametreleriyle (örneğin `min_p`, `top_p` vb.) çakışan anahtarlar içeriyorsa, bunları geçersiz kılar.

chat_template_kwargs (`dict[str, Any]`, *isteğe bağlı*) : Tamamlamalar oluşturulurken `apply_chat_template` fonksiyonuna iletilecek ek anahtar kelime argümanları.

repetition_penalty (`float`, *opsiyonel*, varsayılan `1.0`) : İstekte ve şu ana kadar üretilen metinde görünüp görünmediklerine göre yeni token'ları cezalandıran bir sayı. > `1.0` değerleri modelin yeni token'lar kullanmasını teşvik ederken, < `1.0` değerleri modelin token'ları tekrarlamasını teşvik eder.

cache_implementation (`str`, *isteğe bağlı*) : `use_vllm` `False` olarak ayarlandığında daha hızlı üretim için cache yönteminin uygulaması.

**vLLM tarafından desteklenen üretim hızlandırmasını kontrol eden parametreler:**

use_vllm (`bool`, *isteğe bağlı*, varsayılan `False`) : Tamamlamaları üretmek için vLLM kullanılacak mı? `True` olarak ayarlanırsa, eğitimci üretim için varsayılan model.generate() yerine vLLM kullanır. Bunun için `vllm`'in yüklü olması gerekir.

vllm_mode (`str`, *isteğe bağlı*, varsayılan `"colocate"`) : `use_vllm` `True` olarak ayarlandığında vLLM entegrasyonu için kullanılacak mod. `"server"` veya `"colocate"` değerlerinden biri olmalıdır. - `"server"`: Eğitimci, üretim isteklerini ayrı bir vLLM sunucusuna gönderir. Bir vLLM sunucusunun çalıştığından emin olun (`vllm serve` ile başlatın). - `"colocate"`: vLLM aynı süreçte çalışır ve eğitim GPU'larını paylaşır. Bu, ayrı bir sunucuya olan ihtiyacı ortadan kaldırır ancak eğitimle kaynak çakışmasına neden olabilir.

vllm_model_impl (`str`, *isteğe bağlı*, varsayılan `"vllm"`) : vLLM için kullanılacak model uygulaması. `"transformers"` veya `"vllm"` değerlerinden biri olmalıdır. `"transformers"`: Model uygulaması için `transformers` arka ucunu kullanın. `"vllm"`: Model uygulaması için `vllm` kütüphanesini kullanın.

vllm_enable_sleep_mode (`bool`, *isteğe bağlı*, varsayılan `False`) : Optimizer adımında ağırlık/önbelleğin dışa aktarılmasını sağlamak için vLLM uyku modunu etkinleştirir. GPU bellek kullanımını düşük tutar, ancak motorun uyanması host–cihaz aktarma gecikmesi ekler.

vllm_structured_outputs_regex (`str`, *isteğe bağlı*) : vLLM yapılandırılmış çıktıları için regex. `None` (varsayılan) ise yapılandırılmış çıktılar devre dışıdır.

**vLLM sunucusunu kontrol eden parametreler (yalnızca `vllm_mode` değeri `"server"` olduğunda kullanılır):**

vllm_server_base_url (`str`, *isteğe bağlı*) : vLLM sunucusu için temel URL (ör. `"http://localhost:8000"`). Sağlanırsa, `vllm_server_host` ve `vllm_server_port` yok sayılır.

vllm_server_host (`str`, *isteğe bağlı*, varsayılan `"0.0.0.0"`) : Bağlanacak vLLM sunucusunun ana makinesi. `vllm_server_base_url` sağlanırsa yok sayılır.

vllm_server_port (`int`, *isteğe bağlı*, varsayılan `8000`) : Bağlanacak vLLM sunucusunun portu. `vllm_server_base_url` sağlanıyorsa yok sayılır.

vllm_server_timeout (`float`, *isteğe bağlı*, varsayılan `240.0`) : vLLM sunucusunun ayağa kalkmasını beklemek için saniye cinsinden toplam zaman aşımı süresi. Zaman aşımı sonrasında sunucu hâlâ ayağa kalkmadıysa bir `ConnectionError` yükseltilir.

vllm_group_port (`int`, *isteğe bağlı*, varsayılan `51216`) : Ağırlık güncelleme grubu için port numarası. Bu, vLLM sunucusuyla iletişim kurmak için kullanılır. Port meşgul değilse değiştirmeye gerek yoktur.

**Colocate vLLM çalıştırmayı kontrol eden parametreler (yalnızca `vllm_mode` `"colocate"` olduğunda kullanılır):**

vllm_gpu_memory_utilization (`float`, *isteğe bağlı*, varsayılan `0.3`) : vLLM için GPU bellek kullanımını kontrol eder. Bu ayar yalnızca `vllm_mode` `"colocate"` olarak ayarlandığında geçerlidir. `vllm_mode="server"` kullanıyorsanız, bu parametrenin vLLM sunucusunu `--vllm_gpu_memory_utilization` bayrağıyla başlatırken ayrı olarak geçirilmesi gerekir.

vllm_max_model_length (`int`, *isteğe bağlı*) : vLLM için bağlam penceresi. Veri setindeki en uzun istem uzunluğuna `max_completion_length` eklenmiş değere ayarlayın; belirtilmezse model yapılandırmasından çıkarılır.

vllm_tensor_parallel_size (`int`, *isteğe bağlı*, varsayılan `1`) : vLLM için tensör paralel boyutunu kontrol eder. Bu ayar yalnızca `vllm_mode` `"colocate"` olarak ayarlandığında geçerlidir. `vllm_mode="server"` kullanıyorsanız, bu parametrenin vLLM sunucusunu `--vllm_tensor_parallel_size` bayrağıyla başlatırken ayrı olarak geçirilmesi gerekir.

**Eğitimi kontrol eden parametreler:**

beta (`float`, *isteğe bağlı*, varsayılan `0.05`) : KL katsayısı. `0.0` ise referans model yüklenmez, bu da bellek kullanımını azaltır ve eğitim hızını artırır.

num_iterations (`int`, *isteğe bağlı*, varsayılan `1`) : Parti başına yineleme sayısı (algoritmada μ olarak gösterilir).

epsilon (`float`, *opsiyonel*, varsayılan `0.2`) : Kırpma için epsilon değeri.

epsilon_high (`float`, *isteğe bağlı*) : Kırpma için üst sınır epsilon değeri. Belirtilmezse, `epsilon` argümanında belirtilen alt sınır değeriyle aynı varsayılan değeri kullanır. [DAPO](https://huggingface.co/papers/2503.14476) makalesi `0.28` değerini önerir.

reward_weights (`list[float]`, *isteğe bağlı*) : Her ödül fonksiyonu için ağırlıklar. Ödül fonksiyonlarının sayısıyla eşleşmelidir. `None` ise, tüm ödüller `1.0` ağırlığıyla eşit olarak ağırlıklandırılır.

normalize_advantages (`bool`, *isteğe bağlı*, varsayılan `False`) : Avantajların normalize edilip edilmeyeceğini belirtir. Normalizasyon, ortalamanın `0.0` ve standart sapmanın `1.0` olması için her üretim partisi için yapılır.

reward_clip_range (`tuple[float, float]`, *isteğe bağlı*) : Ödüller için (min, max) olarak kırpma aralığı. `None` ise kırpma uygulanmaz.

mask_truncated_completions (`bool`, *isteğe bağlı*, varsayılan `False`) : Etkinleştirildiğinde, kesilen tamamlamalar kayıp hesabından hariç tutulur; böylece yanlışlıkla cezalandırılmaları ve eğitim sırasında gürültüye yol açmaları önlenir. [DAPO](https://huggingface.co/papers/2503.14476) makalesine göre bu, eğitim kararlılığı için iyi bir uygulamadır.

sync_ref_model (`bool`, *isteğe bağlı*, varsayılan `False`) : `ref_model_mixup_alpha` parametresini kullanarak, her `ref_model_sync_steps` adımda referans modelin aktif modelle senkronize edilip edilmeyeceğini belirtir. Bu senkronizasyon [TR-DPO](https://huggingface.co/papers/2404.09656) makalesinden kaynaklanmaktadır.

ref_model_mixup_alpha (`float`, *isteğe bağlı*, varsayılan `0.6`) : [TR-DPO](https://huggingface.co/papers/2404.09656) makalesinden gelen, güncellemeler sırasında mevcut politika ile önceki referans politika arasındaki karışımı kontrol eden α parametresi. Referans politika şu denklemine göre güncellenir: `π_ref = α * π_θ + (1 - α) * π_ref_prev`. Bu parametreyi kullanmak için `sync_ref_model=True` değerini ayarlamanız gerekir.

ref_model_sync_steps (`int`, *isteğe bağlı*, varsayılan `512`) : [TR-DPO](https://huggingface.co/papers/2404.09656) makalesinden gelen τ parametresi, mevcut politikanın referans politika ile ne sıklıkta senkronize edileceğini belirler. Bu parametreyi kullanmak için `sync_ref_model=True` değerini ayarlamanız gerekir.

**Kayıtları kontrol eden parametreler:**

log_completions (`bool`, *isteğe bağlı*, varsayılan `False`) : Her `logging_steps` adımında (prompt, completion) çiftlerinin bir örneğinin günlüğe kaydedilip kaydedilmeyeceğini belirtir. `rich` yüklüyse, örnek yazdırılır. `wandb` ve/veya `trackio` günlüğü etkinleştirildiyse, `wandb` ve/veya `trackio` üzerinden günlüğe kaydedilir.

log_multimodal (`bool`, *isteğe bağlı*, varsayılan `True`) : Tamamlamalarla birlikte çok modlu içeriğin (görseller, videolar vb.) günlüklenip günlüklenmeyeceğini belirler. Yüksek çözünürlüklü çok modlu veriler kullanırken günlük boyutunu azaltmak için bunu devre dışı bırakın.

num_completions_to_print (`int`, *isteğe bağlı*) : `rich` ile yazdırılacak tamamlama sayısı. `None` ise tüm tamamlamalar günlüğe kaydedilir.

log_unique_prompts (`bool`, *isteğe bağlı*, varsayılan `False`) : Benzersiz istemlerin (prompts) kaydedilip kaydedilmeyeceğini belirtir. `True` ise yalnızca benzersiz istemler kaydedilir. `False` ise tüm istemler kaydedilir.

**Transformers sürekli toplama (continuous batching) ile güçlendirilen üretim hızlandırmasını kontrol eden parametreler:**

use_transformers_continuous_batching (`bool`, *isteğe bağlı*, varsayılan `False`) : Tamamlamaları üretmek için transformers'ın sürekli toplama (continuous batching) motorunun kullanılıp kullanılmayacağını belirtir. `transformers>=5.8.0` gerektirir.

transformers_continuous_batching_config (`dict`, *isteğe bağlı*) : `ContinuousBatchingConfig` için anahtar kelime argümanları.

**Kullanımdan kaldırılan parametreler:**

use_transformers_paged :   `use_transformers_paged` parametresi kullanımdan kaldırılmıştır ve v2.0.0 sürümünde kaldırılacaktır. Bunun yerine `use_transformers_continuous_batching` kullanın.

[RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer) için yapılandırma sınıfı.

Bu sınıf yalnızca RLOO eğitimine özgü parametreleri içerir. Eğitim argümanlarının tam listesi için lütfen [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) belgelerine başvurun. Bu sınıftaki varsayılan değerlerin, [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) içindeki değerlerden farklı olabileceğini unutmayın.

[HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser) kullanarak bu sınıfı, komut satırında belirtilebilen [argparse](https://docs.python.org/3/library/argparse#module-argparse) argümanlarına dönüştürebiliriz.

> [!NOTE]
> Bu parametrelere atanmış varsayılan değerler, [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) içindeki değerlerden farklıdır: - `logging_steps`: Varsayılan değeri `500` yerine `10`'dur. - `gradient_checkpointing`: Varsayılan değeri `False` yerine `True`'dur. - `bf16`: `fp16` ayarlanmadıysa varsayılan değeri `False` yerine `True`'dur. - `learning_rate`: Varsayılan değeri `5e-5` yerine `1e-6`'dir.

## Referanslar

1. [RLOO Makalesi](https://openreview.net/pdf?id=r1lgTGL5DE)
2. [Temellere Dönüş: LLM'lerde İnsan Geri Bildiriminden Öğrenme İçin REINFORCE Tarzı Optimizasyonun Yeniden İncelenmesi](https://huggingface.co/papers/2402.14740)
3. [Makale - REINFORCE++: Büyük Dil Modellerini Hizalandırmak İçin Basit ve Verimli Bir Yaklaşım](https://huggingface.co/papers/2501.03262)
4. [Blog Yazısı - RLHF'e RL'i Geri Getirmek](https://huggingface.co/blog/putting_rl_back_in_rlhf_with_rloo)
5. [Blog Yazısı - RLHF ve Varyantlarını Çözümleme: İlerleme ve Pratik Mühendislik İçgörüleri](https://hijkzzz.notion.site/unraveling-rlhf-and-its-variants-engineering-insights#147d9a33ecc9806090f3d5c749d31f05)
6. [Youtube - RLOO: LLM'lerde İnsan Geri Bildiriminden Öğrenme için Maliyet-Etkin Bir Optimizasyon](https://www.youtube.com/watch?v=86asXGPK6RU&ab_channel=BuzzRobot)

## Eski uygulama (0.21 ve öncesi) içinden Geçiş Kılavuzu

0.22.0 sürümünün yayınlanmasıyla birlikte, [RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer) yeniden tasarlanarak kütüphanedeki [GRPOTrainer](/docs/trl/v1.18.2/tr/grpo_trainer#trl.GRPOTrainer) gibi diğer çevrimiçi eğitimcilerle daha uyumlu hale getirildi. Bu yeni uygulama, eğitimcinin yapılandırma parametrelerinde ve genel yapısında çeşitli değişiklikler getiriyor. [RLOOConfig](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOConfig) için ana değişikliklerin özeti aşağıda yer almaktadır:

| TRL ≤ 0.21.x | TRL ≥ 0.22.0 |
| --- | --- |
| `rloo_k` | `num_generations` olarak yeniden adlandırıldı |
| `cliprange` | `epsilon` olarak yeniden adlandırıldı |
| `kl_coef` | `beta` olarak yeniden adlandırıldı |
| `exp_name` | `run_name` olarak yeniden adlandırıldı. Eski davranışı yeniden oluşturmak için `run_name = f"{exp_name}__{seed}__{int(time.time())}"` kullanın |
| `normalize_reward` | `normalize_advantages` olarak yeniden adlandırıldı. Not: bu, avantajları her zaman normalize ediyordu (eski adına rağmen) |
| `num_ppo_epochs` | `num_iterations` olarak yeniden adlandırıldı (varsayılan: `1`) |
| `token_level_kl` | **kaldırıldı** – KL artık yalnızca dizi düzeyinde hesaplanır |
| `dataset_num_proc` | **kaldırıldı** – kullanılmıyordu |
| `num_mini_batches` | `steps_per_generation` olarak yeniden adlandırıldı |
| `total_episodes` | Bunun yerine `max_steps=total_episodes / gradient_accumulation_steps` kullanın |
| `local_rollout_forward_batch_size` | **kaldırıldı** – artık otomatik olarak `per_device_train_batch_size` (veya değerlendirme sırasında `per_device_eval_batch_size`) olarak ayarlanır |
| `num_sample_generations` | **kaldırıldı** – üretim günlük kaydı sıklığını kontrol etmek için `logging_steps` kullanın |
| `response_length` | `max_completion_length` olarak yeniden adlandırıldı (varsayılan: `512`) |
| `stop_token` | **kaldırıldı** |
| `stop_token_id` | **kaldırıldı** – bunun yerine `processing_class.eos_token_id` kullanın |
| `missing_eos_penalty` | **kaldırıldı** – `eos_token_id`'nin `completion_ids` içinde olup olmadığını kontrol eden özel bir ödül fonksiyonuyla çoğaltın |

Aşağıda [RLOOTrainer](/docs/trl/v1.18.2/tr/rloo_trainer#trl.RLOOTrainer) için ana değişikliklerin bir özeti yer almaktadır:

| TRL ≤ 0.21.x | TRL ≥ 0.22.0 |
| --- | --- |
| `config` | `args` olarak yeniden adlandırıldı |
| `reward_model` | `reward_funcs` olarak yeniden adlandırıldı; artık hem ödül modellerini hem de özel ödül işlevlerini destekler |
| `policy` | `model` olarak yeniden adlandırıldı |
| `ref_policy` | **kaldırıldı** – referans model artık `model` üzerinden otomatik olarak oluşturulur |
| `data_collator` | **kaldırıldı** |

