TRL documentation

GRPO Eğiticisi

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

GRPO Eğiticisi

model badge

Genel Bakış

TRL, Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, Y. K. Li, Y. Wu ve Daya Guo tarafından kaleme alınan DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models 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 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 setindeki istemlerle bir Qwen2.5 0.5B Instruct modeli eğitilir. Veri setindeki verilere buradan erişebilirsiniz:

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

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

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

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

Tamamlamalar oluşturma

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

Avantajın hesaplanması

Her bir G G dizi 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: A^i,t=ri−mean(r)std(r)\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).

Makalede Understanding R1-Zero-Like Training: A Critical Perspective şu gösterilmiştir: std(r) \text{std}(\mathbf{r}) ile ölçeklendirme, soru düzeyinde bir zorluk yanlılığına neden olabilir. Bu ölçeklendirmeyi devre dışı bırakmak için scale_rewards=False içinde GRPOConfig. std tabanlı ölçeklendirmeyi kapatmak, varyans normalleştirmesini de 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ıdır.

Bölüm I: Hile mi Tuzak mı? LLM Muhakemesi için RL’ye Derinlemesine Bakış (Lite PPO) 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 içinde scale_rewards="batch" ayarlayarak bu ölçekleme stratejisini kullanabilirsiniz.

KL sapmasının tahmini

KL sapması, tarafından tanımlanan yaklaşık hesaplayıcı kullanılarak tahmin edilir Schulman ve ark. (2020). Yaklaşık hesaplayıcı şu şekilde tanımlanır: DKL[πθ∥πref]=πref(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)−log⁡πref(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)−1,\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 politikanın yakınında kalmasını sağlayarak avantajı en üst düzeye çıkarmaktır. Sonuç olarak, kayıp şu şekilde tanımlanır: LGRPO(θ)=−1∑i=1G∣oi∣∑i=1G∑t=1∣oi∣[πθ(oi,t∣q,oi,<t)[πθ(oi,t∣q,oi,<t)]no gradA^i,t−βDKL[πθ∥πref]], \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.

Orijinal formülasyondaki DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models, ile ölçekleme yapmıyoruz 1∣oi∣ \frac{1}{|o_i|} çünkü Understanding R1-Zero-Like Training: A Critical Perspective makalesinde bunun yanıt düzeyinde bir uzunluk yanlılığına yol açtığı gösterilmiştir. Daha fazla ayrıntı için kayıp türleri.

Orijinal formülasyona kıyasla DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models, varsayılan olarak β=0.0 \beta = 0.0 kullanıyoruz; bu da KL ayrılığı teriminin kullanılmadığı anlamına gelir. Bu tercih, GRPO ile eğitimde KL ayrılığı teriminin zorunlu olmadığını gösteren çeşitli son çalışmalarla (ör. Open-Reasoner-Zero: An Open Source Approach to Scaling Up Reinforcement Learning on the Base Model) ) motive edilmiştir. Sonuç olarak, bu terimi hariç tutmak yaygın bir uygulama haline gelmiştir (ör. Understanding R1-Zero-Like Training: A Critical Perspective, DAPO: An Open-Source LLM Reinforcement Learning System at Scale). KL ayrılığı terimini dahil etmek isterseniz, beta içindeki GRPOConfig parametresini sıfır olmayan bir değere ayarlayabilirsiniz.

Orijinal makalede, bu formülasyon her üretime birden fazla güncelleme yapılmasını dikkate alacak şekilde genelleştirilmiştir ( μ \mu , ile ayarlanabilir num_iterations içinde GRPOConfig) şunu kullanarak sürrogate amaç fonksiyonu: LGRPO(θ)=−1∑i=1G∣oi∣∑i=1G∑t=1∣oi∣[min⁡(πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t)A^i,t, clip(πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t),1−ϵ,1+ϵ)A^i,t)−βDKL[πθ∥πref]], \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 clip(⋅,1−ϵ,1+ϵ)\text{clip}(\cdot, 1 - \epsilon, 1 + \epsilon) politika oranını 1−ϵ 1 - \epsilon ile 1+ϵ 1 + \epsilon . arasında sınırlayarak güncellemelerin referans politikadan aşırı sapmasını engeller. μ=1 \mu = 1 (TRL'de varsayılan olarak

Kayıp Türleri

Edebiyatta hedefin çeşitli formülasyonları önerilmiştir. Başlangıçta GRPO'nun hedefi şu şekilde tanımlanmıştır: LGRPO(θ)=−1G∑i=1G1∣oi∣∑t=1∣oi∣li,t, \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 li,t=πθ(oi,t∣q,oi,<t)[πθ(oi,t∣q,oi,<t)]no gradA^i,t−βDKL[πθ∥πref]. 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 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: LDAPO(θ)=−1∑i=1G∣oi∣∑i=1G∑t=1∣oi∣li,t, \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 içinde loss_type="dapo" değerini ayarlayın.

Ayrıca, makalede Understanding R1-Zero-Like Training: A Critical Perspective başlangıçtaki GRPO formülasyonunun bir yanıt uzunluğu önyargısı getirdiği gösterilmiştir. DAPO formülasyonunun bu önyargıyı azalttığını, ancak 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: LDr. GRPO(θ)=−1LG∑i=1G∑t=1∣oi∣li,t, \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 içinde loss_type="dr_grpo" değerini ayarlayın.

Alternatif olarak, SAPO makalesi'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 gelen faydalı öğrenme sinyallerini korumasına, aşırı sapmalardan gelen gürültüyü ise bastırmasına olanak tanır.

Kayıp fonksiyonu şu şekilde tanımlanır: LSAPO(θ)=−1G∑i=1G1∣oi∣∑t=1∣oi∣fi,t(πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t))A^i,t \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 fi,t f_{i,t} sigmoid fonksiyonu kullanılarak tanımlanır σ \sigma şu şekilde: fi,t(x)=σ(τi,t(x−1))⋅4τi,t f_{i,t}(x) = \sigma \left( \tau_{i,t} (x - 1) \right) \cdot \frac{4}{\tau_{i,t}}

