RLOO Eğiticisi

Genel Bakış

TRL, Arash Ahmadian, Chris Cremer, Matthias Gallé, Marzieh Fadaee, Julia Kreutzer, Ahmet Üstün ve Sara Hooker tarafından yazılan Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMs makalesinde anlatıldığı üzere, dil modellerinin eğitimi için RLOO Trainer'ı destekler.

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 tarafından katkıda bulunmuş ve daha sonra Shirin Yamani 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 istemlerle bir Qwen 0.5B Instruct modelini eğitiyoruz. Veri setindeki verilere buradan bakabilirsiniz:

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.

# 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:

accelerate launch 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ı.

Tamamlamalar oluşturma

Her eğitim adımında, bir istem (prompt) grubu örnekleriz ve her istem için bir dizi $G$ tamamlama (completion) üretiriz (şu şekilde gösterilir: $o_i$).

Ö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 için $o_i = (o_{i,1}, \dots, o_{i,T})$ bir sorguya bağlı olarak $q$, bir ödül modeli kullanarak skaler bir ödül hesaplarız $R(o_i, q)$.
2. Aynı anda, mevcut politika $\pi_\theta$ ve sabit referans politika $\pi_{\text{ref}}$ arasındaki KL sapmasını dizin üzerinde tahmin ederiz. Dizi $o_i$ 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})}.$$

Dizilere atanan nihai ödül $o_i$ şu şekildedir: $$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 gücünü kontrol eder.

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. batch başına birden fazla gradyan adımı) durumunda, veriler bunun yerine daha önceki bir anlık görüntü tarafından üretilir $\pi_{\text{old}}$. 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 taban değeri şudur:$$b_i = \frac{1}{G-1} \sum_{j \neq i} r_j$$

ve 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ı ş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ı yapmak, 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. Örnekleme 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$ ve bu, standart REINFORCE'a indirgenir.

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ün içine katılır $r_i$, bu da koparılmış avantaja dönüşür $\hat{A}_i$.

Başka bir deyişle, politika içine giren tek yol, önem oranı terimidir $\frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)}$, ve KL terimi politika içine geri yayılmaz.

Buna karşın, GRPO hedefine, mevcut politika ile anlık olarak hesaplanan açık ve türevlenebilir bir KL terimi ekler $\pi_\theta$, bu sayede 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: RLOO hedefinin güven bölgesi içinde kalacak şekilde kırpıldığı 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ığı anlamına gelir ve bu da politikanın $\pi_\theta$ ne kadar değişebileceğini sınırlar.
• 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'yi kullanabilirsiniz. Bunu etkinleştirmek için önce paketi şu şekilde yükleyin

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.

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:

   Kopyalandı

   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:

   Kopyalandı

   from trl import RLOOConfig
   
   training_args = RLOOConfig(
       ...,
       use_vllm=True,
       vllm_mode="server",
   )

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.

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 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 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 başlıklı bölümü inceleyin.

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 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 bölümüne bakın.
• Accelerate: Accelerate, birden fazla GPU ve düğüm arasında dağıtık eğitimi basitleştiren bir kütüphanedir. Dağıtık eğitimi başlatmak için basit bir API sunar ve veri paralelliği, gradyan biriktirme ve dağıtık veri yükleme gibi dağıtık eğitimin karmaşıklıklarını yönetir. Daha fazla ayrıntı için Eğitimi Dağıtma 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.

#!/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}" accelerate launch \
     --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
     --num_processes 32 \
     --num_machines 4 \
     --main_process_ip ${NODELIST[0]} \
     --machine_rank $SLURM_PROCID \
     --rdzv_backend c10d \
     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

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,
        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, 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): 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 için prompts ve completions dizeleri listeleri olacaktır.
     • sohbet formatı 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:

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:

>>> 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.

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:

>>> 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 makalesinde kullanılan format reward fonksiyonundan ilham alınmıştır. Yapılandırılmış mesajlardan oluşan istem ve tamamlamaların kullanıldığı bir sohbet formatı için tasarlanmıştır.

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:

>>> 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 makalesinde kullanılan accuracy reward fonksiyonundan ilham alınarak hazırlanmıştır. Bu örnek, veri setinin ground_truth adlı bir sütun içerdiği standard format için tasarlanmıştır.

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:

>>> 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 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.

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 geçerli fonksiyonlar ve görevlerle devam eder. Bu, RLOOTrainer'ın farklı uygulama alanlarına sahip birden fazla ödül fonksiyonunu işleyebilmesini sağlar.

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 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:

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.

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 sınıfına aşağıdaki gibi iletin:

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:

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'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

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 dosyasını kullanın. lmms-lab/multimodal-open-r1-8k-verified üzerinde eğitim için örnek komut:

accelerate launch \
  --config_file=examples/accelerate_configs/deepspeed_zero3.yaml \
  examples/rloo_visual_math/rloo_visual_math.py \
  --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

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

RLOOConfig

Referanslar

1. RLOO Makalesi
2. Temellere Dönüş: LLM'lerde İnsan Geri Bildiriminden Öğrenme İçin REINFORCE Tarzı Optimizasyonun Yeniden İncelenmesi
3. Makale - REINFORCE++: Büyük Dil Modellerini Hizalandırmak İçin Basit ve Verimli Bir Yaklaşım
4. Blog Yazısı - RLHF'e RL'i Geri Getirmek
5. Blog Yazısı - RLHF ve Varyantlarını Çözümleme: İlerleme ve Pratik Mühendislik İçgörüleri
6. Youtube - RLOO: LLM'lerde İnsan Geri Bildiriminden Öğrenme için Maliyet-Etkin Bir Optimizasyon

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 yeniden tasarlanarak kütüphanedeki 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. Aşağıda, RLOOConfig için ana değişikliklerin bir özeti yer almaktadır:

Aşağıda RLOOTrainer için ana değişikliklerin bir özeti yer almaktadır: