# GRPO Eğiticisi

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

## Genel Bakış

TRL, [Zhihong Shao](https://huggingface.co/syhia), [Peiyi Wang](https://huggingface.co/peiyiwang89), [Qihao Zhu](https://huggingface.co/zqh11), Runxin Xu, [Junxiao Song](https://huggingface.co/haha-point), Mingchuan Zhang, Y. K. Li, Y. Wu ve [Daya Guo](https://huggingface.co/guoday) tarafından kaleme alınan [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models](https://huggingface.co/papers/2402.03300) makalesinde anlatıldığı üzere, dil modellerinin eğitimi için GRPO Trainer'ı destekler.

Makalenin özeti aşağıdaki gibidir:

> Matematiksel akıl yürütme, karmaşık ve yapılandırılmış doğası nedeniyle dil modelleri için önemli bir zorluk oluşturmaktadır. Bu makalede, Common Crawl'dan elde edilen 120 milyar matematikle ilgili token ile doğal dil ve kod verilerini birleştirerek DeepSeek-Coder-Base-v1.5 7B'nin ön eğitiminin devam ettirildiği DeepSeekMath 7B'yi tanıtıyoruz. DeepSeekMath 7B, harici araç kütüphanelerine ve oy verme tekniklerine başvurmadan, yarışma seviyesindeki MATH benchmark'ında 51,7% gibi etkileyici bir puan elde etmiş olup Gemini-Ultra ve GPT-4'ün performans seviyesine yaklaşmaktadır. DeepSeekMath 7B'den 64 örnek üzerinde tutarlılık (self-consistency) yöntemiyle MATH'ta 60,9% başarıya ulaşılmaktadır. DeepSeekMath'in matematiksel akıl yürütme yeteneği iki temel faktöre dayanmaktadır: Birincisi, halka açık web verilerinin önemli potansiyelini titizlikle tasarlanmış bir veri seçme hattı aracılığıyla değerlendirmekteyiz. İkincisi, Proximal Policy Optimization (PPO)'nun bir varyantı olan ve matematiksel akıl yürütme yeteneklerini artırırken aynı zamanda PPO'nun bellek kullanımını optimize eden Group Relative Policy Optimization (GRPO)'yu tanıtıyoruz.

Bu eğitim sonrası yöntemi [Quentin Gallouédec](https://huggingface.co/qgallouedec) tarafından katkı sağlanmıştır.

## Hızlı başlangıç

Bu örnek, GRPO yöntemiyle bir modelin nasıl eğitileceğini göstermektedir. [DeepMath-103K veri seti](https://huggingface.co/datasets/trl-lib/DeepMath-103K)ndeki istemlerle bir [Qwen2.5 0.5B Instruct modeli](https://huggingface.co/Qwen/Qwen2.5-0.5B-Instruct) eğitilir. Veri setindeki verilere buradan erişebilirsiniz:

<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_grpo.py
from datasets import load_dataset
from trl import GRPOTrainer
from trl.rewards import accuracy_reward

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

trainer = GRPOTrainer(
    model="Qwen/Qwen2.5-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_grpo.py
```

8 GPU arasında dağıtıldığında, eğitim yaklaşık 1 gün sürer.

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

> **Not:** Yukarıdaki ödül eğrileri `Qwen/Qwen2-0.5B-Instruct` ile oluşturulmuştur. `Qwen/Qwen2.5-0.5B-Instruct` ile elde edilen sonuçlar niteliksel olarak benzer olacaktır.

## GRPO yöntemine daha derinlemesine bakış

GRPO, çevrimiçi bir öğrenme algoritmasıdır; bu, eğitim sırasında eğitimli modelin kendisi tarafından üretilen verileri kullanarak iteratif olarak iyileştiği anlamına gelir. GRPO hedefinin arkasındaki sezgi, modelin referans politikaya yakın kalmasını sağlarken üretilen tamamlamaların avantajını en üst düzeye çıkarmaktır. GRPO'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ı**.

![GRPO visual](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/grpo_visual.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.

### Avantajın hesaplanması

\\( G \\) dizilerinin her biri için ödül, bir ödül modeli veya ödül fonksiyonu kullanılarak hesaplanır. Ödül modellerinin karşılaştırmalı doğasıyla uyumlu olmak için—genellikle aynı soru için çıktılar arasındaki karşılaştırmalardan oluşan veri setlerinde eğitilirler—avantaj, bu göreli karşılaştırmaları yansıtacak şekilde hesaplanır. Aşağıdaki gibi normalize edilir:

$$\hat{A}_{i,t} = \frac{r_i - \text{mean}(\mathbf{r})}{\text{std}(\mathbf{r})}$$

Bu yaklaşım, yönteme adını verir: **Grup Göreceli Politika Optimizasyonu (GRPO)**.

> [!TIP]
> [Understanding R1-Zero-Like Training: A Critical Perspective](https://huggingface.co/papers/2503.20783) makalesinde, \\( \text{std}(\mathbf{r}) \\) ile ölçeklendirmenin soru düzeyinde bir zorluk yanlılığına neden olabileceği gösterilmiştir. Bu ölçeklendirmeyi [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) içinde `scale_rewards=False` olarak ayarlayarak devre dışı bırakabilirsiniz. Dikkat edin, std tabanlı ölçeklendirmeyi kapatmak varyans normalizasyonunu da kaldırır; bu nedenle güncelleme büyüklükleri doğrudan ham ödül ölçeğine ve parti (batch) bileşimine bağlı hale gelir.

> [!TIP]
> [Bölüm I: Hile mi Tuzak mı? LLM Muhakemesi için RL’ye Derinlemesine Bakış (Lite PPO)](https://huggingface.co/papers/2508.08221) bölümünde gösterildiği üzere, ortalamanın yerel (grup) düzeyde, standart sapmanın ise küresel (toplu işlem) düzeyde hesaplanması daha sağlam ödül şekillendirmesi sağlar. [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) içinde `scale_rewards="batch"` ayarlayarak bu ölçekleme stratejisini kullanabilirsiniz.

### KL sapmasının tahmini

KL sapması, [Schulman ve ark. (2020)](http://joschu.net/blog/kl-approx.html) tarafından tanıtılan yaklaşık hesaplayıcı kullanılarak tahmin edilir. Yaklaşık hesaplayıcı aşağıdaki gibi tanımlanır:

$$\mathbb{D}_{\text{KL}}\left[\pi_\theta \|\pi_{\text{ref}}\right] = \frac{\pi_{\text{ref}}(o_{i,t} \mid q, o_{i,<t})}{\pi_\theta(o_{i,t} \mid q, o_{i,<t})} - \log \frac{\pi_{\text{ref}}(o_{i,t} \mid q, o_{i,<t})}{\pi_\theta(o_{i,t} \mid q, o_{i,<t})} - 1, $$

### Kaybın hesaplanması

Amaç, modelin referans politikaya yakın kalmasını sağlarken avantajı en üst düzeye çıkarmaktır. Dolayısıyla kayıp şu şekilde tanımlanır:

$$ \mathcal{L}_{\text{GRPO}}(\theta) = -\frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \left[ \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\left[\pi_\theta(o_{i,t} \mid q, o_{i,< t})\right]_{\text{no grad}}} \hat{A}_{i,t} - \beta \mathbb{D}_{\text{KL}}\left[\pi_\theta \| \pi_{\text{ref}}\right] \right], $$

burada ilk terim ölçeklendirilmiş avantajı, ikinci terim ise KL ayrılığı aracılığıyla referans politikadan sapmaları cezalandırır.

> [!TIP]
> [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models](https://huggingface.co/papers/2402.03300) makalesindeki orijinal formülasyona kıyasla, [Understanding R1-Zero-Like Training: A Critical Perspective](https://huggingface.co/papers/2503.20783) makalesinde bunun yanıt düzeyinde bir uzunluk yanlılığına yol açtığı gösterildiğinden, \\( \frac{1}{|o_i|} \\) ile ölçekleme yapmıyoruz. Daha fazla ayrıntı için [loss types](#loss-types) bölümüne bakın.

> [!TIP]
> [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models](https://huggingface.co/papers/2402.03300) makalesindeki orijinal formülasyona kıyasla, varsayılan olarak \\( \beta = 0.0 \\) kullanıyoruz; bu, KL sapma teriminin kullanılmadığı anlamına gelir. Bu tercih, GRPO ile eğitimde KL sapma teriminin zorunlu olmadığını gösteren çeşitli son dönem çalışmalarıyla (ör. [Open-Reasoner-Zero: An Open Source Approach to Scaling Up Reinforcement Learning on the Base Model](https://huggingface.co/papers/2503.24290)) desteklenmektedir. Sonuç olarak, bu terimi dışlamak yaygın bir uygulama haline gelmiştir (ör. [Understanding R1-Zero-Like Training: A Critical Perspective](https://huggingface.co/papers/2503.20783), [DAPO: An Open-Source LLM Reinforcement Learning System at Scale](https://huggingface.co/papers/2503.14476)). KL sapma terimini dahil etmek isterseniz, [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) içindeki `beta` değerini sıfırdan farklı bir değere ayarlayabilirsiniz.

Orijinal makalede, bu formülasyon, her üretimden sonra birden fazla güncellemeyi hesaba katmak için **kırpılmış vekil amaç** (clipped surrogate objective) kullanılarak genelleştirilir ( \\( \mu \\), [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) içinde `num_iterations` ile ayarlanabilir):

$$ \mathcal{L}_{\text{GRPO}}(\theta) = - \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \left[ \min \left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})} \hat{A}_{i,t}, \, \text{clip}\left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})}, 1 - \epsilon, 1 + \epsilon \right) \hat{A}_{i,t} \right) - \beta \mathbb{D}_{\text{KL}}\left[\pi_\theta \| \pi_{\text{ref}}\right] \right], $$

burada \\(\text{clip}(\cdot, 1 - \epsilon, 1 + \epsilon) \\) politik oranını \\( 1 - \epsilon \\) ile \\( 1 + \epsilon \\) arasında sınırlayarak güncellemelerin referans politikadan aşırı sapmasını engeller. \\( \mu = 1 \\) olduğunda (TRL'de varsayılan), kırpılmış ikame amaç, orijinal amaca indirgenir.

#### Kayıp Türleri

Literatürde hedefin çeşitli formülasyonları önerilmiştir. Başlangıçta, GRPO'nun hedefi şu şekilde tanımlanmıştır:

$$ \mathcal{L}_{\text{GRPO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} l_{i,t}, $$

burada

$$ l_{i,t} = \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\left[\pi_\theta(o_{i,t} \mid q, o_{i,< t})\right]_{\text{no grad}}_} \hat{A}{i,t} - \beta \mathbb{D}_{\text{KL}}_\left[\pi\theta \| \pi_{\text{ref}}\right]. $$

[DAPO makalesi](https://huggingface.co/papers/2503.14476), uzun-CoT senaryolarında GRPO algoritmasının örnek düzeyindeki kaybının sınırlılıklarını vurgular; bu senaryolarda daha uzun yanıtlar yetersiz cezalandırılır ve bu da daha düşük kaliteli çıktılara yol açar. Önerilen çözüm, yanıt uzunluğundan bağımsız olarak bireysel token'lara daha dengeli ödüller atayarak daha uzun dizileri daha iyi ele alan token düzeyinde bir normalleştirmedir:

$$ \mathcal{L}_{\text{DAPO}}(\theta) = - \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} l_{i,t}, $$

Bu formülasyonu kullanmak için [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) içinde `loss_type="dapo"` değerini ayarlayın.

Ayrıca, [Understanding R1-Zero-Like Training: A Critical Perspective](https://huggingface.co/papers/2503.20783) makalesinde, başlangıç GRPO formülasyonunun bir yanıt uzunluğu önyargısı ortaya koyduğu gösterilmiştir. DAPO formülasyonunun bu önyargıyı azalttığını, ancak onu tamamen ortadan kaldırmadığını ortaya koyuyorlar. Bu önyargıyı tamamen kaldırmak için, sıra uzunluğu yerine bir sabite bölünmesini öneriyorlar; bu da aşağıdaki formülasyona yol açıyor:

$$ \mathcal{L}_{\text{Dr. GRPO}}(\theta) = - \frac{1}{LG} \sum_{i=1}^G \sum_{t=1}^{|o_i|} l_{i,t}, $$

Bu sabitin, maksimum tamamlama uzunluğu olarak önerilir. Bu formülasyonu kullanmak için [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) içinde `loss_type="dr_grpo"` değerini ayarlayın.

Alternatif olarak, [SAPO makalesi](https://huggingface.co/papers/2511.20347)'nde Qwen ekibi, GRPO'nun "sert" kırpma mekanizmasını, yumuşak, sıcaklık kontrollü bir yumuşak kapı mekanizmasıyla değiştirmeyi önermektedir. GRPO, politika referans noktadan çok fazla saparsa gradyanları sıfırlarken, SAPO, gradyan ağırlığını yumuşak bir şekilde azaltan yumuşak bir güven bölgesi kullanır. Bu, modelin "yakın-on-policy" jetonlardan faydalı öğrenme sinyallerini korumasına, aşırı sapmalardan kaynaklanan gürültüyü ise bastırmasına olanak tanır.

Kayıp fonksiyonu şu şekilde tanımlanır:

$$ \mathcal{L}_{\text{SAPO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} f_{i,t} \left( \frac{\pi_\theta(o_{i,t} | q, o_{i,<t})}{\pi_{\theta_{old}}(o_{i,t} | q, o_{i,<t})} \right) \hat{A}_{i,t} $$

Yumuşak kapı fonksiyonu \\( f_{i,t} \\) sigmoid fonksiyonu \\( \sigma \\) kullanılarak şu şekilde tanımlanır:

$$ f_{i,t}(x) = \sigma \left( \tau_{i,t} (x - 1) \right) \cdot \frac{4}{\tau_{i,t}} $$

Sıcaklık \\( \tau_{i,t} \\), avantajın \\( \hat{A}_{i,t} \\) işaretine göre seçilir:

$$ \tau_{i,t} = \begin{cases} \tau_{\text{pos}}, & \text{if } \hat{A}_{i,t} > 0 \\ \tau_{\text{neg}}, & \text{otherwise} \end{cases} $$

Asimetrik sıcaklıklar kullanılmalarını önerirler,  \\( \tau_{\text{neg}} > \tau_{\text{pos}} \\) (varsayılanlar  \\( \tau_{\text{pos}}=1.0, \tau_{\text{neg}}=1.05 \\) ). Bu, modelin kararsızlığı önlemek için "kötü" eylemlerden daha sıkı bir şekilde cezalandırılmasını, "iyi" eylemlere karşı ise daha esnek davranmasını sağlar.

Bu formülasyonu kullanmak için [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) içinde `loss_type="sapo"` değerini ayarlayın.

## 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ı. Araçlar kullanıldığında yalnızca araç dışı tokenlar sayılır.
- `step_time`: Eğitim adımının (üretim dahil) ortalama süresi (saniye cinsinden).
- `completions/mean_length`: Üretilen tamamlamaların ortalama uzunluğu. Araçlar kullanıldığında yalnızca araç dışı jetonlar sayılır.
- `completions/min_length`: Üretilen tamamlamaların (completions) minimum uzunluğu. Araçlar kullanıldığında yalnızca araç dışı jetonlar (tokens) sayılır.
- `completions/max_length`: Üretilen tamamlamaların (completions) maksimum uzunluğu. Araçlar kullanıldığında yalnızca araç dışı jetonlar (tokens) sayılır.
- `completions/mean_terminated_length`: EOS ile sonlanan üretilen tamamlamaların ortalama uzunluğu. Araçlar kullanıldığında yalnızca araç dışı jetonlar sayılır.
- `completions/min_terminated_length`: EOS ile sonlanan üretilen tamamlamaların en küçük uzunluğu. Araçlar kullanıldığında yalnızca araç dışı jetonlar sayılır.
- `completions/max_terminated_length`: EOS ile sonlanan üretilen tamamlamaların maksimum uzunluğu. Araçlar kullanıldığında yalnızca araç dışı jetonlar sayılır.
- `completions/clipped_ratio`: Kesilen (kırpılan) tamamlamaların oranı.
- `tools/call_frequency`: Üretim grubundaki tamamlama başına ortalama araç çağrısı sayısı. Yalnızca `tools` sağlandığında kaydedilir.
- `tools/failure_frequency`: Başarısız olan araç çağrılarının oranı (araç bulunamadı, bir istisna fırlatıldı veya çağrı türü desteklenmiyor). Hiçbir araç çağrılmadığında `0.0`'dır. Yalnızca `tools` sağlandığında kaydedilir.
- `rewards/{reward_func_name}/mean`: Belirli bir ödül fonksiyonundan gelen ortalama ödül. Bir ortam ödülü `get_reward` üzerinden yönetiyorsa, `{reward_func_name}` ortamın sınıf adını belirtir.
- `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ı.
- `sampling/sampling_logp_difference/mean`: Örnekleme birimi (vLLM) tarafından döndürülen log olasılıklar ile eğitim modeli tarafından yeniden hesaplanan log olasılıklar arasındaki, tamamlama jetonları üzerinden hesaplanan ortalama mutlak fark. Artan bir değer, eğitim-çıkarsama uyumsuzluğunun genişlediğini gösterir. Yalnızca `use_vllm=True` ve `vllm_importance_sampling_correction=True` olduğunda kaydedilir.
- `sampling/sampling_logp_difference/max`: En büyük mutlak fark. Yalnızca `use_vllm=True` ve `vllm_importance_sampling_correction=True` olduğunda kaydedilir.
- `sampling/importance_sampling_ratio/min`: Eğitim-çıkarım uyumsuzluğunu düzeltmek için kullanılan en küçük önem örneklemesi oranı, `vllm_importance_sampling_mode` tarafından seçilen kısıt **uygulandıktan** sonra (`*_truncate` modlarında `[C_min, C_max]` aralığına kırpılır, `*_mask` modlarında sıfıra ayarlanır). Tamamlama jetonları üzerinde hesaplanır, `sequence_*` modlarında ise diziler üzerinde hesaplanır. Yalnızca `use_vllm=True` ve `vllm_importance_sampling_correction=True` olduğunda kaydedilir.
- `sampling/importance_sampling_ratio/mean`: Kısıtlı önem örneklemesi oranının ortalaması. Yalnızca `use_vllm=True` ve `vllm_importance_sampling_correction=True` olduğunda kaydedilir.
- `sampling/importance_sampling_ratio/max`: En büyük kısıtlı önem örneklemesi oranı. Yalnızca `use_vllm=True` ve `vllm_importance_sampling_correction=True` olduğunda kaydedilir.
- `policy_loss`: Politika gradyanı kaybı değeri (herhangi bir entropi bonusu uygulanmadan önce). `entropy_coef` sıfır değilse veya `use_adaptive_entropy=True` ise kaydedilir.
- `entropy`: Üretilen tamamlamalar boyunca token tahminlerinin ortalama entropisi. (`mask_truncated_completions=True` ise, maskelenmiş dizilerin tokenları hariç tutulur.)
- `entropy_coef`: Güncel entropi düzenleme katsayısı. `entropy_coef` sıfırdan farklı olduğunda veya `use_adaptive_entropy=True` olduğunda kaydedilir. `use_adaptive_entropy=True` olduğunda her optimizasyon adımı başına bir kez güncellenir.
- `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`: GRPO hedefinin güven bölgesi içinde kalması için kırpılan token (veya `importance_sampling_level="sequence"` ise dizi) olasılıklarının oranı:  \\( \text{clip}\left( r_{i,t}(\theta), 1 - \epsilon_\mathrm{low}, 1 + \epsilon_\mathrm{high} \right)\,, \quad r_{i,t}(\theta) = \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})} \\). Daha yüksek bir değer, daha fazla tokenın kırpıldığı anlamına gelir ve bu da politikanın $\pi_\theta$ 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 token (veya `importance_sampling_level="sequence"` ise 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ında kırpılan, tamamlama başına en küçük token oranı (veya `importance_sampling_level="sequence"` ise dizinin kendisi): \\(r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}\\).
- `clip_ratio/high_mean`: Güven bölgesinin üst sınırında kırpılan token (veya `importance_sampling_level="sequence"` ise 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ında kırpılan, tamamlama başına en büyük token oranı (veya `importance_sampling_level="sequence"` ise dizinin kendisi): \\(r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}\\).
- `cispo_clip_ratio`: Pozitif avantaja sahipken `epsilon_high` değerinde kırpılan token (veya `importance_sampling_level="sequence"` ise dizi) önem örneklemesi ağırlıklarının oranı: \\(r_{i,t}(\theta) > \epsilon_\mathrm{high}\\). Yalnızca `loss_type="cispo"` olduğunda kaydedilir.
- `vespo/phi_seq_mean`: Sıra düzeyi önem ağırlıklarına uygulanan VESPO Gamma ağırlamasının \\(\varphi(w)\\) ortalama değeri. `1.0`'dan düşük değerler, sıraların ağırlığının azaltıldığını gösterir. Yalnızca `loss_type="vespo"` olduğunda kaydedilir.

## Ö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**.

> [!TIP]
> Varsayılan olarak, farklı çerçeveler kullanıldığında ortaya çıkan üretim-eğitim uyumsuzluğunu ele almak için vLLM üretimi için dizin düzeyinde Masked Importance Sampling (`vllm_importance_sampling_mode="sequence_mask"`) etkinleştirilir. Bu, `vllm_importance_sampling_correction=False` olarak ayarlanarak kapatılabilir. Daha fazla bilgi için [Masked Importance Sampling](paper_index#masked-importance-sampling) ve [Sequence-level Importance Sampling](paper_index#sequence-level-importance-sampling) konularına bakın.

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

training_args = GRPOConfig(
    ...,
    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 GRPOConfig

   training_args = GRPOConfig(
       ...,
       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 [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) 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 GRPO, vLLM için `MASTER_ADDR=localhost` ve `MASTER_PORT=12345` değerlerini kullanır ancak bu değerleri ilgili ortam değişkenlerini 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.

#### Eğitim-Çıkarım Uyumsuzluğuyla Başa Çıkma
vLLM çıkarımı büyük ölçüde hızlandırsa da, çıkarım motorunu eğitim motorundan ayırır. Teoride bu motorlar matematiksel olarak özdeştir; ancak pratikte, hassasiyet etkileri ve donanıma özgü optimizasyonlar nedeniyle farklı çıktılar üretebilirler. Bu sapma, iki sistemin farklı optimizasyon hedeflerini yansıtır. Çıkarım motorları, kabul edilebilir bir örneklemleme sadakatini korurken genellikle saniyede token cinsinden ölçülen örneklemleme verimliliğini en üst düzeye çıkarmayı hedefler. Eğitim çerçeveleri ise gradyan hesaplama için sayısal kararlılığa ve hassasiyete odaklanır; bu amaçla ana ağırlıklar ve optimizör durumları için FP32 gibi daha yüksek hassasiyetli biçimleri kullanır. Bu farklı öncelikler ve kısıtlamalar, eğitim ile çıkarım arasında kaçınılmaz, ancak ince bir uyumsuzluk yaratır.

Bu uyumsuzluk, eğitimi kararsızlaştırdığı gözlemlenen yanlı bir gradyan güncellemesine yol açar ([[1]](https://fengyao.notion.site/off-policy-rl)[[2]](https://yingru.notion.site/When-Speed-Kills-Stability-Demystifying-RL-Collapse-from-the-Training-Inference-Mismatch-271211a558b7808d8b12d403fd15edda)[[3]](https://thinkingmachines.ai/blog/defeating-nondeterminism-in-llm-inference/#true-on-policy-rl)[[4]](https://huggingface.co/papers/2510.26788)[[5]](https://huggingface.co/papers/2510.18855)). Basitlik adına, REINFORCE politika gradyanını ele alalım:

$$ \nabla_\theta \mathcal{J}(x,\theta) = \mathbb{E}_{y \sim \pi^\text{train}(\cdot \mid x,\theta)} \left[ \nabla_\theta \log \pi^\text{train}(y \mid x,\theta) \cdot R(x,y) \right] $$

Burada \\( x \\), bazı veri dağılımlarından örneklenen istemleri (prompts) belirtir ve \\( \pi^\text{train} \\), eğitim motoru tarafından uygulanan politikayı ifade eder. vLLM döngüde olduğunda ayrı bir çıkarım politikası \\( \pi^\text{inference} \\) elde edilir, böylece etkili politika gradyanı şu hale gelir

$$ \nabla_\theta \mathcal{J}_{\text{biased}}(x,\theta) = \mathbb{E}_{y \sim \pi^\text{inference}(\cdot \mid x,\theta)} \left[ \nabla_\theta \log \pi^\text{train}(y \mid x,\theta) \cdot R(x,y) \right]. $$

Bu, aksi halde on-policy bir RL problemini off-policy bir probleme dönüştürür.

Bu dağılım kaymasını düzeltmenin standart yolu **önem örneklemesidir (importance sampling, IS)**. İki IS varyantı sunuyoruz: [Kırpılmış Önem Örneklemesi (Truncated Importance Sampling, TIS)](paper_index#truncated-importance-sampling) ve [Maskelenmiş Önem Örneklemesi (Masked Importance Sampling, MIS)](paper_index#masked-importance-sampling). Her iki varyant da hem token düzeyinde hem de dizi düzeyinde uygulanabilir. \\( \rho \\) ile önem ağırlığını, örneğin token başına \\( \rho_t \\) veya dizi başına \\( \rho_{\text{seq}} \\) belirtelim. TIS altında, `[vllm_importance_sampling_clip_min, vllm_importance_sampling_clip_max]` aralığının dışındaki oranlar kırpılır,

$$ \rho \leftarrow \text{clip}(\rho, C_{\min}, C_{\max}). $$

Orijinal [TIS makalesi](https://huggingface.co/papers/1606.02647) tek bir üst sınır kırpma mekanizması önermiştir, yani \\( \min(\rho, C_{\max}) \\). TRL'deki uygulama, [IcePop](paper_index#masked-importance-sampling) yönteminden ilham alarak bir alt sınır da tanıtarak bunu genellemiş ve yukarıda gösterilen iki taraflı formülasyonu elde etmiştir. Not: IcePop'ta sınırlar \\( \alpha \\) ve \\( \beta \\) olarak etiketlenirken, TRL'de \\( C_{\min} \\) ve \\( C_{\max} \\) kullanılır.

MIS kapsamında, bu aralığın dışındaki oranlar sıfıra ayarlanır; bu nedenle bu örnekler gradyana katkı sağlamaz. Başka bir deyişle, uç örnekler TIS altında ağırlığı azaltılırken MIS altında elenir. `vllm_importance_sampling_mode` yapılandırma bayrağı, hem IS varyantını (maskeleme veya kesme) hem de granülerliği (token düzeyi veya dizi düzeyi) seçer.

Önem örneklemesi, eğitim–çıkarım uyumsuzluğuna yönelik ilkesel algoritmik yanıttır. Ancak, iki motor arasındaki uyumsuzluğu doğrudan azaltmayı amaçlayan daha doğrudan yaklaşımlar da vardır. Bunların çoğu mühendislik çözümleridir. Örneğin, [MiniMax M1, çıkarım motorunda FP32 dil modeli başlığı kullanır](https://huggingface.co/papers/2506.13585). Thinking Machines, [belirsiz çıkarım çekirdekleri](https://thinkingmachines.ai/blog/defeating-nondeterminism-in-llm-inference/)ni araştırmıştır, ancak bu önemli bir verimlilik maliyetiyle birlikte gelir. vLLM, Thinking Machines'in parti değişmez belirsiz çekirdekleri üzerine inşa ederek [bit düzeyinde tutarlı politikalar](https://blog.vllm.ai/2025/11/10/bitwise-consistent-train-inference.html) göstermiştir; ancak Kasım 2025 itibarıyla standart vLLM çıkarımına kıyasla önemli bir aktarım cezası devam etmektedir.

### Transformers sürekli toplama ile eğitimi hızlandırın

vLLM'nin bir alternatifi olarak, daha hızlı üretim için transformers'ın yerleşik sürekli toplama (continuous batching) motorunu kullanabilirsiniz. Sürekli toplama, en yavaş olanın bitmesini beklemeden tamamlanmış dizileri derhal partiden (batch) çıkarır. Değişken tamamlanma uzunluklarına sahip görevlerde (ör. matematiksel akıl yürütme), bu yöntem büyük parti boyutlarında (N≥32) varsayılan `generate()` ile karşılaştırıldığında daha hızlı üretim ve daha düşük VRAM kullanımı sağlar.

> [!TIP]
> Continuous batching, sunucu kurulumu veya ağırlık senkronizasyonu gerektirmeyen, doğrudan kullanılabilir bir yükseltmedir. Süreç içi çalışır ve tek GPU'lu eğitim veya bellek kısıtlı ortamlar için uygundur. Ölçekli en yüksek üretim (generation) verimliliği için bunun yerine vLLM kullanın.

```python
from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    use_transformers_continuous_batching=True,
    transformers_continuous_batching_config={
        "use_cuda_graph": False,
        "max_memory_percent": 0.4,  # lower values leave more VRAM for the training backward pass
    },
)
```

> [!TIP]
> TRL, eğitim geri yayılım adımı için yeterli VRAM bırakmak amacıyla `max_memory_percent` değerini varsayılan olarak `0.5` olarak ayarlar (transformers'ın `0.9` değeri yerine). Büyük üretim partileri (N≥32) için veya bellek dışı (out-of-memory) hataları görüyorsanız bu değeri `0.3`–`0.4` aralığına düşürün.

Tam bir eğitim örneği için [`examples/grpo_continuous_batching/grpo_continuous_batching.py`](https://github.com/huggingface/trl/blob/main/examples/grpo_continuous_batching/grpo_continuous_batching.py) dosyasına bakın.

### Ölçekli GRPO: 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, GRPO 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_grpo.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 GRPOTrainer, GRPOConfig
from trl.rewards import accuracy_reward

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

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

    training_args = GRPOConfig(
        per_device_train_batch_size=4,
        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 = GRPOTrainer(
        model="Qwen/Qwen2.5-72B",
        args=training_args,
        reward_funcs=accuracy_reward,
        train_dataset=dataset
    )
    trainer.train()

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

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

[GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer), 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.
     - `environments`: tamamlama başına bir tane olmak üzere ortam örneklerinin listesi. Yalnızca `environment_factory` sağlandığında mevcuttur. Bölüm sırasında biriken durumu okumak için (ör. `env.counter`) bunu kullanın. Durumlu ortamlar için ödülü bir `get_reward` yöntemi aracılığıyla ortama ait bırakmayı tercih edin — bkz. [Ödüller](#rewards).
     - 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, [GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer) 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 GRPOTrainer

# 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 = GRPOTrainer(
    model="Qwen/Qwen2.5-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 [GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer) geçerli fonksiyonlar ve görevlerle devam eder. Bu, [GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer)'ın farklı uygulama alanlarına sahip birden fazla ödül fonksiyonunu işleyebilmesini sağlar.

[GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer)'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 [GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer) bunları eşzamanlı olarak çalıştırır, böylece gecikmeleri üst üste biner.

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 [GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer) nesnesine aşağıdaki gibi iletin:

```python
from trl import GRPOTrainer

trainer = GRPOTrainer(
    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 GRPOTrainer

trainer = GRPOTrainer(
    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.

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

### Entropi düzenlemesi

Keşfi teşvik etmek ve politikanın neredeyse deterministik çıktılara çökmesini önlemek için eğitim hedefine bir entropi bonusu ekleyebilirsiniz. Entropi düzenlemesi, GRPO kaybını aşağıdaki gibi genişletir:

$$ \mathcal{L}(\theta) = \mathcal{L}_{\text{GRPO}}(\theta) - \alpha \cdot \mathcal{H}(\pi_\theta), $$

burada \\(\mathcal{H}(\pi_\theta)\\) politikanın token başına ortalama entropisini ve \\(\alpha\\) entropi katsayısını ifade eder. Bonus, `loss_type` değerinden bağımsız olarak her zaman token başına ortalama entropidir; bir kayıp türünün politika normalizasyonuna (ör. Dr. GRPO'nun `batch_size * max_completion_length` paydası) uyarlanacak şekilde yeniden ölçeklenmez, bu nedenle `entropy_coef` her kayıp türü için aynı anlama gelir.

**Statik entropi** — eğitim boyunca sabit bir katsayı:

```python
from trl import GRPOConfig, GRPOTrainer

training_args = GRPOConfig(entropy_coef=0.05, ...)
```

**Uyarlanabilir entropi** — katsayı, [Skywork-OR1](https://huggingface.co/papers/2505.22312)'de tanıtıldığı gibi, hedef entropiye dayanarak her optimizör adımında güncellenir. Mevcut entropi `entropy_target`'e eşit veya daha düşük olduğunda katsayı `entropy_coef_delta` kadar artırılır; aksi halde azaltılır. Katsayı yalnızca entropi hedefe eşit veya daha düşükken uygulanır (yani sıfır değildir):

```python
training_args = GRPOConfig(
    entropy_coef=0.01,          # initial coefficient
    use_adaptive_entropy=True,
    entropy_target=5.0,         # target mean per-token entropy (nats); tune for your model
    entropy_coef_delta=0.005,   # step size per optimizer step
    entropy_coef_min=0.0,
    entropy_coef_max=1.0,
    ...
)
```

Tipik dil modellerinin token başına entropileri 2–10 nat aralığındadır, bu nedenle varsayılan `entropy_target=0.2` değeri neredeyse hiç düzenlemeyi tetiklemez — bonus, entropi hedefe eşit veya daha düşük olduğunda, yani neredeyse tam bir çöküş durumunda devreye girer. Bu değeri, modeliniz için anlamlı bir değere, örneğin eğitimde erken aşamalarda gözlemlediğiniz entropiye (bu, `entropy` metriği olarak kaydedilir) yakın bir değere ayarlayın. `top_entropy_quantile < 1.0` kullanıldığında, `entropy_target` yüksek entropili token alt kümesine uygulanır — bu alt kümenin entropisi, kaydedilen tam token `entropy` değerinden daha yüksek olacaktır, bu nedenle buna göre kalibre edin.

`use_adaptive_entropy=True` olduğunda, mevcut entropi katsayısı `entropy_coef` her kontrol noktasıyla birlikte kaydedilir ve devam ettirme sırasında geri yüklenir; böylece eğitim tamamen yeniden başlatılabilir.

### GRPO için Hızlı Deney

RapidFire AI, TRL üzerine oturan ve tek bir GPU üzerinde bile birden fazla GRPO yapılandırmasını aynı anda başlatmanızı sağlayan açık kaynak bir deney motorudur. Yapılandırmaları sırayla denemek yerine RapidFire, yeniden başlatmadan **tüm öğrenme eğrilerini daha erken görmenize, düşük performans gösteren çalıştırmaları durdurmanıza ve umut verici olanları uçuş sırasında yeni ayarlarla klonlamanıza** olanak tanır. Daha fazla bilgi için [RapidFire AI Entegrasyonu](rapidfire_integration) bölümüne bakın.

## Ajan Eğitimi

GRPO, **ajan eğitimi**ni destekler: model, üretim sırasında araçları çağırır ve sonuçtan öğrenir.

- Bir **araç**, modele sunulan düz bir Python işlevidir (senkron veya asenkron). Durumsuz çağrılar (bir hesap makinesi, bir web araması) için `tools` kullanın.
- **environment** daha genel bir formdur: her rollout için sıfırdan oluşturulan, kamuya açık metotları araçlar olarak sunulan durumlu bir nesnedir; ayrıca `reset` yaşam döngüsü kancası ve ödülü kendisinin yönetmesine olanak tanıyan isteğe bağlı `get_reward` içerir. Rollout başına durum, reset kancası veya ortam tarafından yönetilen ödül gerekiyorsa `environment_factory` kullanın.

Bir arada çalışırlar — `environment_factory` ile birlikte bağımsız `tools` geçebilirsiniz.

### Araçlar

`tools` argümanı, ajanın kullanabileceği araçları tanımlayan Python fonksiyonlarının (senkron veya asenkron) bir listesini bekler:

```python
from trl import GRPOTrainer

trainer = GRPOTrainer(
    tools=[tool1, tool2],
    ...,
)
```

Her araç, **tip ipuçlu argümanlara ve dönüş türlerine** sahip standart bir Python fonksiyonu olmalı ve amacını, argümanlarını ve dönüş değerini açıklayan bir **Google tarzı docstring** içermelidir. Daha fazla ayrıntı için [Araçları geçme kılavuzu](https://huggingface.co/docs/transformers/en/chat_extras#passing-tools)'na bakın.

> [!TIP]
> GRPO araç çağrı döngüsü, sohbet şablonunun *önek koruyucu* olmasını gerektirir (bir araç mesajı eklenmesi, önceki mesajların nasıl görüntülendiğini değiştirmemelidir). Bilinen model aileleri (ör. Qwen3, DeepSeek-V3) için TRL, araçlar etkinleştirildiğinde otomatik olarak yamalı bir eğitim şablonu kullanır. Tam liste için [Sohbet Şablonları](chat_templates#training-templates) bölümüne bakın.

Araç çağırma turlarının sayısını sınırlamak için [GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig) içinde `max_tool_calling_iterations` kullanın. Varsayılan olarak bir sınır yoktur ve üretim; modelin araç çağrısı içermeyen bir yanıt turu üretmesi, tamamlamanın (tüm turlar ve araç sonuçları) `max_completion_length` belirteceye ulaşması veya tam dizinin modelin maksimum uzunluğuna (`vllm_mode="colocate"` ile `vllm_max_model_length`, aksi halde modelin `max_position_embeddings`) ulaşması durumunda durur.

Örnek:

```python
from trl import GRPOTrainer

def multiply(a: int, b: int) -> int:
    """
    Multiplies two integers.

    Args:
        a: The first integer.
        b: The second integer.

    Returns:
        The product of the two integers.
    """
    return a * b

async def async_add(a: int, b: int) -> int:
    """
    Asynchronously adds two integers.

    Args:
        a: The first integer.
        b: The second integer.

    Returns:
        The sum of the two integers.
    """
    return a + b

trainer = GRPOTrainer(
    tools=[multiply, async_add],
    ...,
)
```

### Ortamlar

Araçları `environment_factory` üzerinden de sağlayabilirsiniz. Bu modda [GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer), her rollout için bir ortam örneği oluşturur ve ortamın genel yöntemlerini araçlar olarak sunar.

> [!IMPORTANT]
> `environment_factory`, `transformers>=5.2.0` sürümünü gerektirir.

`environment_factory` kullandığınızda veri ortama aittir: harici bir `train_dataset` yoktur. Her rollout sırasında `reset()`, ortamın tuttuğu bir kurptan kendi kendine örneklem yaparak veya bir durumu prosedürel olarak üreterek görevi oluşturur ve istemi (prompt) döndürür. `max_steps`, eğitim uzunluğunu belirler. Aşağıda, hedefi kendi kendine örnekleyen ve bir `increment` metodu (araç olarak maruz bırakılan) içeren bir ortamın minimal bir örneği verilmiştir.

```python
import random

from trl import GRPOConfig, GRPOTrainer

class IncrementEnv:
    # Reserved methods
    def reset(self, **kwargs) -> str | None:  # required; called at the start of each rollout
        self.counter = 0
        self.target = random.randint(1, 6)  # self-sample the task
        return f"Increment the counter by {self.target}."  # returned string becomes the prompt

    def get_reward(self) -> float:  # optional: the environment scores itself from its own state
        return float(self.counter == self.target)

    # Public methods (exposed as tools)
    def increment(self, step: int) -> int:
        """
        Increment the internal counter.

        Args:
            step: Value to add to the counter.

        Returns:
            The updated counter value.
        """
        self.counter += step
        return self.counter

trainer = GRPOTrainer(
    model="Qwen/Qwen3-0.6B",
    args=GRPOConfig(max_steps=1000, chat_template_kwargs={"enable_thinking": False}),
    environment_factory=IncrementEnv,
)
trainer.train()
```

Bir ortam sınıfının iki ayrılmış metodu vardır: `reset` ve `get_reward`. Diğer herkese açık metotların aksine, bunlar modele araç olarak sunulmaz.

- `reset` (zorunlu), rollout başladığında çağrılır. `None` veya bir string döndürebilir. GRPO'da bir string döndürdüğünde, bu string kullanıcı istemidir.
- `get_reward` (isteğe bağlı, senkron veya asenkron) argüman almaz ve bir `float` döndürür: ortam, az önce çalıştırdığı bölümü kendi iç durumuna göre puanlar (oyun bir kazanışla mı bitti? kelime tahmin edildi mi?). Tamamlanan her rollout için bir kez çağrılır ve bir ödül kaynağı olarak görev yapar.

> [!NOTE]
> Ortam her `reset()` çağrısında kendinden örneklem yaptığı için, bir GRPO grubundaki `G` üye aynı başlangıç durumunu paylaşmayabilir; bu da grup baz çizgisini biraz daha gürültülü hale getirir. Bir grup içindeki durumların aynı olması için, `reset()` durumunu paylaşılan bir anahtardan deterministik olarak türetmelidir.

#### Harici bir veri seti sağlama (isteğe bağlı)

Ortamın kendi kendine örneklemesini bırakmak yerine, harici bir `train_dataset` sağlayabilirsiniz. Örneğin görevleriniz zaten bir veri setinde yer alıyorsa veya [birden fazla ortam](#multiple-environments) arasında yönlendirme yapmak istiyorsanız. Her rollout için eğitimci bir satır örnekler, `"prompt"` sütununu istem olarak kullanır ve satırın diğer sütunlarını `reset()` fonksiyonuna anahtar kelime argümanları olarak iletir (böylece ortam, görevi veri setinden okur).

```python
from datasets import Dataset
from trl import GRPOTrainer

# Each row carries the prompt and the task data (here, the counter target to reach).
dataset = Dataset.from_dict(
    {
        "prompt": [[{"role": "user", "content": f"Increment the counter to {i}."}] for i in range(1, 7)],
        "target": list(range(1, 7)),
    }
)

class IncrementEnv:
    def reset(self, target, **kwargs) -> None:  # the row's `target` column arrives as a keyword argument
        self.counter = 0
        self.target = target

    def get_reward(self) -> float:
        return float(self.counter == self.target)

    def increment(self, step: int) -> int:  # exposed as a tool (see the full docstring above)
        self.counter += step
        return self.counter

trainer = GRPOTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=dataset,  # the dataset owns the task; the "target" column reaches reset(target=...)
    environment_factory=IncrementEnv,
)
trainer.train()
```

### Ödüller

Ortam tarafından sağlanan ve trainer tarafından sağlanan ödül kaynakları birbirini dışlamaz. Tamamlamadan doğal olarak hesaplanabilen ödüller için (ör. metin üzerinde biçim kontrolü) `reward_funcs` parametresini iletin _ve_ ortamın durumuna bağlı ödülü `get_reward` üzerinden döndürmesine izin verin. Tüm kaynaklar toplanır; `reward_weights` yalnızca `reward_funcs` için geçerlidir (ortam kendi ölçeğini kendisi belirler).

```python
def format_reward(completions, **kwargs):  # trainer-owned: scores the completion text
    ...

trainer = GRPOTrainer(
    model="Qwen/Qwen3-0.6B",
    args=GRPOConfig(max_steps=1000),
    reward_funcs=format_reward,          # trainer-owned: scores the completion
    environment_factory=IncrementEnv,    # env-owned: scores its internal state via `get_reward`
)
```

`reward_func`, ortam durumunu doğrudan okuyabilir: `environment_factory` ayarlandığında, eğitimci `environments` anahtar kelimesini (tamamlama başına bir örnek) iletir. Bu ara sıra işe yarar, ancak duruma bağlı ödüller için `get_reward` tercih edilmelidir.

Bu, [`AsyncGRPOTrainer`](async_grpo_trainer) için de aynı şekilde çalışır.

### Çevreler

Tek bir çalıştırmada farklı görevlerin karışımını eğitmek için (ör. bir kodlama görevi ve bir oyun), tek bir çağrılabilir yerine, ortam adlarını fabrikalara eşleyen bir sözlük geçirin. Her rollout, veri setindeki `environment` alanı üzerinden ortamını seçer ve **sadece o ortamın araçları açığa vurulur**. Bu, alakasız araçların sızmasını önler (oyunun `move` aracının bir kodlama örneğine, ve tersinin). Her ortam yine kendi verisine sahip olur ve `reset()` üzerinden istemi döndürür; bu nedenle veri setinin, ortamlar arasında yönlendirme için yalnızca `environment` sütununa ihtiyacı vardır.

```python
import random

from datasets import Dataset
from trl import GRPOConfig, GRPOTrainer

class CodingEnv:
    def reset(self, **kwargs) -> str:
        n = random.randint(1, 20)
        return f"Compute the {n}th Fibonacci number."

    def run_code(self, code: str) -> str:  # exposed as a tool only for "coding" examples
        """Run the given Python code and return its stdout.

        Args:
            code: The Python source to execute.

        Returns:
            The captured standard output.
        """
        ...

class GameEnv:
    def reset(self, **kwargs) -> str:
        return "Reach the goal tile."

    def move(self, action: str) -> str:  # exposed as a tool only for "game" examples
        """Apply an action to the game and return the new observation.

        Args:
            action: One of "up", "down", "left", "right".

        Returns:
            The observation after the move.
        """
        ...

# The dataset only routes: each row picks the environment for that rollout
dataset = Dataset.from_dict({"environment": ["coding", "game"] * 500})

trainer = GRPOTrainer(
    model="Qwen/Qwen3-0.6B",
    args=GRPOConfig(chat_template_kwargs={"enable_thinking": False}),
    train_dataset=dataset,
    reward_funcs=reward_func,
    environment_factory={"coding": CodingEnv, "game": GameEnv},
)
trainer.train()
```

Ödül fonksiyonu, her örneğin ortamını yine `reward_kwargs["environments"]` üzerinden alır; bu sayede ortam türüne göre dallanabilir (ör. `isinstance(env, CodingEnv)`). Ortam örnekleri adımlar arasında yeniden kullanılır (epizodlar arasında sıfırlanır), bu nedenle pahalı bir `__init__` her adımda değil yalnızca bir kez ödenir. `environment` alanı eğitimci tarafından tüketilir ve `reset` fonksiyonuna **iletilmez**.

### Çok Modlu Araç Yanıtları

Araçlar, içerik blokları listesini döndürerek metnin yanı sıra görselleri de geri döndürebilir. Bu, aracın görsel geri bildirim sağladığı VLM ajanı eğitiminde (ör. ekran görüntüleri, grafikler, kamera yakalamaları) kullanışlıdır.

```python
from PIL import Image

def take_screenshot() -> list:
    """
    Takes a screenshot of the current screen.

    Returns:
        The screenshot image with a description.
    """
    img = Image.open("screenshot.png")
    return [{"type": "image", "image": img}, {"type": "text", "text": "Here is the screenshot."}]
```

Dönen görüntüler, sohbetin içine otomatik olarak enjekte edilir ve sonraki üretim turları için VLM'ye iletilir.

### Desteklenen Modeller

Test edildi:

- **Beam** — örn. `reflection/Beam-1.0-501B-A23B`
- [**DeepSeek-R1**](https://huggingface.co/collections/deepseek-ai/deepseek-r1) — örn., `deepseek-ai/DeepSeek-R1`
- [**Gemma4**](https://huggingface.co/collections/google/gemma-4) — örn. `google/gemma-4-E2B-it`
- **GLM-4-MoE** ([4.5](https://huggingface.co/collections/zai-org/glm-45), [4.6](https://huggingface.co/collections/zai-org/glm-46) veya [4.7](https://huggingface.co/collections/zai-org/glm-47)) — örn., `zai-org/GLM-4.7`
- [**GPT-OSS**](https://huggingface.co/collections/openai/gpt-oss) — örn. `openai/gpt-oss-20b`
- [**Llama 3.1**](https://huggingface.co/collections/meta-llama/llama-31) — örn. `meta-llama/Llama-3.1-8B-Instruct`
- [**Llama 3.2**](https://huggingface.co/collections/meta-llama/llama-32) — örn. `meta-llama/Llama-3.2-3B-Instruct`
- [**Qwen2.5**](https://huggingface.co/collections/Qwen/qwen25) — örn. `Qwen/Qwen2.5-0.5B-Instruct`
- [**Qwen3**](https://huggingface.co/collections/Qwen/qwen3) — örn. `Qwen/Qwen3-0.6B`
- [**Qwen3-VL**](https://huggingface.co/collections/Qwen/qwen3-vl) — örn. `Qwen/Qwen3-VL-2B-Instruct`
- [**Qwen3.5**](https://huggingface.co/collections/Qwen/qwen35) — örn., `Qwen/Qwen3.5-2B`
- [**Qwen3.6**](https://huggingface.co/collections/Qwen/qwen36) — örn. `Qwen/Qwen3.6-35B-A3B`

> [!TIP]
> Tüm LLM'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.

### Ortam Entegrasyonları

Tüm ortamlar aynı `environment_factory` yuvasına bağlanır, bu nedenle TRL düzeyinde birbirinin yerine kullanılabilirler — görevinize uygun ekosisteme sahip olanı seçin:

| Entegrasyon | Nedir | Bunu şu durumda kullanın |
|---|---|---|
| [OpenEnv](openenv) | Hugging Face ve topluluk tarafından desteklenen açık ortam standardı (Gymnasium tarzı API, WebSocket üzerinden veya konteynerize edilmiş çalıştırma ile sunulur). | Hub'dan hazır bir OpenEnv ortamı kullanıyorsunuz veya açık standarda göre kendi ortamınızı tanımlıyorsunuz (ör. Wordle, Sudoku, Catch). |
| [OpenReward](openreward) | ORS konuşan ortamlarla entegrasyon ([openreward.ai](https://openreward.ai) kataloğu veya kendi ORS sunucunuz); görevler **ve** ödüller HTTP üzerinden sunulur. | Bir ORS ortamına karşı eğitim almak istiyorsunuz: kataloğu (ör. `Eigent/SETA`), kendi altyapınızda barındırdığınız bir ortam veya üzerinde çalıştığınız yerel bir sunucu. |
| [Harbor](harbor) | Harbor görev takımlarıyla bir entegrasyon: her görev bir talimat, gerçek bir kum havuzu görüntüsü (`docker`, `e2b`, ...) ve kum havuzu içinde bir doğrulayıcıdır. | Bir Harbor görev setine karşı eğitim yapmak istiyorsunuz: her biri kendi içinde bağımsız bir kum havuzu ve doğrulayıcıdan oluşan (örneğin, bir kum havuzundaki dosyaları inceleyen ve bir değerlendiricinin kontrol ettiği bir yanıt yazan veri analizi ajanı) görevlerden oluşan bir ağaç. |

## Görsel Dil Modellerinin Eğitimi

GRPO, 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 [grpo\_vlm.py](https://github.com/huggingface/trl/blob/main/examples/grpo_visual_math/grpo_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/grpo_visual_math/grpo_visual_math.py \
  --deepspeed examples/deepspeed_configs/zero3.json \
  --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
  --output_dir grpo-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.

## GRPOTrainer[[trl.GRPOTrainer]]

#### trl.GRPOTrainer[[trl.GRPOTrainer]]

```python
trl.GRPOTrainer(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]]] | None = None, args: trl.trainer.grpo_config.GRPOConfig | 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, tools: list[collections.abc.Callable] | None = None, rollout_func: collections.abc.Callable[[list[str], 'GRPOTrainer'], dict[str, typing.Any]] | None = None, environment_factory: collections.abc.Callable[[], trl.trainer.grpo_trainer._SupportsReset] | dict[str, collections.abc.Callable[[], trl.trainer.grpo_trainer._SupportsReset]] | None = None)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.0/trl/trainer/grpo_trainer.py#L143)

**Parametreler:**

model (`str` veya [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) veya `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, örneğin `'./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` nesnesi. Yalnızca nedensel dil modelleri desteklenir.

reward_funcs (`RewardFunc | list[RewardFunc]`, *isteğe bağlı*) : Ödülleri hesaplamak için kullanılacak ödül işlevleri. Ödülleri hesaplamak için tüm ödül işlevlerini istemler ve tamamlamalarla çağırıp ödülleri topluyoruz. Ödül, `environment_factory` aracılığıyla ortam tarafından sağlandığında (aşağıya bakınız) atlanabilir. 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* 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ıyla [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 eşzamanlı veya asenkron olabilir ve ödülün bu ö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 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ız.  Eğitmenin 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şerek erişilebilir. - Bir ödül işlevleri listesi, burada 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 ([GRPOConfig](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOConfig), *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), *isteğe bağlı*) : 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.  Sadece bir `environment_factory` sağlandığında ve ortamın veriyi kendine ait (veya prosedürel olarak üretilen) veriyi içerip `reset()` metodundan prompt'u döndürdüğü durumda atlanabilir. Bu durumda, eğitim süresini tanımlamak için `max_steps` ayarlanmalıdır.  `train_dataset` bir [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset) (ör. bir akış veri seti) olduğunda, 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 gerekli olması nedeniyle, eğitim argümanlarında `max_steps` ayarlanmalı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`, *isteğe bağlı*) : Modeli sarmak için kullanılan PEFT yapılandırması. `None` ise model sarılmaz.

tools (`Callable` listesi, *isteğe bağlı*) : Modelin üretim sırasında çağırabileceği çağrılabilir araç fonksiyonlarının (senkron veya asenkron) listesi. Her araç, uygun şekilde tip ipucu eklenmiş argümanlara ve dönüş değerlerine sahip standart bir Python fonksiyonu olmalı ve amacını, argümanlarını ve dönüş değerini açıklayan bir Google tarzı docstring içermelidir. Daha fazla ayrıntı için bkz: https://huggingface.co/docs/transformers/en/chat_extras#passing-tools. Model, fonksiyonu nasıl çağıracağını belirlemek için fonksiyonun adını, tip ipuçlarını ve docstring'ini kullanır. Modelin sohbet şablonunun araç kullanımını desteklediğinden ve araç çağırma için ince ayar yapıldığından emin olun.

rollout_func (`RolloutFunc`, *isteğe bağlı*) : Tamamlamaları üretmek için kullanılacak işlev. Mevcut sürece tahsis edilen istem listesini ve eğitmen örneğini alır. `"prompt_ids"`, `"completion_ids"` ve `"logprobs"` alanlarına sahip bir sözlük döndürmelidir ve isteğe bağlı olarak `"logprob_token_ids"` (şekli `"logprobs"` ile aynı) döndürebilir. Diğer tüm alanlar ödül işlevlerine iletilir. İşlev, kopyalama yapılmadan ham süreç başına istem dilimini alır; her istem için doğru sayıda tamamlama döndürmekten sorumludur (eğitimci üzerindeki `num_generations` / `num_generations_eval` değerlerine bakın). Bu özellik deneyseldir ve önceden haber verilmeden herhangi bir zamanda değiştirilebilir veya kaldırılabilir.

environment_factory (`EnvironmentFactory` veya `dict[str, EnvironmentFactory]`, *isteğe bağlı*) : Bir ortam örneği oluşturup döndüren çağrılabilir bir nesne veya ortam adlarını bu tür çağrılabilir nesnelere eşleyen bir sözlük. Ortam sınıfı, üretim sırasında araç olarak çağrılabilen yöntemler tanımlamalıdır. Her yöntem, yukarıda açıklanan `tools` ile aynı gereksinimleri karşılamalıdır. Ortam, üretimler arasında durumu sıfırlamak için kullanılabilen çağrılabilir bir `reset` yöntemi de uygulamalıdır. `reset` yöntemi `None` veya bir dize döndürmelidir: bir dize döndürdüğünde, bu dize üretimden önce son kullanıcı mesajına eklenir. Ortam, argüman almayan ve `float` döndüren bir `get_reward` yöntemi de tanımlayabilir: bu yöntem mevcut olduğunda ödülün sahibi ortamdır ve `get_reward`, tamamlanan her rollout için ortamdaki iç duruma göre puanlamak üzere bir kez çağrılır. Bu, `reward_funcs` ile birlikte (ağırlığı 1 olan ve ortamın sınıf adı altında kaydedilen) ek bir ödül kaynağı olarak görev yapar; bu durumda `reward_funcs` isteğe bağlı hale gelir. Tek bir çağrılabilir nesne kullanıldığında, tüm örnekler aynı ortamı kullanır ve etkileşimlerinin izole kalması için her rollout için bir örnekleme yapılır. Sözlük kullanıldığında, her örnek ortamını adıyla seçen bir `environment` alanı taşımalıdır ve yalnızca o ortamın araçları prompt'ta açığa çıkarılır — bu da tek bir çalıştırmada görevlerin karıştırılmasına (ör. bir kodlama ortamı ve bir oyun) olanak tanır. Bu özellik deneyseldir ve önceden haber verilmeden herhangi bir zamanda değiştirilebilir veya kaldırılabilir.

Grup Göreceli Politika Optimizasyonu (GRPO) yöntemi için Trainer. Bu algoritma ilk olarak [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models](https://huggingface.co/papers/2402.03300) makalesinde önerilmiştir.

Örnek:

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

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

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

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

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

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.0/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.GRPOTrainer.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.0/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.

## GRPOConfig[[trl.GRPOConfig]]

#### trl.GRPOConfig[[trl.GRPOConfig]]

```python
trl.GRPOConfig(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 = True, 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, cast_lm_head_to_fp32: bool = False, num_generations: int | None = 8, 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.0, num_iterations: int = 1, epsilon: float = 0.2, delta: float | None = None, epsilon_high: float | None = None, sapo_temperature_neg: float = 1.05, sapo_temperature_pos: float = 1.0, vespo_k_pos: float = 2.0, vespo_lambda_pos: float = 3.0, vespo_k_neg: float = 3.0, vespo_lambda_neg: float = 2.0, importance_sampling_level: str = 'token', reward_weights: list[float] | None = None, multi_objective_aggregation: str = 'sum_then_normalize', scale_rewards: str = 'group', loss_type: str = 'dapo', mask_truncated_completions: bool = False, sync_ref_model: bool = False, ref_model_mixup_alpha: float = 0.6, ref_model_sync_steps: int = 512, top_entropy_quantile: float = 1.0, entropy_coef: float = 0.0, use_adaptive_entropy: bool = False, entropy_coef_min: float = 0.0, entropy_coef_max: float = 1.0, entropy_coef_delta: float = 0.005, entropy_target: float = 0.2, max_tool_calling_iterations: int | None = None, vllm_importance_sampling_correction: bool = True, vllm_importance_sampling_mode: str = 'sequence_mask', vllm_importance_sampling_clip_max: float | None = 3.0, vllm_importance_sampling_clip_min: float | None = None, off_policy_mask_threshold: float | None = None, use_bias_correction_kl: bool = True, log_completions: bool = False, log_multimodal: bool = True, num_completions_to_print: int | None = None, log_unique_prompts: bool = False, log_completions_hub_repo: str | None = None, use_transformers_continuous_batching: bool = False, transformers_continuous_batching_config: dict | str | None = None, use_transformers_paged: bool = False, vllm_importance_sampling_cap: float | None = None)
```

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

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

model_init_kwargs (`str` veya `dict[str, Any]`, *isteğe bağlı*) : [GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer)'ın `model` argümanı bir dize olarak verildiğinde [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) için kullanılan anahtar kelime argümanları. `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.

cast_lm_head_to_fp32 (`bool`, *isteğe bağlı*, varsayılan `False`) : Politik ve referans modellerin dil modelleme başlığının float32'ye dönüştürülüp dönüştürülmeyeceğini belirtir. [ScaleRL](https://huggingface.co/papers/2510.13786) tarifi tarafından önerildiği gibi. Bu bayrak, yalnızca modelin ayrılmamış kelme gömme ve dil modelleme başlığı katmanlarına sahip olması durumunda desteklenir, yani model yapılandırmasında `tie_word_embeddings` False olmalıdır.

**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 `8`) : 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.0`) : KL katsayısı. `0.0` (varsayılan) ise referans model yüklenmez, bu da bellek kullanımını azaltır ve eğitim hızını artırır. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning](https://huggingface.co/papers/2501.12948) `0.001` değerini kullanı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.

delta (`float`, *isteğe bağlı*) : float olarak ayarlandığında, iki taraflı GRPO kaybında üst kırpma sınırını etkinleştirir. `None` (varsayılan) ise standart GRPO kırpma işlemi kullanılır. Etkinleştirildiğinde `1 + ε` değerinden büyük olması önerilir. Bu yöntem [INTELLECT-2 teknik raporunda](https://huggingface.co/papers/2505.07291) tanıtılmıştır.

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 alır. [DAPO](https://huggingface.co/papers/2503.14476) makalesi `0.28` değerini önerir. `loss_type='cispo'` ile kullanıldığında, bu değer [ScaleRL makalesinde](https://huggingface.co/papers/2510.13786) belirtilen ε_max parametresine karşılık gelir ve varsayılan olarak önerilen `5.0` değerini alır.

sapo_temperature_neg (`float`, *isteğe bağlı*, varsayılan `1.05`) : `sapo` kayıp fonksiyonunda kullanılan, pozitif olmayan avantaj puanlarına sahip jetonlar için sıcaklık. Bu parametre, [Soft Adaptive Policy Optimization makalesinde](https://huggingface.co/papers/2511.20347) tanıtılmıştır.

sapo_temperature_pos (`float`, *isteğe bağlı*, varsayılan `1.0`) : `sapo` kayıp fonksiyonunda pozitif avantaj puanlarına sahip jetonlar için kullanılan sıcaklık. Bu parametre, [Soft Adaptive Policy Optimization makalesinde](https://huggingface.co/papers/2511.20347) tanıtılmıştır.

vespo_k_pos (`float`, *isteğe bağlı*, varsayılan `2.0`) : pozitif avantajlar için k parametresi, VESPO kaybında üs olarak kullanılır. Düşük önem ağırlıklarına sahip örneklerin (önem örneklemesi oranı < 1 olduğunda) ne kadar agresif bir şekilde ağırlığının azaltılacağını kontrol eder.

vespo_lambda_pos (`float`, *isteğe bağlı*, varsayılan `3.0`) : pozitif avantajlar için lambda parametresi, VESPO kaybında sönümleme faktörüdür. Yüksek önem ağırlıklarına sahip örneklerin (önem örneklemesi oranı > 1 olduğunda) ne kadar agresif bir şekilde ağırlığının azaltılacağını kontrol eder.

vespo_k_neg (`float`, *isteğe bağlı*, varsayılan `3.0`) : negatif avantajlar için k parametresi, VESPO kaybında üs olarak kullanılır. Düşük önem ağırlıklarına sahip örneklerin (önem örneklemesi oranı < 1 olduğunda) ne kadar agresif bir şekilde ağırlığının azaltılacağını kontrol eder.

vespo_lambda_neg (`float`, *isteğe bağlı*, varsayılan `2.0`) : negatif avantajlar için lambda parametresi, VESPO kaybında üstel sönümleme faktörüdür. Yüksek önem ağırlıklarına sahip örneklerin (önem örneklemesi oranı > 1 olduğunda) ne kadar agresif bir şekilde ağırlığının azaltılacağını kontrol eder.

importance_sampling_level (`str`, *isteğe bağlı*, varsayılan `"token"`) : Önem örneklemesi oranlarının `"token"` veya `"sequence"` düzeyinde hesaplanıp hesaplanmayacağını kontrol eder. `"token"`, ham token başına log-olasılık oranlarını (token başına bir ağırlık) korur. `"sequence"`, log-olasılık oranlarını geçerli tokenler arasında ortalayarak dizi başına tek bir oran üretir. [GSPO makalesi](https://huggingface.co/papers/2507.18071), dizi düzeyinde örneklemenin genellikle daha kararlı eğitim ve dizi düzeyindeki ödüllerle daha iyi hizalanma sağladığını göstermektedir.

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.

multi_objective_aggregation (`str`, *isteğe bağlı*, varsayılan `"sum_then_normalize"`) : Birden fazla ödül fonksiyonunu birleştirmek için kullanılan yöntem. Desteklenen değerler şunlardır:  - `"sum_then_normalize"` (varsayılan): Önce her ödül fonksiyonundan ağırlıklı ödüller toplanır, ardından `scale_rewards` tarafından belirtilen ödül ölçekleme/düzenleme uygulanır (detaylar için `scale_rewards` bölümüne bakınız). - `"normalize_then_sum"`: Önce her ödül fonksiyonu, nesiller arasında (her grup içinde) normalize edilir/ölçeklenir, ardından normalize edilen ödüller belirtilen ağırlıklar kullanılarak toplanır. Birleştirilen ödül, avantajlar oluşturulurken batch düzeyinde normalize edilir. Bu, [GDPO: Group reward-Decoupled Normalization Policy Optimization for Multi-reward RL Optimization](https://huggingface.co/papers/2601.05242) makalesinde önerilen yaklaşımdır.

scale_rewards (`str` veya `bool`, *isteğe bağlı*, varsayılan `"group"`) : Ödüllere uygulanacak ölçekleme stratejisini belirtir. Desteklenen değerler şunlardır:  - `True` veya `"group"` (varsayılan): Ödüller, her grup içindeki standart sapmaya göre ölçeklenir; bu, bir grup içinde birim varyansın sağlanmasını garanti eder. - `"batch"`: Ödüller, [PPO Lite makalesi](https://huggingface.co/papers/2508.08221)nde önerildiği gibi tüm batch boyunca hesaplanan standart sapmaya göre ölçeklenir. - `False` veya `"none"`: Ölçekleme uygulanmaz. [Dr. GRPO makalesi](https://huggingface.co/papers/2503.20783), standart sapmaya göre ölçeklemenin soru düzeyinde bir zorluk yanlılığına yol açtığı için ödülleri ölçeklememeyi önerir.

loss_type (`str`, *isteğe bağlı*, varsayılan `"dapo"`) : Kullanılacak kayıp formülasyonunu belirtir. Desteklenen değerler şunlardır:  - `"grpo"`: Token düzeyindeki kayıpları, dizinin uzunluğuna göre normalize ederek birleştirir. Uzunluk yanlılığı nedeniyle önerilmez—bu yaklaşım, pozitif avantajlara sahip daha kısa tamamlamaları ve negatif avantajlara sahip daha uzun tamamlamaları tercih etme eğilimindedir. - `"dr_grpo"`: Token düzeyindeki kayıpları, küresel bir sabit ile normalize ederek birleştirir. Bu yöntem, uzunluk yanlılığını ortadan kaldırmak için [Dr. GRPO makalesinde](https://huggingface.co/papers/2503.20783) tanıtılmıştır. Sabitin değeri `max_completion_length` ile eşleşir. - `"dapo"` (varsayılan): Token düzeyindeki kayıpları, küresel birikimli batch'teki aktif token sayısına göre normalize ederek birleştirir. Bu yöntem, uzunluk yanlılığını ortadan kaldırmak için [DAPO makalesinde](https://huggingface.co/papers/2503.14476) tanıtılmıştır. - `"bnpo"`: Token düzeyindeki kayıpları, yerel batch'teki aktif token sayısına göre normalize ederek birleştirir. Normalizasyonun yalnızca yerel batch üzerinde yapıldığına dikkat edin; bu nedenle, sabit bir etkili batch boyutuna rağmen sonuçlar, yerel batch boyutuna bağlı olarak hafifçe değişebilir. `per_device_train_batch_size==1` kullanıldığında, kayıp GRPO kaybına eşdeğerdir. - `"cispo"`: Avantaj ölçekli önem örneklemesi ağırlıkları yerine, önem örneklemesi ağırlıklarını kırpma (clipping) işlemine tabi tutar. Kırpılmış ağırlıklar, ardından avantajlar ve politika modelinin log olasılıkları ile çarpılır. Bireysel token kayıpları, küresel birikimli batch'teki aktif token sayısına göre normalize edilerek birleştirilir. Bu yöntem, [MiniMax-M1 makalesinde](https://huggingface.co/papers/2506.13585) tanıtılmıştır. - `"sapo"`: [Soft Adaptive Policy Optimization makalesinde](https://huggingface.co/papers/2511.20347) tanıtıldığı üzere, Yumuşak Uyarlanabilir Politika Optimizasyonu kaybı. Sert kırpma yerine, faydalı öğrenme sinyallerini korurken off-policy güncellemelerini uyumlu bir şekilde azaltan, sıcaklık kontrollü, pürüzsüz bir kapı (gate) kullanır. - `"luspo"`: Uzunluk-Yansız Dizi Politika Optimizasyonu kaybı. Her dizinin kaybını uzunluğuna göre ölçekleyen bir dizi düzeyinde kayıptır. Bu, GSPO'nun bir değişikliğidir ve `importance_sampling_level="sequence"` gerektirir. [LUSPO makalesinde](https://huggingface.co/papers/2602.05261) tanıtılmıştır. - `"vespo"`: Varyasyonel Dizi Düzeyinde Yumuşak Politika Optimizasyonu. Sert kırpma yerine, dizi düzeyindeki önem ağırlıklarına doğrudan uygulanan pürüzsüz, asimetrik bir Gamma ağırlıklandırma fonksiyonu kullanır. [VESPO makalesinde](https://huggingface.co/papers/2602.10693) tanıtılmıştır.

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.

top_entropy_quantile (`float`, *isteğe bağlı*, varsayılan `1.0`) : [Beyond the 80/20 Rule](https://huggingface.co/papers/2506.01939) makalesindeki ρ parametresi. Politika kaybı teriminde, her dizi konumu için olasılık dağılımının entropisine göre en yüksek ρ kantilindeki tokenları korur ve sonuçları iyileştirir. Aralık: `[0.0-1.0]`. `0.0` değeri, en yüksek entropili token hariç tümünü maskelemeye alır; `1.0` tüm tokenları korur. Makale `0.2` değerini önerir. `mask_truncated_completions=True` ile kullanılırsa, yalnızca kesilmemiş tamamlamalardaki tokenlar dikkate alınır.

entropy_coef (`float`, *opsiyonel*, varsayılan `0.0`) : Kayıp fonksiyonundaki entropi düzenleme teriminin katsayısı. Pozitif bir değer, politikayı neredeyse deterministik çıktılara çökmeden tutarak keşfi teşvik eden bir entropi bonusu ekler. Bonus, `loss_type` değerinden bağımsız olarak her zaman token başına ortalama entropidir; bir kayıp türünün politika normalizasyonuyla eşleşecek şekilde yeniden ölçeklenmez, bu nedenle `entropy_coef` her kayıp türü için aynı anlama gelir. `use_adaptive_entropy=True` olduğunda, bu başlangıç katsayısı olarak görev yapır ve her optimizasyon adımında güncellenir. `0.0` (varsayılan) olarak ayarlandığında hiçbir etkisi yoktur.

use_adaptive_entropy (`bool`, *isteğe bağlı*, varsayılan `False`) : [Skywork-OR1](https://huggingface.co/papers/2505.22312)'de tanıtılan adaptif entropi kontrolünün kullanılıp kullanılmayacağını belirtir. Etkinleştirildiğinde, entropi katsayısı `entropy_coef` her optimizasyon adımında güncellenir: mevcut entropi `entropy_target`'ın altındaysa `entropy_coef_delta` kadar artırılır, aksi halde azaltılır. Katsayı yalnızca entropi `entropy_target`'a eşitse veya altındaysa uygulanır.

entropy_coef_min (`float`, *isteğe bağlı*, varsayılan `0.0`) : Adaptif entropi kontrolü kullanıldığında entropi katsayısı için alt sınır.

entropy_coef_max (`float`, *isteğe bağlı*, varsayılan `1.0`) : Adaptif entropi kontrolü kullanıldığında entropi katsayısı için üst sınır.

entropy_coef_delta (`float`, *isteğe bağlı*, varsayılan `0.005`) : Adaptif entropi kontrolü sırasında her optimizasyon adımında entropi katsayısını ayarlamak için kullanılan adım boyutu.

entropy_target (`float`, *isteğe bağlı*, varsayılan `0.2`) : Adaptif entropi kontrolü tarafından kullanılan hedef ortalama token başına entropi (nat cinsinden). Katsayı yalnızca mevcut entropi bu değerin altında veya eşit olduğunda uygulanır. Politika kaybıyla aynı token kümesi üzerinde ölçülür: varsayılan olarak tüm tamamlama tokenları veya `top_entropy_quantile < 1.0` olduğunda yalnızca yüksek entropili alt küme. Tipik dil modellerinin token başına entropileri 2–10 nat aralığındadır, bu nedenle `0.2` varsayılanı neredeyse asla düzenlemeyi tetiklemez (yalnızca neredeyse tam entropi çöküşünde); bonusu politika çökmeden önce devreye sokmak için bunu eğitimde erken gözlemlediğiniz entropiye yakın ayarlayın (`entropy` metriği olarak kaydedilir) ve `top_entropy_quantile` kullanırken token alt kümesini dikkate alın.

max_tool_calling_iterations (`int`, *isteğe bağlı*) : Bir ajan eğitilirken araç çağırma turlarının maksimum sayısı. `None` ise, bir sınır yoktur ve üretim; modelin araç çağrısı içermeyen bir yanıt turu oluşturması, tamamlamanın (tüm turlar ve araç sonuçları) `max_completion_length` jetona ulaşması veya tam dizinin modelin maksimum uzunluğuna (`vllm_mode="colocate"` için `vllm_max_model_length`, aksi halde modelin `max_position_embeddings`) ulaşması durumunda durur.

vllm_importance_sampling_correction (`bool`, *isteğe bağlı*, varsayılan `True`) : vLLM tamamlama logprobs'leri ile yeniden hesaplanan eğitim logprobs'leri arasındaki uyumsuzluğu düzeltmek için Önem Numunelendirmesi (IS) uygulanıp uygulanmayacağını belirtir. `False` olarak ayarlanırsa, `vllm_importance_sampling_mode` ne olursa olsun IS uygulanmaz. `True` olduğunda, seçilen mod, IS oranlarının nasıl hesaplanacağını ve sınırlandırılacağını belirler. `top_p < 1`, `top_k > 0` veya `min_p > 0` kullanıldığında, yeniden hesaplanan logprobs'ler, her token'ın örneklemesinin yapıldığı aday kümesi üzerinde normalize edilir; bunun için vLLM 0.28 veya üzeri sürüm ve sunucu modunda `--return-sampling-mask` ile başlatılmış bir sunucu (vLLM 0.30'dan itibaren `--enable-scale-out`) gereklidir; aksi takdirde IS oranları yanlı olur. vLLM bu aday kümesini `top_k` ile sınırlar, bu nedenle onu dilbilgisi izin verdiği token'lara daraltan `top_p < 1`, `min_p > 0` ve yapılandırılmış çıktılar için `top_k > 0` (ör. `top_k=512`) gereklidir. Aksi halde eğitimi durduracak olan yapılandırılmış çıktılar da bu aday kümesini gerektirir. vLLM, döndürdüğü logprobs'lere `repetition_penalty` uygular, bu nedenle `repetition_penalty != 1.0` için `vllm_importance_sampling_correction=False` gereklidir.

vllm_importance_sampling_mode (`str`, *isteğe bağlı*, varsayılan `"sequence_mask"`) : `vllm_importance_sampling_correction=True` olduğunda Importance Sampling'in nasıl gerçekleştirileceğini belirtir. Olası değerler şunlardır:  - `"token_truncate"`: Token düzeyinde kesilmiş IS. Token başına oranlar [C_min, C_max] aralığına kırpılır. - `"token_mask"`: Token düzeyinde maskelenmiş IS. [C_min, C_max] aralığının dışındaki token başına oranlar sıfıra ayarlanır. - `"sequence_truncate"`: Dizi düzeyinde kesilmiş IS. Tek bir dizi oranı [C_min, C_max] aralığına kırpılır ve dizideki tüm tokenlara uygulanır. - `"sequence_mask"`: Dizi düzeyinde maskelenmiş IS. Oranları [C_min, C_max] aralığının dışında olan diziler maskelenir.

vllm_importance_sampling_clip_max (`float`, *isteğe bağlı*, varsayılan `3.0`) : `vllm_importance_sampling_mode` tarafından kullanılan önem örneklemesi üst sınırı C_max. `*_truncate` modlarında, önem oranları C_max değerinden yukarı doğru kırpılır. `*_mask` modlarında, C_max'tan büyük olan oranlar sıfıra ayarlanır.

vllm_importance_sampling_clip_min (`float`, *isteğe bağlı*) : `vllm_importance_sampling_mode` tarafından kullanılan önem örneklemesi alt sınırı C_min. `*_truncate` modlarında oranlar alttan C_min değerinde kırpılır. `*_mask` modlarında C_min'den düşük olan oranlar sıfıra ayarlanır. C_min'den düşük oranları üst sınır olmadan kesin olarak maskelemek için `vllm_importance_sampling_clip_max=None` değerini ayarlayın.

off_policy_mask_threshold (`float`, *isteğe bağlı*) : Off-policy dizgi maskelenmesi için eşik değeri. `None` ise off-policy dizgi maskelenmesi devre dışı bırakılır. Ayarlandığında, negatif avantajlara ve yüksek KL sapmasına sahip dizgiler, eğitimi istikrarlı tutmak için maskelenir. Bu parametre, [DeepSeek-V3.2 makalesi](https://huggingface.co/papers/2512.02556)ndeki Denklem 9'daki `delta` eşiğine karşılık gelir. Pozitif bir değer (ör. 0.5) bekler.

use_bias_correction_kl (`bool`, *isteğe bağlı*, varsayılan `True`) : KL teriminin, [DeepSeek-V3.2 makalesinde](https://huggingface.co/papers/2512.02556) açıklandığı gibi KL gradyanının tarafsız ters-KL gradyanı olmasını sağlamak için önem örneklemesi oranıyla çarpılıp çarpılmayacağını belirtir. Bu, `beta != 0` durumunda, politika üzerinde (on-policy) dahil olmak üzere, KL gradyanını değiştirir: oran türevlenebilir olduğundan, değeri tam olarak 1 olan yerlerde bile gradyanı etkiler. Tarafsız ters-KL özelliği `importance_sampling_level="token"` için geçerlidir; `"sequence"` kullanıldığında ise dizi düzeyindeki ağırlık, token başına KL değerlerine yayılır.

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

log_completions_hub_repo (`str`, *isteğe bağlı*) : Tamamlamaların kaydedileceği Hugging Face Hub deposu. `'username/reponame'` veya `'orgname/reponame'` gibi tam bir depo adı olmalı ya da yalnızca `'reponame'` olmalı; bu durumda depo, şu anda oturum açmış Hugging Face kullanıcısının ad alanına oluşturulur. `hub_private_repo=True` olarak ayarlamadığınız veya organizasyonunuzun varsayılanı özel depolar oluşturmak olmadıkça, bu deponun herkese açık olacağını unutmayın.

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

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

[GRPOTrainer](/docs/trl/v1.18.0/tr/grpo_trainer#trl.GRPOTrainer) için yapılandırma sınıfı.

Bu sınıf yalnızca GRPO 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.