Sıcaklık τi,t \tau_{i,t} avantajın işaretine göre seçilir A^i,t \hat{A}_{i,t} : τi,t={τpos,if A^i,t>0τneg,otherwise \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ın kullanılmasını öneriyorlar, τneg>τpos \tau_{\text{neg}} > \tau_{\text{pos}} (varsayılan değerler τpos=1.0,τneg=1.05 \tau_{\text{pos}}=1.0, \tau_{\text{neg}}=1.05 ). Bu, modelin kararsızlığı önlemek için “kötü” eylemlere daha sıkı bir şekilde ceza almasını, “iyi” eylemlere ise daha esnek davranmasını sağlar.

Bu formülasyonu kullanmak için 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 kalacak şekilde kırpılan token (veya importance_sampling_level="sequence") düzeyinde) olasılıklarının oranı: clip(ri,t(θ),1−ϵlow,1+ϵhigh) ,ri,t(θ)=πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t) \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 sınırlar.
  • clip_ratio/low_mean: Güven bölgesinin alt sınırında kırpılan token (veya importance_sampling_level="sequence") düzeyinde) olasılıklarının ortalama oranı: ri,t(θ)<1−ϵlowr_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}.
  • clip_ratio/low_min: Tamamlama başına token'ların (veya importance_sampling_level="sequence") güven bölgesinin alt sınırında kırpılan ri,t(θ)<1−ϵlowr_{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") düzeyinde) olasılıklarının ortalama oranı: ri,t(θ)>1+ϵhighr_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}.
  • clip_ratio/high_max: Tamamlama başına token'ların (veya sıralamanın kendisinin, eğer importance_sampling_level="sequence") güven bölgesinin üst sınırında kırpılmışsa) en büyük oranı: ri,t(θ)>1+ϵhighr_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}.
  • cispo_clip_ratio: token (veya importance_sampling_level="sequence") önem örneklemesi ağırlıklarının epsilon_high değerinde kırpılan ve pozitif avantaja sahip olan oranı: ri,t(θ)>ϵhighr_{i,t}(\theta) > \epsilon_\mathrm{high}. yalnızca şu durumda kaydedilir: loss_type="cispo".
  • vespo/phi_seq_mean: VESPO Gamma ağırlıklandırmasının ortalama değeri φ(w)\varphi(w) dizgi düzeyindeki önem ağırlıklarına uygulanan 1.0 değerinin altında olması, dizgilerin ağırlığının azaltıldığı anlamına gelir. Yalnızca loss_type="vespo".

Özelleştirme

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

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

pip install trl[vllm]

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

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

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:

    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:

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

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

Model boyutuna ve eğitim için genel GPU bellek gereksinimlerine bağlı olarak, düşük kullanım oranı veya bellek taşması hatalarını önlemek için 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 sunuyoruz. vllm_gpu_memory_utilization önerisini almak için aşağıdaki gibi kullanmanız yeterlidir:

Önerilen değer ortamınızda işe yaramıyorsa, istikrarı sağlamak için önerilen değere küçük bir pay (ör. +0.05 veya +0.1) eklemenizi öneririz.

Hâlâ bellek dışı (out-of-memory) hataları alıyorsanız vllm_enable_sleep_mode değerini True olarak ayarlayın; bu durumda vllm parametreleri ve önbellek, optimizasyon adımı sırasında dışa aktarılır. Daha fazla bilgi için vLLM Sleep Mode ile Bellek Kullanımını Azaltma başlıklı bölümü inceleyin.

Varsayılan olarak 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 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 önyargılı bir gradyan güncellemesine yol açar ([1][2][3][4][5]). Basitlik adına REINFORCE politika gradyanını ele alalım: ∇θJ(x,θ)=Ey∼πtrain(⋅∣x,θ)[∇θlog⁡πtrain(y∣x,θ)⋅R(x,y)] \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 x bazı bir veri dağılımından örneklenen istemleri (prompts) ifade eder ve πtrain \pi^\text{train} eğitim motoru tarafından uygulanan politikadır. vLLM döngüde olduğunda ayrı bir çıkarım politikası elde ederiz πinference \pi^\text{inference} , böylece etkili politika gradyanı şu hale gelir ∇θJbiased(x,θ)=Ey∼πinference(⋅∣x,θ)[∇θlog⁡πtrain(y∣x,θ)⋅R(x,y)]. \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 (IS). İki IS varyantı sunuyoruz: Kesikli Önem Örneklemesi (TIS) ve Maskeli Önem Örneklemesi (MIS). Her iki varyant da hem token düzeyinde hem de dizgi düzeyinde uygulanabilir. ρ \rho önem ağırlığını, örneğin ρt \rho_t token başına veya ρseq \rho_{\text{seq}} dizgi başına. TIS altında, aralığın dışındaki oranlar [vllm_importance_sampling_clip_min, vllm_importance_sampling_clip_max] kırpılır: ρ←clip(ρ,Cmin⁡,Cmax⁡). \rho \leftarrow \text{clip}(\rho, C_{\min}, C_{\max}).

Orijinal TIS makalesi tek bir üst sınır kırpma mekanizması önermiştir, yani min⁡(ρ,Cmax⁡) \min(\rho, C_{\max}) . TRL'deki uygulama, bunu IcePop yönteminden ilham alarak alt sınır da ekleyerek genelleştirmiş ve yukarıda gösterilen iki taraflı formülasyonu elde etmiştir.
IcePop'ta sınırların etiketlerinin α \alpha ve β \beta olduğunu, TRL'de ise Cmin⁡ C_{\min} ve Cmax⁡ C_{\max} .

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. Thinking Machines, belirsiz çıkarım çekirdeklerini 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 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.

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.

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
    },
)

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

#!/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
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, yoğun ödül modelleri yerine özel ödül işlevlerinin kullanılmasını destekler. Uyumluluğu sağlamak için ödül işlevinizin aşağıdaki gereksinimleri karşılaması gerekir:

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

  1. Girdi argümanları:

    • Fonksiyon aşağıdakileri anahtar kelime argümanları olarak kabul etmelidir:

      • prompts (istemleri içerir),
      • completions (üretilen tamamlamaları içerir),
      • completion_ids (tokenize edilmiş tamamlamaları içerir),
      • trainer_state (TrainerState): Eğiticinin (trainer) mevcut durumu. Bu, eğitim ilerlemesine göre ödülün ayarlandığı müfredat öğrenimi (curriculum learning) gibi dinamik ödül fonksiyonlarını uygulamak için kullanılabilir.
      • log_extra: tamamlamalar tablosuna ek sütunlar eklemek için kullanılabilen log_extra(column: str, values: list) çağrılabilir bir nesne. Örnek 6'ya bakın.
      • log_metric: kl, entropy vb. metriklerin yanı sıra skaler metrikleri grafik olarak günlüğe kaydetmek için kullanılan, çağrılabilir log_metric(name: str, value: float). Örnek 6'ya bakın.
      • 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.
      • Veri setinin sahip olabileceği tüm sütun adları (prompt hariç). Örneğin, veri seti ground_truth adında bir sütun içeriyorsa, fonksiyon ground_truth anahtar kelime argümanı olarak çağrılır.

      Bu gerekliliğe uymak için en kolay yol, fonksiyon imzasında **kwargs kullanmaktır.

    • Veri seti biçimine bağlı olarak girdi değişecektir:

      • standart biçim için prompts ve completions dizeleri listeleri olacaktır.
      • sohbet formatı için prompts ve completions, mesaj sözlüklerinden oluşan listeler olacaktır.
  2. Dönüş değeri: İşlev, birer tamamlamaya karşılık gelen ödülü temsil eden birer ondalık sayıdan oluşan bir liste döndürmelidir.

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

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

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

Bunu şu şekilde test edebilirsiniz:

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

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

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

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

Bunu şu şekilde test edebilirsiniz:

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

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

Aşağıda, tamamlamanın belirli bir formata sahip olup olmadığını kontrol eden bir ödül fonksiyonu örneği yer almaktadır. Bu örnek, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning makalesinde kullanılan format reward fonksiyonundan ilham alınmıştır. Yapılandırılmış mesajlardan oluşan istem ve tamamlamaların kullanıldığı bir sohbet formatı için tasarlanmıştır.

import re

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

Bu fonksiyonu şu şekilde test edebilirsiniz:

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

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

Aşağıda, tamamlamanın doğru olup olmadığını kontrol eden bir ödül fonksiyonu örneği yer almaktadır. Bu örnek, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning makalesinde kullanılan accuracy reward fonksiyonundan ilham alınarak hazırlanmıştır. Bu örnek, veri setinin ground_truth adlı bir sütun içerdiği standard format için tasarlanmıştır.

import re

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

Bu fonksiyonu şu şekilde test edebilirsiniz:

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

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

Aşağıda, 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.

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

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

import asyncio

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

Örnek 6: Ek sütunlar ve metrikler kaydetme

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

import re

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

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

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

    return rewards

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

Özel ödül fonksiyonunuzu kullanmak için, bunu GRPOTrainer nesnesine aşağıdaki gibi iletin:

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:

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'ı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ı şu şekilde genişletir: L(θ)=LGRPO(θ)−α⋅H(πθ), \mathcal{L}(\theta) = \mathcal{L}_{\text{GRPO}}(\theta) - \alpha \cdot \mathcal{H}(\pi_\theta),

buradaH(πθ)\mathcal{H}(\pi_\theta) politikanın token başına ortalama entropisidir veα\alpha entropi katsayısıdır. Bonus, her zaman token başına ortalama entropidir; loss_type; türüne bakılmaksızın, bir kayıp türünün politika normalizasyonuna (ör. Dr. GRPO'nun batch_size * max_completion_length paydası) uyarlanarak yeniden ölçeklenmez, bu nedenle entropy_coef tüm kayıp türleri için aynı anlama gelir.

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

from trl import GRPOConfig, GRPOTrainer

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

Uyarlanabilir entropi — katsayı, Skywork-OR1'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):

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 bölümüne bakın.

Ajan Eğitimi

GRPO, ajan eğitimini 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:

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'na bakın.

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ı bölümüne bakın.

Araç çağırma turlarının sayısını sınırlamak için 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 ürettiğinde, tamamlamanın (tüm turlar ve araç sonuçları) max_completion_length belirteç sayısına ulaştığında veya tam dizinin modelin maksimum uzunluğuna ulaştığında durur (vllm_mode="colocate" kullanıldığında vllm_max_model_length, aksi halde modelin max_position_embeddings değeri).

Örnek:

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, her rollout için bir ortam örneği oluşturur ve ortamın genel yöntemlerini araçlar olarak sunar.

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.

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.

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 arasında yönlendirme yapmak istiyorsanız. Her rollout için eğitimci bir satır örnekler, "prompt" sütununu istem (prompt) 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).

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

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

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.

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 — örn., deepseek-ai/DeepSeek-R1
  • Gemma4 — örn. google/gemma-4-E2B-it
  • GLM-4-MoE (4.5, 4.6 veya 4.7) — örn., zai-org/GLM-4.7
  • GPT-OSS — örn. openai/gpt-oss-20b
  • Llama 3.1 — örn. meta-llama/Llama-3.1-8B-Instruct
  • Llama 3.2 — örn. meta-llama/Llama-3.2-3B-Instruct
  • Qwen2.5 — örn. Qwen/Qwen2.5-0.5B-Instruct
  • Qwen3 — örn. Qwen/Qwen3-0.6B
  • Qwen3-VL — örn. Qwen/Qwen3-VL-2B-Instruct
  • Qwen3.5 — örn., Qwen/Qwen3.5-2B
  • Qwen3.6 — örn. Qwen/Qwen3.6-35B-A3B

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:

EntegrasyonNedirBunu şu durumda kullanın
OpenEnvHugging 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).
OpenRewardORS konuşan ortamlarla entegrasyon (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.
HarborHarbor 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

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

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

sınıf trl.GRPOTrainer

< >

( model: str | PreTrainedModel | PeftModelreward_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 = Noneargs: trl.trainer.grpo_config.GRPOConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_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 = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonereward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = Nonetools: list[collections.abc.Callable] | None = Nonerollout_func: collections.abc.Callable[[list[str], 'GRPOTrainer'], dict[str, typing.Any]] | None = Noneenvironment_factory: collections.abc.Callable[[], trl.trainer.grpo_trainer._SupportsReset] | dict[str, collections.abc.Callable[[], trl.trainer.grpo_trainer._SupportsReset]] | None = None )

Parametreler

  • model (str veya PreTrainedModel veya PeftModel) — Eğitilecek model. Şunlardan biri olabilir:
    • Bir dize, huggingface.co üzerindeki bir model deposunda barındırılan ön eğitilmiş bir modelin model kimliği veya 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, from_pretrained'den farklıdır; orada (Transformers v5'ten itibaren) dtype model yapılandırmasından çıkarılır.
    • Bir 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ır ve ödülleri toplar. Ödül, ortam tarafından sağlandığında ( environment_factory (aşağıya bakın) atlanabilir. Aşağıdakilerden biri olabilir:
    • Örneğin aşağıdaki gibi tek bir ödül fonksiyonu:

      • Bir dize: huggingface.co üzerindeki bir model deposunda barındırılan ön eğitilmiş bir modelin model kimliği veya 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 kullanılarak yüklenir.

      • Bir PreTrainedModel nesnesi: Yalnızca sıra sınıflandırma modelleri desteklenir.

      • Özel ödül fonksiyonu: Fonksiyona, istemler (prompts) ve üretilen tamamlamalar ile veri setindeki ek sütunlar sağlanır. Bir ödül listesi döndürmelidir. Özel ödül fonksiyonları senkron veya asenkron olabilir ve ödülün ilgili örnekler için geçerli olmadığı durumlarda None döndürebilir. Bu, farklı ödül fonksiyonlarının farklı örnek türlerine uygulandığı çoklu görev eğitiminde faydalıdır. Bir ödül fonksiyonu bir örnek için None döndürdüğünde, o ödül fonksiyonu o örneğin ödül hesabından hariç tutulur. Daha fazla ayrıntı için bkz. Özel bir ödül fonksiyonu kullanma.

        Eğiticinin durumu, ödül fonksiyonuna da iletilir. Eğiticinin durumu, TrainerState sınıfının bir örneğidir ve ödül fonksiyonunun imzasındaki trainer_state argümanına erişilerek kullanılabilir.

    • Ödül fonksiyonlarının bir listesi, her öğe bağımsız olarak yukarıdaki türlerden herhangi biri olabilir. Listede farklı türlerin karıştırılması (ör. bir dize model kimliği ve özel bir ödül fonksiyonu) izin verilir.

  • args (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 veya IterableDataset, isteğe bağlı) — Eğitimde kullanılacak veri seti. Şu sütunu içermelidir: "prompt". Veri setindeki ek sütunlar yok sayılır. Örneklerin biçimi şu şekillerden biri olabilir:
    • Standart: Her örnek düz metin içerir.
    • Sohbet: Her örnek yapılandırılmış mesajlar içerir (ör. rol ve içerik).

    environment_factory sağlandığında ve ortamın verileri kendisinin sahip olduğu (veya prosedürel olarak ürettiği) ve istemi reset() metodundan döndürdüğü durumlarda atlanabilir. Bu durumda, eğitim süresini tanımlamak için max_steps ayarlanmalıdır.

    train_dataset bir 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, max_steps eğitim argümanlarında ayarlanmalıdır.

  • eval_dataset (Dataset, IterableDataset, DatasetDict, 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, 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 ile modelin adından yüklenir. Bir dolgu belirteci, tokenizer.pad_token, ayarlanmış olmalıdır. İşleme sınıfı bir dolgu belirteci ayarlamadıysa, varsayılan olarak tokenizer.eos_token kullanılır.
  • reward_processing_classes (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ı reward_funcs. Şu seçeneklerden 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 ile eşleşen listenin bir öğesi None ise, modelin belirteçleyicisi (tokenizer) otomatik olarak from_pretrained kullanılarak yüklenir. reward_funcs içindeki özel ödül fonksiyonları (yani PreTrainedModel olmayanlar) için reward_processing_classes içindeki karşılık gelen girdiler yok sayılır.
  • callbacks (liste TrainerCallback, isteğe bağlı) — Eğitim döngüsünü özelleştirmek için kullanılacak geri çağrılar listesi. Bunlar, burada.

    Varsayılan olarak kullanılan geri çağrılardan birini kaldırmak istiyorsanız, remove_callback metodunu kullanın.

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], isteğe bağlı, varsayılan (None, None)) — Kullanılacak optimizörü ve zamanlayıcıyı içeren bir demet. Modelinizde AdamW örneği ve args tarafından kontrol edilen get_linear_schedule_with_warmup tarafından verilen bir zamanlayıcı olarak varsayılan değerlere sahip olacaktır.
  • quantization_config (BitsAndBytesConfig, isteğe bağlı) — Model bir model tanımlayıcısından yüklenirken kullanılan nicelleştirme 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 aracın, uygun şekilde tip ipucu (type-hint) verilmiş argümanlara ve dönüş değerlerine sahip standart bir Python fonksiyonu ve amacını, argümanlarını ve dönüş değerini açıklayan bir Google tarzı docstring içermesi gerekir. Daha fazla ayrıntı için bkz: https://huggingface.co/docs/transformers/en/chat_extras#passing-tools. Model, fonksiyonun adını, tip ipuçlarını ve docstring'ini kullanarak nasıl çağrılacağını belirler. Modelin sohbet şablonunun (chat template) araç kullanımını desteklediğinden ve araç çağırma (tool calling) için ince ayar (fine-tune) 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 listesi ve trainer örneğini alır. "prompt_ids", "completion_ids" ve "logprobs" alanlarına sahip bir dict döndürmelidir ve isteğe bağlı olarak "logprob_token_ids" (şekli "logprobs" ile aynı) döndürebilir. Diğer 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 (bkz. trainer üzerindeki num_generations / num_generations_eval). 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 yukarıda açıklanan reset yöntemini de uygulamalıdır; bu yöntem, üretimler arasında durumu sıfırlamak için kullanılabilir. 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 ayrıca get_reward argüman almayan ve float: varsa, ödülün sahibi ortam olur ve get_reward tamamlanan her rollout için bir kez çağrılarak ortamın iç durumuna göre puanlanır. Bu, ortamın sınıf adı altında kaydedilen ve ağırlığı 1 olan ek bir ödül kaynağı olarak görev yapar ve reward_funcs, bu durumda isteğe bağlı hale gelir.

    Tek bir callable ile her örnek aynı ortamı kullanır ve her rollout için bir örnek oluşturulduğundan etkileşimleri izole kalır. Bir sözlük kullanıldığında, her örneğin ortamını adıyla seçen bir environment alanı taşıması gerekir ve yalnızca o ortamın araçları prompt’unda 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 makalesinde önerilmiştir.

Örnek:

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

eğit

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

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. Mevcutsa, eğitim burada yüklenen model/optimizör/zamanlayıcı 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ı) — Eğitim sırasında değerlendirme için tahminleri toplarken göz ardı edilmesi gereken, model çıktısındaki (bir sözlükse) anahtarların listesi.

Dönüş değeri

~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

< >

( output_dir: str | None = None_internal_call: bool = False )

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

Yalnızca ana süreçten kaydedecektir.

push_to_hub

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

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ı değer döndürmesi gerektiğini belirtir.
  • 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ı) — Commit'in alınacağı git revizyonu. Varsayılan olarak “main” dalının başıdır.
  • private (bool, isteğe bağlı) — Depo oluşturulurken özel yapılıp yapılmayacağı. Varsayılan olarak args.hub_private_repo değerini alır. Depo zaten mevcutsa hiçbir etkisi yoktur.
  • kwargs (dict[str, Any], isteğe bağlı) — ~Trainer.create_model_card ile birlikte iletilen ek anahtar kelime argümanları.

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

GRPOConfig

sınıf trl.GRPOConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool | None = Falselabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Falsecast_lm_head_to_fp32: bool = Falsenum_generations: int | None = 8num_generations_eval: int | None = Nonemax_completion_length: int | None = 512ds3_gather_for_generation: bool = Trueshuffle_dataset: bool | None = Truepad_to_multiple_of: int | str | None = 'auto'generation_batch_size: int | None = Nonesteps_per_generation: int | None = Nonetemperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonegeneration_kwargs: dict | str | None = Nonechat_template_kwargs: dict | str | None = Nonerepetition_penalty: float = 1.0cache_implementation: str | None = Noneuse_vllm: bool = Falsevllm_mode: str = 'colocate'vllm_model_impl: str = 'vllm'vllm_enable_sleep_mode: bool = Falsevllm_structured_outputs_regex: str | None = Nonevllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_server_timeout: float = 240.0vllm_group_port: int = 51216vllm_gpu_memory_utilization: float = 0.3vllm_max_model_length: int | None = Nonevllm_tensor_parallel_size: int = 1beta: float = 0.0num_iterations: int = 1epsilon: float = 0.2delta: float | None = Noneepsilon_high: float | None = Nonesapo_temperature_neg: float = 1.05sapo_temperature_pos: float = 1.0vespo_k_pos: float = 2.0vespo_lambda_pos: float = 3.0vespo_k_neg: float = 3.0vespo_lambda_neg: float = 2.0importance_sampling_level: str = 'token'reward_weights: list[float] | None = Nonemulti_objective_aggregation: str = 'sum_then_normalize'scale_rewards: str = 'group'loss_type: str = 'dapo'mask_truncated_completions: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512top_entropy_quantile: float = 1.0entropy_coef: float = 0.0use_adaptive_entropy: bool = Falseentropy_coef_min: float = 0.0entropy_coef_max: float = 1.0entropy_coef_delta: float = 0.005entropy_target: float = 0.2max_tool_calling_iterations: int | None = Nonevllm_importance_sampling_correction: bool = Truevllm_importance_sampling_mode: str = 'sequence_mask'vllm_importance_sampling_clip_max: float | None = 3.0vllm_importance_sampling_clip_min: float | None = Noneoff_policy_mask_threshold: float | None = Noneuse_bias_correction_kl: bool = Truelog_completions: bool = Falselog_multimodal: bool = Truenum_completions_to_print: int | None = Nonelog_unique_prompts: bool = Falselog_completions_hub_repo: str | None = Noneuse_transformers_continuous_batching: bool = Falsetransformers_continuous_batching_config: dict | str | None = Noneuse_transformers_paged: bool = Falsevllm_importance_sampling_cap: float | None = None )

Model ve referans modeli kontrol eden parametreler

  • model_init_kwargs (str veya dict[str, Any], isteğe bağlı) — model argümanı GRPOTrainer için bir dize olarak verildiğinde kullanılan from_pretrained için 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 ve from_pretrained işlevlerine aktarılır. Ödül modeli ve ödül tokenizer'ı yüklemelerine de uygulanır.
  • router_aux_loss_coef (float, isteğe bağlı) — 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ğı. 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) — Politika ve referans modellerinin dil modelleme başlığının float32'ye dönüştürülüp dönüştürülmeyeceği. ScaleRL 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ındaki tie_word_embeddings değeri 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 fonksiyonu kullanıyorsanız, bu değeri False olarak bırakmalısınız.
  • num_generations (int, isteğe bağlı, varsayılan olarak 8) — Her prompt için örneklenmesi gereken nesil sayısı. Etkili batch boyutu (num_processes * per_device_batch_size
    • gradient_accumulation_steps) bu değere tam olarak bölünmelidir.
  • num_generations_eval (int, isteğe bağlı) — 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) — Oluşturulan 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 modeli 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 üretime yol açmasıdır. 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ğı.
  • pad_to_multiple_of (int veya str, isteğe bağlı, varsayılan "auto") — Belirlenirse, prompt kimlikleri ve tamamlama kimlikleri bu değerin katına yastıklanır. "auto", Neuron (AWS Trainium) üzerinde 128'in katına yastıklar; bu platform her giriş şekli için bir kez derleme yapar ve başka yerlerde yastıklama uygulanmaz.

Ü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 birlikte kullanılamaz.
  • steps_per_generation (int, isteğe bağlı) — Her üretim için 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, isteğe bağlı, varsayılan 1.0) — Dikkate alınacak üst tokenların kümülatif olasılığını kontrol eden float. (0, 1] aralığında olmalıdır. Tüm tokenları dikkate almak için 1.0 olarak ayarlayın.
  • top_k (int, isteğe bağlı, varsayılan 0) — Top-k filtreleme için en yüksek olasılığa sahip tutulacak sözlük belirteçlerinin sayısı. 0 ise top-k filtreleme devre dışı bırakılır ve tüm belirteçler dikkate alınır.
  • min_p (float, isteğe bağlı) — En olası token'ın olasılığına göre ölçeklendirilen 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 (transformers kullanılıyorsa) veya SamplingParams (vLLM kullanılıyorsa) iletilmesi için ek anahtar kelime argümanları. Bu, suppress_tokens, num_beams gibi ayarları yapılandırarak üretim davranışını daha da özelleştirmek için kullanılabilir. Diğer üretim parametreleriyle (ör. min_p, top_p vb.) çakışan anahtarlar içeriyorsa, bunlar onları 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, isteğe bağlı, varsayılan 1.0) — İstemde ve şu ana kadar üretilen metinde görünüp görünmediklerine göre yeni token'ları cezalandıran bir ondalık sayı. 1.0'dan büyük değerler modelin yeni token'lar kullanmasını teşvik ederken, 1.0'dan küçük değerler 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 önbellek 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 paketinin yüklü olması gerekir.
  • vllm_mode (str, isteğe bağlı, varsayılan olarak "colocate") — kullanıldığında vLLM entegrasyonu için kullanılacak mod use_vllm olarak ayarlanırsa True. aşağıdakilerden biri olmalıdır: "server" veya "colocate".
    • "server": Eğitmen, ü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ır. "vllm": Model uygulaması için vllm kütüphanesini kullanır.
  • vllm_enable_sleep_mode (bool, isteğe bağlı, varsayılan False) — Optimizatör adımı sırasında ağırlıkları/önbelleği boşaltmak için vLLM uyku modunu etkinleştirir. GPU bellek kullanımını düşük tutar, ancak motorun uyanması ev sahibi–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` `"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"). Verildiğinde 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 host adresi. 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ırsa yok sayılır.
  • vllm_server_timeout (float, isteğe bağlı, varsayılan 240.0) — vLLM sunucusunun ayağa kalkması için beklenen toplam zaman aşımı süresi (saniye cinsinden). Sunucu zaman aşımı süresinin sonunda ayağa kalkmazsa 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 edilmiş 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 edin. Bu ayar yalnızca vllm_mode değeri "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 eklenerek en az bu 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 tensor paralel boyutunu kontrol eder. Bu ayar yalnızca vllm_mode değeri "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, LLM'lerde akıl yürütmeyi pekiştirmeli öğrenme yoluyla teşvik eder ve 0.001 değeri kullanılır.
  • num_iterations (int, isteğe bağlı, varsayılan 1) — Parti başına yineleme sayısı (algoritmada μ olarak gösterilir).
  • epsilon (float, optional, defaults to 0.2) — Epsilon value for clipping.
  • 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 tanıtılmıştır.
  • epsilon_high (float, isteğe bağlı) — Kesme işlemi için üst sınır epsilon değeri. Belirtilmezse, epsilon argümanında belirtilen alt sınır değeriyle aynı varsayılan değeri kullanır. DAPO makalesi 0.28 değerini önerir. loss_type='cispo' ile kullanıldığında, bu değer ScaleRL makalesinde 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 tanıtılmıştır.
  • sapo_temperature_pos (float, isteğe bağlı, varsayılan 1.0) — sapo kayıp fonksiyonunda kullanılan, pozitif avantaj puanlarına sahip jetonlar için sıcaklık. Bu parametre, Soft Adaptive Policy Optimization makalesinde 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 sürgüsüdü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 düşürüleceğini 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 azalma 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 düşürüleceğini 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ı korur (token başına bir ağırlık). "sequence" geçerli tokenler arasında log-olasılık oranlarını ortalayarak dizin başına tek bir oran üretir. GSPO makalesi, dizin düzeyinde örneklemenin genellikle daha kararlı bir eğitim ve dizin düzeyindeki ödüllerle daha iyi bir hizalama 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 şekilde ağırlıklandırılır.
  • multi_objective_aggregation (str, isteğe bağlı, varsayılan olarak "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 işlevinden ağırlıklı ödüller toplanır, ardından scale_rewards ile belirtilen ödül ölçekleme/normalizasyonu uygulanır (ayrıntılar için scale_rewards bölümüne bakın).
    • "normalize_then_sum": Önce her ödül fonksiyonu, nesiller boyunca (her grup içinde) normalize edilir/ölçeklenir, ardından normalize edilmiş ödüller belirtilen ağırlıklar kullanılarak toplanır. Toplanan ödül, avantajlar oluşturulurken parti düzeyinde normalize edilir. Bu, GDPO: Group reward-Decoupled Normalization Policy Optimization for Multi-reward RL Optimization makalesinde önerilen yaklaşımdır.
  • scale_rewards (str veya bool, isteğe bağlı, varsayılan olarak "group") — Ödül ölçeklendirme stratejisini belirtir. Desteklenen değerler şunlardır:
    • True veya "group" (varsayılan): ödül grup içi standart sapmaya göre ölçeklenir, böylece grup içi varyans birim olarak sağlanır.
    • "batch": ödül, PPO Lite makalesinde önerildiği gibi tüm batch üzerinden standart sapmaya göre ölçeklenir.
    • False veya "none": ölçekleme uygulanmaz. Dr. GRPO makalesi, 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 olarak "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 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 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. Normalizasyon yalnızca yerel batch üzerinde yapıldığından, etkin batch boyutu sabit olsa da 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) uygular. Kırpılmış ağırlıklar, avantajlar ve politika modelinin log olasılıkları ile çarpılır. Bireysel token kayıpları, küresel birikimli batch içindeki aktif token sayısına normalize edilerek toplanır. Bu yöntem MiniMax-M1 makalesinde tanıtılmıştır.
    • "sapo": Soft Adaptive Policy Optimization makalesinde tanıtıldığı üzere Soft Adaptive Policy Optimization kaybı. Sert kırpma yerine, faydalı öğrenme sinyallerini korurken off-policy güncellemelerini uyumlu bir şekilde azaltan, sıcaklık kontrollü ve pürüzsüz bir kapı kullanır.
    • "luspo": Length-Unbiased Sequence Policy Optimization kaybı. Her bir dizinin kaybını uzunluğuna göre ölçekleyen dizi düzeyinde bir kayıp. Bu, GSPO'nun bir değişikliğidir ve importance_sampling_level="sequence" gerektirir. LUSPO makalesinde tanıtılmıştır.
    • "vespo": Varyansiyonel Sıralama Seviyesinde Yumuşak Politika Optimizasyonu. Sert kırpma yerine, sıralama seviyesindeki önem ağırlıklarına doğrudan uygulanan pürüzsüz, asimetrik Gamma ağırlıklandırma fonksiyonu kullanır. VESPO makalesinde 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 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) — Referans modelin, ref_model_mixup_alpha parametresini kullanarak her ref_model_sync_steps adımda aktif modelle senkronize edilip edilmeyeceğini belirtir. Bu senkronizasyon TR-DPO makalesinden kaynaklanmaktadır.
  • ref_model_mixup_alpha (float, isteğe bağlı, varsayılan 0.6) — TR-DPO makalesindeki α parametresi, güncellemeler sırasında mevcut politika ile önceki referans politika arasındaki karışımı kontrol eder. Referans politika şu denkleme 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 makalesindeki τ 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 makalesindeki ρ parametresi. Politika kayıp teriminde, her dizi konumundaki olasılık dağılımının entropisine göre token'ların en üst-ρ çeyreğini 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 token'ları korur. Makale 0.2 değerini önerir. mask_truncated_completions=True ile kullanılırsa, yalnızca kırpılmamış tamamlamalardaki token'lar dikkate alınır.
  • entropy_coef (float, isteğe bağlı, varsayılan 0.0) — Kayıp fonksiyonundaki entropi düzenleme teriminin katsayısı. Pozitif bir değer, politikanın neredeyse deterministik çıktılara çökmesini engelleyerek 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 normalizasyonuna uydurmak için yeniden ölçeklenmez, bu nedenle entropy_coef her kayıp türü için aynı anlama gelir. use_adaptive_entropy=True olduğunda, bu değer başlangıç katsayısı olarak kullanılı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'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) — Uyarlanabilir entropi kontrolü kullanıldığında entropi katsayısının alt sınırı.
  • entropy_coef_max (float, isteğe bağlı, varsayılan 1.0) — Uyarlanabilir entropi kontrolü kullanılırken entropi katsayısı için üst sınır.
  • entropy_coef_delta (float, isteğe bağlı, varsayılan 0.005) — Uyarlanabilir 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) — Uyarlanabilir 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şitinde 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 değeri eğitimde erken gözlemlediğiniz entropiye ( entropy metriği olarak kaydedilir) yakın ayarlayın (top_entropy_quantile kullanırken token alt kümesini de 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 üretmesi, tamamlamanın (tüm turlar ve araç sonuçları) max_completion_length belirteç sayısına ulaşması veya tam dizinin modelin maksimum uzunluğuna (vllm_mode="colocate" için vllm_max_model_length, aksi halde modelin max_position_embeddings değeri) 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 Importance Sampling (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 (ve vLLM 0.30'dan itibaren --enable-scale-out) ile başlatılmış bir sunucu gereklidir; aksi takdirde IS oranları yanlı olur. vLLM bu aday kümesini top_k ile sınırlar, bu nedenle onu dilbilgisinin izin verdiği tokenlarla sınırlayan 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 olarak "sequence_mask") — vllm_importance_sampling_correction=True olduğunda Importance Sampling'in nasıl gerçekleştirileceğini belirtir. vllm_importance_sampling_correction=True. Olası değerler şunlardır:
    • "token_truncate": Token düzeyinde kırpılmış IS. Token başına oranlar [C_min, C_max] aralığına kırpılır.
    • "token_mask": Token düzeyinde maskeli IS. [C_min, C_max] aralığının dışındaki token oranları sıfıra ayarlanır.
    • "sequence_truncate": Dizi düzeyinde kırpılmış IS. Tek bir dizi oranı [C_min, C_max] aralığına kırpılır ve dizideki tüm jetonlara uygulanır.
    • "sequence_mask": Dizi düzeyinde maskeli 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 değerinin altındaki oranlar sıfıra ayarlanır. C_min değerinin altındaki 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 maskeleme eşiği. None ise off-policy dizgi maskeleme 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 makalesindeki Denklem 9'daki delta eşiğine karşılık gelir. Pozitif bir değer bekler (ör. 0.5).
  • use_bias_correction_kl (bool, isteğe bağlı, varsayılan True) — KL teriminin, DeepSeek-V3.2 makalesinde açıklandığı gibi, KL gradyanının yanlı olmayan ters-KL gradyanı olmasını sağlamak için önem örneklemesi oranıyla çarpılıp çarpılmayacağını belirtir. Bu, beta != 0 olan her durumda, 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. Yanlı olmayan 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 üzerine yayılır.

Kayıt tutmayı 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, örneği yazdırır. wandb ve/veya trackio günlüğü etkinleştirildiyse, wandb ve/veya trackio üzerinden kaydeder.
  • log_multimodal (bool, isteğe bağlı, varsayılan True) — Tamamlamalarla birlikte çok modlu içeriklerin (görseller, videolar vb.) günlüğe kaydedilip kaydedilmeyeceğini belirtir. 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, oturum açılmış 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 depo herkese açıktır.

transformers sürekli toplu işleme (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ğı. 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 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 belgelerine başvurun. Bu sınıftaki varsayılan değerlerin TrainingArguments içindeki değerlerden farklı olabileceğini unutmayın.

HfArgumentParser kullanarak bu sınıfı, komut satırında belirtilebilen argparse argümanlarına dönüştürebiliriz.

Bu parametrenin TrainingArguments'ten farklı varsayılan değerleri vardır:

  • logging_steps: Varsayılan olarak 500 yerine 10 değerine ayarlanır.
  • gradient_checkpointing: Varsayılan olarak False yerine True değerini alır.
  • bf16: fp16 ayarlanmadıysa varsayılan olarak True, False yerine.
  • learning_rate: Varsayılan olarak 5e-5 yerine 1e-6 olarak ayarlanır.
Update on GitHub