TRL documentation

Asenkron GRPO Eğiticisi

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Asenkron GRPO Eğiticisi

model badge

Genel Bakış

AsyncGRPOTrainer, GRPO algoritmasını uygular ancak rollout üretimini eğitimden ayırır. Arka planda çalışan bir işçi, vLLM sunucusundan tamamlamaları sürekli olarak akış halinde gönderirken eğitim döngüsü bunları tüketir; böylece üretim ve gradyan güncellemeleri sırayla değil, üst üste gerçekleşir.

Bu eğitimci Amine Dirhoussi ve Quentin Gallouédec tarafından katkı sağlanmıştır.

Hızlı başlangıç

Bu örnek, Asynchronous GRPO yöntemiyle bir modelin nasıl eğitileceğini göstermektedir. DeepMath-103K veri setindeki istemlerle bir Qwen3.5 2B modeli eğitilir. Veri setindeki verilere buradan erişebilirsiniz:

Aşağıda modeli eğitmek için kullanılan betik yer almaktadır. Trainer, vLLM ve kernels gerektirir; accuracy_reward ise math-verify gerektirir. Bunları pip install trl[vllm,kernels,math_verify] komutuyla kurabilirsiniz.

# train_async_grpo.py
from datasets import load_dataset
from trl import AsyncGRPOTrainer
from trl.rewards import accuracy_reward

if __name__ == "__main__":  # the rollout worker is a spawned process that re-imports this script
    dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

    trainer = AsyncGRPOTrainer(
        model="Qwen/Qwen3.5-2B",
        reward_funcs=accuracy_reward,
        train_dataset=dataset,
    )
    trainer.train()

Generation çalışması, eğitimciden farklı GPU'larda, bir vLLM sunucusunda gerçekleştirilir. Bunu GPU 0 üzerinde başlatın:

CUDA_VISIBLE_DEVICES=0 VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen3.5-2B \
    --weight-transfer-config '{"backend": "nccl"}' \
    --logprobs-mode processed_logprobs \
    --api-server-count 8 \
    --max-model-len 4096

Ardından betiği GPU 1 üzerinde aşağıdaki komutu kullanarak çalıştırın:

CUDA_VISIBLE_DEVICES=1 python train_async_grpo.py

Uyumluluk ve kısıtlamalar

Mevcut AsyncGRPOTrainer uygulamasında bazı argüman kombinasyonları bilinçli olarak kısıtlanmıştır:

  • Generation her zaman vllm serve komutuyla başlatılan ayrı bir vLLM sunucusunda çalışır. Colocate modu yoktur.
  • Veri setindeki istemler sohbet biçiminde olmalıdır. environment_factory kullanıldığında veri setinde prompt sütunu olmayabilir ve reset() bunu sağlar.
  • Ödül işlevleri Python çağrılabilirleri olmalıdır. Model kimliği veya PreTrainedModel olarak verilen ödül modelleri desteklenmez, bkz. Özel bir ödül işlevi kullanma.
  • Eğitmen transformers>=5.2.0 gerektirir.
  • Sharded eğitim FSDP2 kullanır. DeepSpeed desteklenmez; bağlam ve dizi paralelliği de (parallelism_config içinde cp_size > 1 veya sp_size > 1) desteklenmez.
  • use_liger_kernel=True desteklenmiyor.
  • lm_head hedefli PEFT adaptörleri desteklenmez.
  • Dikkat çukuru (attention sink) içeren modeller desteklenmez. Desteklenen tek dikkat dışı katman, hibrit modellerin (Qwen3.5, Qwen3.6, Qwen3-Next, …) kapılı DeltaNet katmanlarıdır ve bunlar için transformers>=5.15.0 gereklidir.
  • Görseller desteklenmez, bkz. Görsel Dil Modellerinin Eğitimi.

Eğitim, dikkat çekirdeğini kernels kütüphanesi aracılığıyla Hub'dan yükler: AMD GPU'lar (ROCm) için kernels-community/aiter-flash-attn, NVIDIA Blackwell GPU'lar için kernels-community/flash-attn4 ve diğer NVIDIA GPU'lar için kernels-community/flash-attn3. Dikkat logaritma değerlerini sınırlayan (attn_logit_softcapping) modeller, örneğin Gemma 2, AMD GPU'larda veya NVIDIA Blackwell GPU'larında desteklenmez.

Asynchronous GRPO yönteminin derinlemesine incelenmesi

GRPOTrainer içinde üretim ve eğitim ardışık olarak gerçekleşir: bir parti üretilir, kayıp hesaplanır, ağırlıklar güncellenir ve bu işlem tekrarlanır. colocate modu kullanılsa bile bir faz, diğerinin başlamadan önce tamamlanmalıdır. AsyncGRPOTrainer’da ise bir rollout işçisi, arka plandaki bir süreçte tamamlamaları üretir ve puanlarken eğitim döngüsü kaybı hesaplar ve modeli günceller. Çalışma şeklini anlamak için üç ana adıma ayrılabilir: Tamamlamaları üretme, avantajı hesaplama ve kaybı hesaplama. Referans model olmadığından KL dağılım farkı terimi yoktur (GRPO’nun varsayılanı, beta=0.0).

Tamamlamalar oluşturma

Rollout işçisi, vLLM sunucusuna aynı anda en fazla max_concurrent_rollouts istek gönderir. Her istem için G G tamamlama grubu oluşturur (num_generations) ve grup tamamlandığında puanlar ve avantajlarını hesaplar. Oluşan eğitim örnekleri, eğitim döngüsünün çektiği bir kuyruğa eklenir. Üretim yalnızca eğitimden max_staleness adım önde olduğunda bekler (bkz. Eşzamanlılık), ) ve bir eğitim adımı yalnızca kuyruk boş olduğunda bekler.

Her weight_sync_steps eğitim adımında, trainer güncellenmiş ağırlıklarını NCCL üzerinden vLLM sunucusuna gönderir; böylece bir sonraki tamamlamalar en güncel politikadan gelir. Bu nedenle bir tamamlama, eğitilen politikadan birkaç adım eski bir politikadan gelebilir: trainer bir örneği çektiğinde, max_staleness ağırlık güncellemesinden fazla geride kalan örnekler elenir.

Metrikler ve bu sayfanın geri kalanı, bir tamamlamanın geçtiği aşamalar için aşağıdaki terimleri kullanır:

  • a grubu bir istem ve onun G G rollout'larıdır. Avantaj, bu grup içinde hesaplanır.
  • a rollout, bir istem için üretilen ve tüm araç çağrılarını içeren tek bir tam konuşmadır. Bir veya daha fazla turndan oluşur; her biri bir vLLM isteğidir.
  • a sample, kaybın hesaplandığı şeydir: bir rollout'un avantajı ile birlikte token'ları. Çok turlu bir rollout, birden fazla örnek üretebilir (bkz. Multi-turn rollouts).
  • a row, bir sürecin bir mikro-batch'te ileriye gönderdiği şeydir: birlikte paketlenmiş birkaç örnek (bkz. Tree packing). Bir micro-batch, süreç başına bir satır tutar ve gradient_accumulation_steps mikro-batch bir step, yani optimizör adımını oluşturur.

Token sayıları üç türde gelir: üretilen tokenlar modelin ürettiği tokenlardır, iletilen tokenlar bir örneğin tüm tokenlarıdır (istem ve araç sonuçları dahil) ve eğitilen tokenlar, kaybın (loss) hesaplandığı tokenlardır.

Avantajın hesaplanması

Bir grubun her bir G G tamamlaması için ödül, her bir ödül fonksiyonundan gelen ödüllerin toplamıdır. Avantaj, GRPO'da olduğu gibi grup içinde 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})}

scale_rewards seçeneği yoktur: avantaj her zaman grubun standart sapmasıyla ölçeklenir. Ödül fonksiyonlarının tamamının None döndürdüğü bir tamamlama, grubun ortalaması ve standart sapmasından hariç tutulur ve sıfır avantaj alır.

Tüm ödülleri eşit olan bir grup elenir: varsayılan avantaj her yerde sıfır olduğundan, bu grup üzerinde eğitim yapmak bir ileri ve geri geçiş maliyeti gerektirir ve hiçbir şeyi değiştirmez. Bu tür grupların oranı frac_zero_std_groups olarak kaydedilir. Adım, elenen gruplardan doldurulduğundan, elenen grup sayısı ne kadar çok olursa adım başına o kadar çok üretim yapılır. Elenen bir grup yine de epoch'a dahil edilir; epoch, istemler üzerinde tek bir geçiş olarak kalır.

Kaybın hesaplanması

vLLM sunucusunun log-olasılıkları eğitimcinin (trainer) log-olasılıklarıyla asla tam olarak eşleşmez: farklı çekirdekler (kernels), farklı bir hassasiyet ve birkaç adım geride kalmış bir politika (bkz. Eğitim-Çıkarım Uyuşmazlığıyla Başa Çıkma). Eğitimci, örnekleyicinin (sampler) log-olasılıklarını eski politika olarak kullandığından, tek bir önem oranı (importance ratio) hem uyuşmazlığı hem de güncelliği (staleness) kapsar: ri,t(θ)=πθ(oi,t∣q,oi,<t)πsampler(oi,t∣q,oi,<t). r_{i,t}(\theta) = \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\text{sampler}}(o_{i,t} \mid q, o_{i,< t})}.

Oranı [vllm_importance_sampling_clip_min, vllm_importance_sampling_clip_max] aralığının dışında kalan tokenlar kayıptan (loss) düşürülür. Daha fazla bilgi için Masked Importance Sampling başlığını inceleyin.

Varsayılan olarak (score_centering=True), eğitmen Skor Merkezileme'yi kullanır. Önem ağırlıkları tek başına uyumsuzluğu gidermez: örneklenen bir token'ın ∇θlog⁡πθ \nabla_\theta \log \pi_\theta değeri, örnekleyici altında sıfıra ortalama olarak eşitlenmez μ \mu , bu nedenle her güncelleme, politikayı örnekleyiciye doğru da çeker. Skor merkezileme, bu beklentiyi her konumda çıkarır: ∇θL=−Eo∼μ[A^(f(rt)∇θlog⁡πθ(ot)−Ev∼μ[f(rv)∇θlog⁡πθ(v)])],rv=πθ(v)μ(v), \nabla_\theta \mathcal{L} = - \mathbb{E}_{o \sim \mu} \left[ \hat{A} \left( f(r_t) \nabla_\theta \log \pi_\theta(o_t) - \mathbb{E}_{v \sim \mu} \left[ f(r_v) \nabla_\theta \log \pi_\theta(v) \right] \right) \right], \quad r_v = \frac{\pi_\theta(v)}{\mu(v)},

burada f(r)=r f(r) = r içinde [Cmin⁡,Cmax⁡] [C_{\min}, C_{\max}] ve 0 0 dışında. İç beklenti, rollout işçisinin sunucudan her konum için istediği num_sampler_logprobs en olası jetonlar üzerinde alınır.

ile score_centering=False, eğitmen, aynı maskeli oranla GRPO'nun kırpılmış vekil hedefini kullanır: L(θ)=−1∑i∣oi∣∑i∑t=1∣oi∣1[Cmin⁡≤ri,t(θ)≤Cmax⁡]min⁡(ri,t(θ)A^i,t, clip(ri,t(θ),1−ϵlow,1+ϵhigh)A^i,t), \mathcal{L}(\theta) = - \frac{1}{\sum_{i} |o_i|} \sum_{i} \sum_{t=1}^{|o_i|} \mathbb{1}\left[ C_{\min} \le r_{i,t}(\theta) \le C_{\max} \right] \min \left( r_{i,t}(\theta) \hat{A}_{i,t}, \, \text{clip}\left( r_{i,t}(\theta), 1 - \epsilon_{\text{low}}, 1 + \epsilon_{\text{high}} \right) \hat{A}_{i,t} \right),

burada ϵlow \epsilon_{\text{low}} şudur epsilon ve ϵhigh \epsilon_{\text{high}} şudur epsilon_high.

Her iki durumda da kayıp, tüm süreçler üzerinden sayılan mikro-toplumdaki eğitimli jeton sayısına normalize edilir ve bir adımın gradient_accumulation_steps mikro-toplumu üzerinde ortalaması alınır.

Kaydedilen metrikler

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

  • num_tokens: Şu ana kadar yönlendirilen toplam token sayısı, istemler ve tamamlamalar dahil. Ağaç paketleme (tree packing) kullanıldığında, birden fazla örnek tarafından paylaşılan bir önek yalnızca bir kez sayılır.
  • 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: Son turu bir EOS token'ı ile bitmeyen, kırpılmış (clipped) tamamlamaların oranı.
  • completions/duplicate_frac: Grup içindeki bir rollout'un, önceki bir rollout'unu token token düzeyinde tekrarlayan rolloutların oranı. Doygunluk ve kopyalar bölümüne bakın.
  • tools/call_frequency: Her rollout üzerinden, daha sonra atılan gruplar dahil olmak üzere, tamamlama başına ortalama araç çağrısı sayısı. Yalnızca eğitimcinin araçları varsa kaydedilir.
  • tools/failure_frequency: Araç çağrılarının başarısız olan (araç bulunamadı veya bir istisna fırlatıldı) oranı, daha sonra düşürülen gruplar dahil olmak üzere tüm araç çağrıları üzerinden hesaplanır. Araç çağrısı olmayan bir kayıt penceresinde NaN değerini alır; bu durumda GRPO 0.0 kaydeder. Yalnızca eğitimcinin araçları varsa kaydedilir.
  • rewards/{reward_func_name}/mean: Belirli bir ödül fonksiyonundan, puanladığı tüm tamamlamalar üzerinden (sonradan atılan gruplar dahil) elde edilen 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}/group_std: Belirli bir ödül fonksiyonundan gelen ödülün standart sapması, her grup içinde hesaplanır ve eğitim örnekleri üzerinde ortalaması alınır.
  • reward: Gruplar üzerinden fonksiyonlar arası ödüllerin toplanarak her puanlanan tamamlama üzerinden hesaplanan genel ortalama ödül, ardından düşürülen grupları da içerir. Bu, politikanın ödülüdür, bu nedenle izlenmesi gereken budur: reward_trained, ödüllerinin tamamı eşit olan grupları hariç tutar.
  • reward_group_std: Gruplar içinde hesaplanıp eğitim örnekleri üzerinde ortalaması alınan, fonksiyonlar arası toplanmış ödül standart sapması. Avantajın bölündüğü değerdir; GRPO’daki reward_std ise tüm batch üzerinden alınır.
  • reward_trained: Eğiticinin eğitim yaptığı örneklerin ortalama ödülü. Ödülleri tamamen eşit olan grupları ve max_staleness sınırını aşan için düşürülen örnekleri hariç tutar.
  • reward_zero_std_groups: Ödülleri birbirine eşit olan ve bu nedenle elenen grupların ortalama ödülü: takıldıkları ödül değeri. frac_zero_std_groups ve reward ile birlikte okumak için Doygunluk ve kopyalar bölümüne bakın.
  • frac_zero_std_groups: Ödül standart sapması sıfır olan (tüm yanıtlar doğru veya yanlış olan) veya iki'den az puanlanabilir tamamlama içeren grupların oranı. Bu gruplar elenir.
  • 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 ortalama mutlak fark, eğitim görmüş jetonlar üzerinden.
  • sampling/sampling_logp_difference/max: En büyük mutlak fark.
  • sampling/importance_sampling_ratio/min: En küçük önem örneklemesi oranı ri,t(θ) r_{i,t}(\theta) model ile örnekleyici arasında, eğitim görmüş jetonlar üzerinde, dışındaki jetonlar atılmadan önce [vllm_importance_sampling_clip_min, vllm_importance_sampling_clip_max] düşürülür.
  • sampling/importance_sampling_ratio/mean: Bu önem örneklemesi oranının ortalaması.
  • sampling/importance_sampling_ratio/max: En büyük önem örneklemesi oranı.
  • sampling/masked_mean: Önem örneklemesi oranları [vllm_importance_sampling_clip_min, vllm_importance_sampling_clip_max] aralığının dışında kaldığı için kayıptan çıkarılan eğitimli tokenların oranı.
  • sampling/sampler_mass: Örnekleme cihazının num_sampler_logprobs en olası jetonlarının kapsadığı ortalama olasılık kütlesi. Yalnızca score_centering=True olduğunda kaydedilir.
  • entropy: Eğitilen tokenler arasında token tahminlerinin ortalama entropisi.
  • 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.
  • clip_ratio/region_mean: GRPO hedefinin güven bölgesi içinde kalacak şekilde kırpıldığı token olasılıklarının oranı: clip(ri,t(θ),1−ϵlow,1+ϵhigh) \text{clip}\left( r_{i,t}(\theta), 1 - \epsilon_\mathrm{low}, 1 + \epsilon_\mathrm{high} \right) . ile score_centering=True kayıp kırpma yapmaz, bu nedenle clip_ratio/* metrikleri güven bölgesi dışındaki tokenları sayar.
  • clip_ratio/low_mean: Güven bölgesinin alt sınırında kırpılan token olasılıklarının ortalama oranı: ri,t(θ)<1−ϵlowr_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}.
  • clip_ratio/low_min: Güven bölgesinin alt sınırında kırpılan token başına tamamlama oranının en küçük değeri: 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 olasılıklarının ortalama oranı: ri,t(θ)>1+ϵhighr_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}.
  • clip_ratio/high_max: Güven bölgesinin üst sınırında kırpılan token'ların tamamlama başına en büyük oranı: ri,t(θ)>1+ϵhighr_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}.

Diğer metrikler asenkron hattı açıklar.

Metrikler, kayıt penceresi başına bir kez kaydedilir: önceki kayıttan bu yana kaydedilen her şey, son logging_steps optimizör adımını kapsar. Pencere boyunca:

  • reward, rollout/turns_mean ve tools/latency_s gibi her rollout, örnek veya çağrı başına ölçülen bir ortalama, penceredeki tüm rollouts, örnekler veya çağrılar üzerinde ortalanır. rollout/generated_tokens_per_s gibi bir oran ise toplam token sayısının toplam saniyeye bölünmesiyle elde edilir.
  • Aksi halde, son kısmında count kelimesi içeren bir ad toplanır: sample/dropped_stale_count, eğitim başlangıcından değil, son logdan bu yana atılan örneklerin sayısıdır.
  • Son kısmında max veya min kelimesi içeren bir ad, örneğin sample/staleness_max veya completions/max_length, en büyük veya en küçük değeri korur.
  • Diğer tüm metrikler, pencerede kaydedilen değerlerin ortalamasıdır.

Birimler:

  • _s: saniye.
  • tokens_per_s: saniyede token sayısı.
  • _frac: 0 ile 1 arasındaki oran.
  • _per_step: bir optimizasyon adımındaki miktar, penceredeki adımlar üzerinde ortalama alınmıştır.

Rollout metrikleri

  • rollout/duration_s: Bir rollout'un duvar saati süresi, dağıtım (dispatch) anından rollout döngüsünün onu topladığı ana kadar.
  • rollout/generated_tokens_per_s: Önceki rapordan bu yana, saniye başına üretilen token sayısı cinsinden üretim verimliliği.
  • rollout/concurrency: vLLM sunucusuna gönderilen eşzamanlı rollout sayısı.
  • rollout/concurrency_cap: Uçuştaki rollout'lar için geçerli olan, sunucunun yüküne göre değişen üst sınır. Eşzamanlılık bölümüne bakın.
  • rollout/turns_mean, rollout/turns_max: Her rollout başına ortalama ve maksimum tur sayısı.
  • rollout/samples_per_rollout: Her rollout başına eğitim örnek sayısı. 1.0'ın üzerinde bazı rollouts dallandırıldı; 1.0'ın altında bazıları eğitimli token üretmedi. Çok turlu rollouts bölümüne bakın.
  • rollout/fork_frac: Tutulan tokenlerle başlamayan prompt'a sahip tur geçişlerinin oranı; bu, turun yeni bir örnek başlattığı anlamına gelir.
  • rollout/drift_tokens_mean, rollout/drift_tokens_max: Bir fork'un yeniden render ettiği tutulan token sayısı, tur geçişleri üzerinde ortalama alınmıştır (fork oluşturmayanlar 0 olarak sayılır). Yeni örnek, ayrışmadan önceki tokenları paylaştığı için bu, her fork'un ileri yöne eklediği değerdir.
  • rollout/score_queue_size: Puanlanmayı bekleyen tamamlanmış grupların sayısı.
  • rollout/queue_size: Rollout kuyruğunda puanlanan ve trainer'ın onları çektiği noktada ölçülen örnek sayısı. Rollout kuyruğu bölümüne bakın.
  • rollout/score_s: Bir grubu puanlamanın süresi.
  • rollout/score_wait_s: Tamamlanan bir grubun puanlanmadan önce beklediği süre.
  • rollout/score_block_s: Skorlama kuyruğu dolu olduğu için üretim engellendi.
  • rollout/backpressure_s: Üretim, eğitimden max_staleness adım önde olduğu için bir rollout başlatmaya başlamadan önce bekleme süresi, kayıt penceresindeki bekleme sürelerinin ortalaması alınarak hesaplanır. Eşzamanlılık bölümüne bakın.
  • rollout/vllm_retry_count: Yeniden denenen vLLM isteklerinin sayısı. Aksi takdirde bozulmuş bir sunucu, açıklanamayan yavaşlık gibi görünür.
  • rollout/vllm_kv_cache_usage_frac: vLLM KV önbellek kullanımı (motorlar üzerindeki maksimum), kayıt penceresindeki anketler üzerinde ortalama alınmıştır.
  • rollout/vllm_running_requests: Sunucunun motorlarının çözümlediği istek sayısı (motorlar üzerinden toplanan vLLM'in num_requests_running değeri). rollout/concurrency ile arasındaki fark, yanıtları oluşturan API sunucu sürecinde bekleyen isteklerdir.
  • rollout/vllm_queued_requests: Sunucunun kabul ettiği ancak henüz zamanlaması yapılmamış isteklerin sayısı (motorlar üzerinden toplanan vLLM'in num_requests_waiting değeri).
  • rollout/vllm_preemption_count: Sunucunun önemsizleştirdiği (preempt) istek sayısı (vLLM'in num_preemptions_total değeri, motorlar üzerinden toplanmış hali). Bir ağırlık senkronizasyonu sunucunun önbelleklerini sıfırlar ve bu da çalışan tüm istekleri önemsizleştirir; bu nedenle bu metrik bir baskı sinyali değildir.

Araç metrikleri

  • tools/latency_s, tools/{tool_name}/latency_s: Tüm araçlar ve araç başına bir araç çağrısını çalıştırmak için harcanan süre.
  • tools/{tool_name}/call_count, tools/{tool_name}/failure_count: Araç başına çağrı sayısı ve başarısız çağrı sayısı.
  • tools/unknown_name_count: Var olmayan bir araca yapılan çağrı sayısı. Çalışıp hata fırlatan bir araçtan farklı olarak bu bir politika hatasıdır.
  • tools/parallel_calls_mean: Araç çağıran bir asistan mesajındaki ortalama araç çağrısı sayısı.
  • tools/loop_exhausted_frac: Araç çağrılarını hâlâ yaparken max_tool_calling_iterations sınırında kesilen rolloutların, çağrı içermeyen rolloutlar ve ardından düşürülen gruplar dahil olmak üzere tüm rolloutlar üzerinden oranı. Yalnızca trainer araçlara sahipse kaydedilir.

HarnessAsyncGRPOTrainer, bu parametrelerin çoğunu aynı adlarla kaydeder. Farklar için harness'lerde eğitim bölümüne bakın.

Ortam metrikleri

  • env/reset_s: Bir rollout başlamadan önce ortamın reset() işlevinde geçirilen süre. Yalnızca environment_factory sağlandığında kaydedilir.
  • env/reward_s: Bir rollout bittikten sonra ortamın get_reward() işlevinde geçirilen süre. Yalnızca ortam get_reward işlevini tanımlıyorsa kaydedilir.

Örnek metrikler

  • sample/forwarded_tokens_mean, sample/forwarded_tokens_max: Örnek başına iletilen token sayısının ortalaması ve maksimumu.
  • sample/trained_tokens_mean: Örnek başına ortalama eğitim token sayısı.
  • sample/time_in_queue_s: Bir örneğin eğitimde kullanılmadan önce rollout kuyruğunda beklediği süre.
  • sample/staleness_mean, sample/staleness_max: Bir örneği üreten politika ile bu örnek üzerinde eğitim yapan politika arasındaki ağırlık güncelleme sayısı. sampling/importance_sampling_ratio/* ve sampling/sampling_logp_difference/* metrikleri, bu eskimeyi eğitim-çıkarsama uyumsuzluğuyla birleştirir: sıfır eskime durumunda 1.0'dan sapma veya 0.0'dan sapma gösteren log-olasılık farkı, örneğin sunucuyla bir dtype farkı gibi, bu uyumsuzluğa işaret eder.
  • sample/dropped_stale_count: max_staleness değerini aşan örneklerin sayısı.

Toplu metrikler

  • batch/forwarded_tokens_per_step, batch/trained_tokens_per_step: Tüm süreçler üzerinden adım başına yönlendirilen ve eğitilen token sayısı.
  • batch/samples_per_step, batch/groups_per_step: Adım başına örnek ve farklı grup sayısı. Grup başına örnek sayısınca farklılık gösterirler.
  • batch/microbatches_per_step: Adım başına mikro-toplu (micro-batch) sayısı.
  • batch/masked_token_frac: Eğitilmeyen yönlendirilen tokenların oranı.
  • batch/samples_per_row, batch/row_tokens_mean, batch/row_tokens_max: Satır başına örnek sayısı ve satır başına iletilen tokenların ortalama ve maksimum sayısı.
  • batch/row_fill_frac: Satırların token_budget değerinin ne kadarını kullandığını gösteren oran.
  • batch/row_imbalance: En pahalı satırın dikkat maliyetinin ortalama maliyete oranı. En pahalı satıra sahip işlem, diğerlerini gradyan all-reduce sırasında bekletir; 1.0 mükemmel dengeyi temsil eder.
  • batch/packing_ratio: İleri yönlendirilen her token başına paketleme öncesi token sayısı: paketlemenin ileri yönlendirmeyi küçültme çarpanı, hiçbir şey paylaşılmadığında 1.0.
  • batch/pad_frac: Satırların aynı uzunlukta olmasını sağlamak için eklenen dolgu oranı. Sadece aktarım maliyeti vardır, ileri geçişten önce kaldırılır.
  • batch/dropped_oversize_count: token_budget aşımı nedeniyle atılan örnek sayısı.

Performans metrikleri

  • perf/step_s: Optimizer, ağırlık senkronizasyonu ve örnekler için bekleme süresini içeren bir adımın duvar saati süresi.
  • perf/fwd_bwd_s, perf/fwd_s: Bir adımın ileri ve geri geçişlerinde ve yalnızca ileri geçişlerinde harcanan süre.
  • perf/optimizer_s: Optimizer adımında harcanan süre.
  • perf/rollout_wait_s: Eğitim, rollout kuyruğu boş olduğu için beklediği süre. Rollout kuyruğu bölümüne bakın.
  • perf/weight_sync_s: Bir ağırlık senkronizasyonunun süresi; perf/weight_sync_pause_s (vLLM'in duraklamasını bekleme), perf/weight_sync_barrier_s (diğer süreçleri bekleme) ve perf/weight_sync_transfer_s (ağırlıkları gönderme) olarak bölünmüştür.
  • perf/fwd_bwd_forwarded_tokens_per_s, perf/wall_clock_forwarded_tokens_per_s: İleri ve geri geçişler boyunca veya tüm adım boyunca saniyede iletilen token sayısı.
  • perf/wall_clock_trained_tokens_per_s: Tüm adım boyunca saniyede eğitilen token sayısı.
  • perf/fwd_bwd_mfu, perf/wall_clock_mfu: Eğitim cihazlarının model FLOPs kullanım oranı, ileri ve geri geçişler boyunca veya tüm adım boyunca. Bunlar vLLM sunucusunu hariç tutar. Yalnızca eğitim cihazının eğitim hassasiyetindeki tepe hesaplama gücü bilindiğinde ve FLOPs tahmini modelin mimarisini (Llama, Qwen2, Qwen3, Qwen3-MoE veya Qwen3-VL gibi) desteklediğinde kaydedilir.

Özelleştirme

vLLM sunucusunu yapılandırma

Trainer, vllm_server_base_url adresinden (http://localhost:8000 varsayılan olarak) eriştiği bir vLLM sunucusuyla içerik üretir:

VLLM_SERVER_DEV_MODE=1 vllm serve <model_name> \
    --weight-transfer-config '{"backend": "nccl"}' \
    --logprobs-mode processed_logprobs \
    --api-server-count 8 \
    --max-model-len 4096
  • VLLM_SERVER_DEV_MODE=1 ve --weight-transfer-config, eğitimcinin ağırlıklarını gönderdiği uç noktaları açığa çıkarır.
  • --logprobs-mode processed_logprobs sunucusun, sıcaklık ve top-k/top-p uygulandıktan sonra örneklemesinin alındığı dağılımın log-olasılıklarını döndürmesini sağlar; önem oranı (importance ratio) bununla karşılaştırılır.
  • --api-server-count 8, puan merkezleme isteklerinin düşük maliyetle sunulmasını sağlayan en yüksek log-olasılıkları korur (aşağıdaki uyarıya bakın).
  • --max-model-len, beklediğiniz maksimum toplam dizi uzunluğudur (istek ve tamamlama). Daha düşük bir değer, sunucudaki GPU bellek kullanımını azaltarak KV önbelleği için daha fazla bellek boşaltır ve verimliliği artırır. İyi bir başlangıç noktası, yapılandırmanızdaki istek uzunluğuna max_completion_length değerinin eklenmesidir. Araçlar kullanıldığında, her tur en fazla max_completion_length token ve araç sonuçları ekler; bu nedenle bu değeri, beklediğiniz en uzun konuşmaya göre ayarlayın. Bir turun isteği ile max_completion_length toplamı --max-model-len değerinden uzunsa, sunucu isteği reddeder ve çalışma sunucunun hatasıyla durur. top_k veya top_p kullanıldığında, sunucu bunun yerine --max-model-len değerine ulaştığında o turu durdurur ve yalnızca zaten bu kadar uzun olan bir isteği reddeder. Bu değer aynı zamanda varsayılan token_budget değeridir.

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.

En yüksek log-olasılıkların (log-probabilities) seri hale getirilmesi, vLLM API sunucusunda CPU işidir ve varsayılan tek API sunucusuyla num_sampler_logprobs=8 değeri, üretim (generation) verimliliğini yarıya indirir. vLLM 0.32 veya üzeri sürümlerde sunucuyu --api-server-count 8 bayrağıyla başlatın: tek bir H100 üzerinde 1,5B ile 7B parametreli modellerde ölçüldüğünde, en yüksek 8 log-olasılık bu durumda üretim verimliliğinin %3'ünden azına mal oluyor. vLLM 0.31'de aynı bayrak hâlâ %20 ile %40 arasında bir kayba yol açıyor; bu sorun vllm-project/vllm#58181 ile yamalandı.

Eşzamanlılık

Üç sınır, aynı anda kaç rollout çalıştırılacağını belirler. İlk ikisi kendi kendine uyarlanır; üçüncüsünü siz ayarlayabilirsiniz.

Eski veri (Staleness). max_staleness, üretimin eğitimden (trainer) en fazla kaç eğitim adımı önde olabileceğini belirler. İşçi (worker), bir adımdaki örnek sayısının tamamlamaların (completions) uzaması veya kısalmasıyla değiştiği için bu sınırı token cinsinden takip eder. Her adımın ardından trainer, kullandığı token sayısını sayar ve işçinin kuyrukta veya işlemde en fazla max(max_staleness, 1) katı kadar token tutmasına izin verir. İlk adım öncesinde, her satırın dolu olduğu varsayılır. İşçi, yalnızca bu sınırın altında kaldığı sürece yeni bir rollout grubu başlatır. En başta bir rollout'un kaç token üreteceğini henüz bilmediği için, ilk grup tamamlanana kadar gruptan gruba geçerek ilerler. Sonuçta hâlâ max_staleness adımdan eski olan bir örnek atılır.

vLLM yükü. vLLM'ye aynı anda çok fazla istek göndermek onu yavaşlatır: KV önbelleği dolar ve vLLM bazı istekleri duraklatıp yeniden işlemek zorunda kalır. Bu nedenle işçi, aynı anda kaç rollout'un çalıştığını sınırlayan canlı bir üst sınır da tutar ve bu değer rollout/concurrency_cap olarak kaydedilir; ayrıca sınırı ayarlamak için sunucunun /metrics uç noktasını her 5 saniyede bir kontrol eder. Sınır, tam uzunlukta KV önbelleğine sığan istek sayısıyla başlar (KV cache tokens / max_model_len), böylece başlangıçta sunucu aşırı yüklenmez. KV önbelleği kullanımı %60'ın altında kaldığı ve bekleyen istek olmadığı sürece sınır, tamamlanan rollout sayısı kadar bir üst sınır değerine kadar en fazla %25 oranında artırılır. Kullanım %80'in üzerine çıktığında sınır %30 oranında azaltılır: çalışan istekler devam eder, yeni istekler ise bekler. Sunucunun /metrics uç noktası yoksa sınır max_concurrent_rollouts değerine eşittir.

Kaynaklar. max_concurrent_rollouts (varsayılan olarak 512) aynı anda çalışan rollout'ların üst sınırını belirtir. Bu, sizin kendiniz belirlediğiniz tek sınırdır; çünkü eğitimci, ortamlarınızın ve araçlarınızın neyi kaldırabileceğini göremez. Her çalışan rollout bir ortam kullanır, bu boyuttaki bir iş parçacığı havuzunda senkron araç çağrıları çalıştırabilir ve vLLM sunucusuna açık bir bağlantı tutar. Bunu, örneğin ortam sunucunuzun kabul ettiği oturum sayısı gibi, bu bileşenlerin kaldırabileceği değere ayarlayın:

from trl import AsyncGRPOConfig

training_args = AsyncGRPOConfig(
    ...,
    max_concurrent_rollouts=64,
)

Çok düşükse, üretim yavaşlar. Bir rollout, vLLM üretirken değil, araçları çalıştırırken veya turlar arasında beklerken de slotunu korur; bu nedenle birçok araç çağıran rollouts, vLLM’i meşgul tutmak için daha fazla slota ihtiyaç duyar. Varsayılan değerden çok yüksekse, vLLM sunucusu bağlantıları düşürmeye başlayabilir.

Kaydedilen metrikler, üretimi hangi sınırın kısıtladığını gösterir:

  • rollout/backpressure_s'in sıfırın üzerinde olması: bayatlık sınırı. Üretim, eğitimden önde gidiyor; bu, çıkarım eğitimin daha hızlı olduğunda beklenen bir durumdur.
  • rollout/concurrency, rollout/concurrency_cap altında ve max_concurrent_rollouts değerinin altında: vLLM sunucusunun yükü.
  • rollout/concurrency değeri max_concurrent_rollouts sınırına ulaşmış, rollout/vllm_kv_cache_usage_frac düşük ve perf/rollout_wait_s yüksek: tavan. Ortamlarınız ve araçlarınız izin veriyorsa max_concurrent_rollouts değerini artırın.

Rollout kuyruğu

Worker, puanlanmış örnekleri bir kuyruğa iter ve trainer ondan alır. Bu kuyruğu dört metrik tanımlar:

  • rollout/queue_size: bekleyen örnek sayısı.
  • sample/time_in_queue_s: tek bir örneğin eğitimde kullanılmadan önce ne kadar süre beklediğini, yani eskiliğinin zaman bileşenini belirtir.
  • perf/rollout_wait_s: kuyruk boş olduğu için eğitimin ne kadar süre beklediği.
  • rollout/backpressure_s: üretim, eğitimden max_staleness adım önde olduğu için ne kadar süre bekledi.

Son iki, birbirinin aynasıdır. Kuyruk boyutuyla birlikte okunduklarında, darboğazın hangi tarafta olduğunu gösterirler:

  • Kuyruk neredeyse boş, perf/rollout_wait_s yüksek: üretim kısıtlı. Eğitmen aç kalıyor; rollout/generated_tokens_per_s, rollout/concurrency ve rollout/score_queue_size değerlerine bakın.
  • yaklaşık max_staleness adımın tokenlarını tutan kuyruk, rollout/backpressure_s yüksek: trainer-bound. Üretim geri tutulur ve sample/staleness_mean sınırına yakın değerlerde seyreder.
  • her ikisi de yüksek: max_staleness sınırı kendisi çok dar. Uçuştaki rollouts, örnekleri kuyruğa ulaşmadan önce bu sınırı doldurur; bu da trainer'ın, üretim geri tutulurken beklemesine neden olur. max_staleness değerini artırın.
  • her ikisi de neredeyse sıfır: dengeli.

Doygunluk ve kopyalar

Politika, bir grubun rollout'ları arasındaki farklardan öğrenir: her avantaj, grubun ortalama ödülüne karşı alınır. Bir grubun tüm rollout'ları aynı ödülü aldığında, hepsi sıfır avantaj alır ve grup atılır (bkz. Kayıt altına alınan metrikler), politika hiçbir şey öğrenmez. Bir çalıştırma doygunluğa ulaştıkça, giderek daha fazla grup bu duruma gelir; ya her rollout prompt'u çözer ya da hiçbiri çözmez. Bu durumları ayırt eden dört metrik vardır ve her biri kendi sorusunu yanıtlar, böylece grafiklerinden doğrudan okuyabilirsiniz:

metrikquestion
frac_zero_std_groupsgrupların ne kadarı sinyal taşımıyor
reward_zero_std_groupso grupların nerede takıldığını gösterir: ortalama ödülleri. 0/1 ödüllerde, her rollout'un geçtiği paydır; dolayısıyla 0.9, neredeyse hepsinin çözüldüğü, 0.1 ise neredeyse hepsinin her rollout'ta başarısız olduğu anlamına gelir
rewardher puanlanan grup üzerinde politikanın ne kadar iyi performans gösterdiği, atılanlar dahil
completions/duplicate_fracaynı istem için örneklemenin hâlâ farklı dağıtımlar üretilip üretilmediği

Ödül aralığınıza karşı ilk üçünü birlikte okuyun:

frac_zero_std_groupsreward_zero_std_groupsrewardteşhisne yapılmalı
düşükherhangi (birkaç grup üzerinde gürültülü)herhangisağlıklı: grupların çoğu bir gradyan üretirhiçbir şey
tırmanmaaralığın üst kısmına yakıntırmanmaüstte doygunluğa ulaşmak: istemler politika için çok kolay hale gelmiştir, başarılı bir çalışmanın genellikle bu şekilde sona ermesiçalışmayı durdurun veya daha zor istemlere geçin
yüksekaralığın alt kısmına yakındüşük ve düzaltta takılı kalma: istemler çok zor veya ödül fonksiyonu asla kredi vermiyorÖnce completions/clipped_ratio değerini kontrol edin, çünkü cevabından önce kesilen bir tamamlama 0 puan alır; ardından ödül işlevinin tamamlamaları doğru ayrıştırdığından emin olmak için birkaç tamamlamayı okuyun.
tırmanmadüşendüşenregression: daha önce geçen gruplar artık birlikte başarısız oluyorçökme olup olmadığını kontrol etmek için completions/duplicate_frac ve entropy değerlerine bakın
yüksekortadaherhangikarışık: 0/1 ödülleriyle bazı istemler çok kolay, bazıları çok zor olabilir. Kısmi kredi ödülleriyle gruplar aynı kısmi puanda da takılabilir.rollout'ları oku

completions/duplicate_frac, bir grubun tüm turları boyunca, önceki bir rollout'unu token token düzeyinde tekrar eden rollout'ların payını ifade eder. Aynı rollout'lar aynı ödülleri alır, bu nedenle kopyalar frac_zero_std_groups değerini de yukarı çeker.

completions/duplicate_fracteşhis
0'a yakın, tamamlamaları yeterince kısa olup tesadüfen tekrarlanabilecek görevlerde küçük bir tabansağlıklı: bir grubun rollout'ları bağımsız olarak örneklenir
(num_generations - 1) / num_generations değerine doğru sıçrarörnekleme artık rastgele değildir: her grup, bir rollout'un kopyaları olarak geri döner. Örneğin, 0 sıcaklık veya aynı metni çözen veri-paralel vLLM motorları (çalışan, bunu önlemek için her istekle benzersiz bir tohum gönderir)
yavaşça yükselir, entropy düşercollapse: politika, her istem için tek bir cevaba yakınsıyor

Bu metrikler, örnekler üzerinde eğitim yapıldığında değil, işçi bir grubu puanladığında kaydedilir; bu nedenle eğitimden biraz önde çalışırlar ve max_staleness değerini aşan örnekleri nedeniyle daha sonra elenen grupları da içerirler. Her ödül fonksiyonu None döndürdüğü için hiçbir rollout’un puanlanamadığı bir grup elenir ve frac_zero_std_groups içinde sayılır; ancak ödülü olmadığından reward_zero_std_groups bu grubu hariç tutar.

Ağaç paketleme

Bir mikro-toplumdaki örnekler, dolgu olmadan, işlem başına bir satır olarak paketlenir. Bir satır bir prefix trie'dır, bir birleştirme değildir: birden fazla örnek tarafından paylaşılan bir token bir kez ileriye aktarılır ve dikkat mekanizması her örneğe yalnızca kendi geçmişini gösterir. Bir grubun tüm rollout'ları onun prompt'unu tekrarlar ve çok turlu bir rollout'un her turu o ana kadarki konuşmayı tekrarlar, bu nedenle ileri geçiş, paketleme oranı kadar (batch/packing_ratio) küçülür. Bu yalnızca bir yerleşim değişikliğidir: her eğitilen token kendi hedefini, avantajını ve eski log-olasılığını korur ve log-olasılığı, örneğin tek başına ileriye aktarılmasıyla eşleşir.

Bir istemin iki yuvarlanmasında, p istem, a ve b ise iki tamamlama olsun:

1. Rollouts         r0:  p1 p2 p3 a1 a2                10 tokens
                    r1:  p1 p2 p3 b1 b2

2. Trie             S0 [p1 p2] ─┬─ S1 [p3 a1 a2]       p3 is not shared: a position predicts
                                └─ S2 [p3 b1 b2]       one token, and p3 predicts a1 or b1

3. Packed row       index         0  1 |  2  3  4 |  5  6  7
   (depth-first)    input_ids    p1 p2 | p3 a1 a2 | p3 b1 b2    8 tokens: everything but attention
                    position_ids  0  1 |  2  3  4 |  2  3  4    runs on 8 instead of 10
                    segment      S0    | S1       | S2

4. Attention        segment   queries    keys and values: the segment's path in the trie
   (one call)       S0        p1 p2      p1 p2              index 0 1
                    S1        p3 a1 a2   p1 p2 p3 a1 a2     index 0 1 2 3 4
                    S2        p3 b1 b2   p1 p2 p3 b1 b2     index 0 1 5 6 7

5. Loss             r0: a1 a2 predicted at index 2 3   each trained token is predicted at the index
                    r1: b1 b2 predicted at index 5 6   of the token before it in its rollout

Birkaç sonuç:

  • Ortak bir önek paylaşıldığında: bir istemin (prompt) rollout'ları ve istemler arasında ortak bir sistem istemi veya araç şeması. Bir örnek, grubunun zaten bulunduğu ve isteminin zaten mevcut olduğu satıra gider. O satır dolu olduğunda, bir sürecin hâlâ boş bir satırı varsa veya en yüklü satırı (mikro-toplu işlemenin süresini belirleyen) artırmıyorsa örnek başka bir satıra gider; aksi halde mikro-toplu işleme kapanır.
  • Paylaşılan hiçbir şey düz paketleme değildir: her örnek kendi segmenti olur, bu da sıradan dolgu olmadan paketlemedir.
  • Sadece K/V kopyalanır: paylaşılan önek, her torun segmenti için bir kez toplanır; bu, paketlenmemiş eğitimin tuttuğu miktara yakındır ve gruplu sorgu dikkatiyle küçük kalır.
  • Gated DeltaNet hibritleri desteklenir (Qwen3.5, Qwen3.6, Qwen3-Next, …): konvolüsyonları her token'ın kendi öncüllerini okur ve parçalı delta kuralı her segmenti ebeveyninin son durumundan başlatır.

token_budget, bir satırdaki token sayısını sınırlar ve paylaşılan bir tokenı yalnızca bir kez sayar. Varsayılan olarak sunucunun max_model_len değeridir, bu nedenle hiçbir örnek bu sınırı aşamaz. Paylaşılan hiçbir şey yokken, ağaç paketleme, düz padding-free paketleme hızına yakın bir hızda çalışır ve hızlanma, paketleme oranıyla yaklaşık olarak artar (Qwen3-0.6B ve 1.7B modellerinde, H100 üzerinde 3.4 oranında yaklaşık 2.8 ile 3x arasında). Oran, paylaşılan önek ile satır başına örnek sayısının çarpımıdır, bu yüzden batch/samples_per_row birincil göstergedir: 1’e yakınsa hiçbir şey paylaşılamaz ve ayarlanabilir parametre token_budget olur. batch/row_fill_frac, örnekler uzun olduğunda önemlidir: 10k token’lık bir örnek, 32k bütçeyi kötü bir şekilde doldurur (üçü sığar, dördü asla sığmaz, bu nedenle planlayıcı genellikle ikisini alır ve satır yaklaşık %77 dolu çalışır), oysa 1k token’lık örnekler bütçeyi neredeyse mükemmel şekilde doldurur.

Ağaç paketlemeyi (tree packing) batch/trained_tokens_per_step / perf/fwd_bwd_s üzerinden değerlendirin. Paketlenmiş bir mikro-toplu (micro-batch) daha fazla örnek barındırdığından perf/fwd_bwd_s artar ve ileri yönlendirilen token sayısına bölünen perf/fwd_bwd_mfu düşer: bunların hiçbiri bir gerileme (regression) değildir. Satır başına daha fazla örnek, adım başına daha fazla rollout çekildiği anlamına da gelir; bu nedenle üretim kısıtlı (generation-bound) bir çalışma daha da belirgin hale gelir.

Toplu metrikler şu şekilde bir araya gelir: bir adım gradient_accumulation_steps × num_processes satır içerdiğinden, batch/samples_per_step yaklaşık olarak batch/samples_per_row değerinin bu kadar katı kadardır; tokenlar için de durum aynıdır. İki taraf yalnızca bir adımın mikro toplamları arasındaki değişkenliğe kadar uyuşur, çünkü adım başına metrikler toplamlar, satır başına olanlar ise ortalamalardır.

Satırları uzatan veya azaltan her şey paylaşımı kaldırır. Asla dallanmayan çok turlu bir sohbet, tek bir uzun örnektir ve rollout/samples_per_rollout, bir sohbetin kaç örnek ürettiğini belirtir.

Top-k ve top-p örneklemesi

Top-k ve top-p, örneklem dağılımını tüm sözlük yerine kısıtlı bir aday kümesi üzerinde yeniden normalize eder. Sunucunun log-olasılıkları bunu yansıtır (--logprobs-mode processed_logprobs), bu nedenle eğitimcinin de aynı küme üzerinde normalize etmesi gerekir; aksi halde tüm önem oranları yanlı olur: bir token’ın tüm sözlük altındaki olasılığı, örneklem alındığı aday kümesi altındaki olasılıktan daha düşüktür (DeepSeek-V3.2, bölüm 3.1). top_p < 1 veya top_k > 0 durumunda, işçi her örneklenen token için aday kümesini sunucudan ister ve eğitimci log-olasılıkları bu küme üzerinde yeniden normalize eder. Bunun için iki ek sunucu bayrağı gerekir ve vLLM aday kümesinin boyutunu bununla sınırladığı için top_k ayarlanmalıdır:

VLLM_SERVER_DEV_MODE=1 vllm serve <model_name> \
    --weight-transfer-config '{"backend": "nccl"}' \
    --logprobs-mode processed_logprobs \
    --api-server-count 8 \
    --max-model-len 4096 \
    --return-sampling-mask \
    --enable-scale-out
from trl import AsyncGRPOConfig

training_args = AsyncGRPOConfig(
    ...,
    top_p=0.95,
    top_k=512,
)

--return-sampling-mask, vLLM'nin aday kümesini (vLLM 0.28 veya üzeri, V2 model runner'ında: sunucu bayrağı reddediyorsa VLLM_USE_V2_MODEL_RUNNER=1) kaydetmesini sağlar ve --enable-scale-out, bu kümeyi döndüren token-in-token-out uç noktasını açığa çıkarır. İşçi, başlarken sunucuda her iki ayarı da kontrol eder. Eski bir vLLM bu kümeyi döndüremediğinden, eğitimci tüm sözlük üzerinde normalleştirmeye devam eder ve yanlı orana dair bir uyarı verir.

PEFT ile adaptörler eğitin

🤗 PEFT kütüphanesiyle sıkı entegrasyon destekliyoruz; böylece tüm modeli eğitmek yerine adaptörleri eğitebilir ve Hub üzerinde paylaşabilirsiniz.

from datasets import load_dataset
from peft import LoraConfig
from trl import AsyncGRPOTrainer
from trl.rewards import accuracy_reward

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

    trainer = AsyncGRPOTrainer(
        model="Qwen/Qwen3.5-2B",
        reward_funcs=accuracy_reward,
        train_dataset=dataset,
        peft_config=LoraConfig(r=32, lora_alpha=64, target_modules="all-linear"),
    )
    trainer.train()

Her ağırlık senkronizasyonunda güncellenmiş politika sunucuya iletilmelidir. Varsayılan olarak eğitimci, adaptörü temel modele birleştirir ve tam birleşik ağırlıkları gönderir; bu, 7B'lik bir model için her senkronizasyonda yaklaşık 15 GB'dır. vLLM sunucusunu --enable-lora ile başlatırsanız, bunun yerine yalnızca adaptör gönderilir; r=32 için yaklaşık 160 MB'dır:

VLLM_SERVER_DEV_MODE=1 VLLM_ALLOW_RUNTIME_LORA_UPDATING=1 vllm serve <model_name> \
    --weight-transfer-config '{"backend": "nccl"}' \
    --logprobs-mode processed_logprobs \
    --api-server-count 8 \
    --max-model-len 4096 \
    --enable-lora \
    --max-lora-rank 32 \
    --max-loras 6

VLLM_ALLOW_RUNTIME_LORA_UPDATING=1, eğitimcinin her yeni adaptörü gönderdiği uç noktayı açığa çıkarır. --enable-lora kullanılsa bile --weight-transfer-config parametresini koruyun: eğitimci yalnızca başlangıçta bir senkronizasyon modu seçer ve bu noktada sunucu zaten çalışır durumdadır; birleşik senkronizasyon ise yedek çözümdür.

--max-lora-rank, 1, 8, 16, 32, 64, 128, 256, 320, 512 değerlerinden biri olmalıdır. Sunucunun sunabileceği en yüksek rankı belirler, sunacağı rankı değil; bu nedenle r=4 adaptörü 8 altında sorunsuz çalışır. --max-loras, en az max_staleness + 2 olmalıdır: eğitimci, eski bir politika altında başlayan bir rollout'un ortada politika değiştirmek yerine o politika altında tamamlanabilmesi için max_staleness + 1 adaptör sürümünü kayıtlı tutar ve her senkronizasyonda en eski sürümü boşaltmadan önce bir sonraki sürümü yükler. Eğitimci, başlangıçta her iki değeri de kontrol eder ve sunucuyu hangi değerlerle yeniden başlatacağınızı belirtir.

vLLM, adaptörleri ağ üzerinden değil diskten yüklediği için eğitimci, her sürümü <output_dir>/.vllm_lora/ altında yazar ve sunucuya yolu verir. Sunucu farklı bir makinede çalışıyorsa, bu dizinin her ikisinin de görebildiği bir dosya sisteminde bulunması gerekir.

<output_dir>/.vllm_lora/ bir sunum önbelleğidir, eğittiğiniz adaptörün saklandığı yer değildir. Yalnızca en son sürümleri barındırır ve her biri, güncellik penceresinden düştükten kısa süre sonra silinir. Adaptörünüzü koruyan şey checkpoint'lerdir, bu nedenle onları kapatmayın: save_strategy="no" ile saatler süren bir çalıştırma biter ve arkasında hiçbir şey bırakmaz. output_dir'ın sunucu tarafından okunabilir olması ve işin ömründen uzun süre var olması gerekir; bu nedenle, yavaş bir paylaşımlı dosya sisteminden senkronizasyonları uzak tutsa bile düğüm yerel geçici alanı işe yaramaz.

Adapter senkronizasyonu her zaman daha hızlı değildir. vLLM, birleşik ağırlıklar yerine bir LoRA adapter'ı sunduğunda token başına yaklaşık 1,33 ile 1,39 kat daha yavaş üretim yapar ve RL'de duvar saati süresini genellikle üretim aşaması belirler. Buna karşılık, her senkronizasyonda çok daha kısa bir duraklama ve senkronizasyon bant genişliğinin yaklaşık %1'i elde edilir. Üretim verimliliği darboğazınızsa, birleşik senkronizasyon genellikle hâlâ daha iyi bir seçimdir.

Özel bir ödül fonksiyonu kullanma

AsyncGRPOTrainer, özel ödül fonksiyonlarının kullanılmasını destekler. Uyumluluğu sağlamak için ödül fonksiyonunuzun 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 ödül işlevi sağladığınızda, bunlar eşzamanlı olarak çalışır: asenkron olanlar birlikte beklenir, senkron olanlar ise iş parçacıklarında çalışı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),
      • 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 sohbet biçimindedir, bu nedenle prompts ve completions mesaj sözlüklerinin listeleridir.

  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.

Ödül fonksiyonları, ayrı bir süreç olan rollout işçisinde çalıştığından, ona iletilen her şey pickled edilir. Her ödül fonksiyonu, araç ve environment_factory (ve bunların kapattığı her şey) picklenebilir olmalıdır: modül düzeyinde bir fonksiyon, functools.partial veya çağrılabilir sınıf örneği kullanın. Lambda'lar ve kapanışlar, trainer.train() sırasında TypeError fırlatır. Bu, ödül fonksiyonlarının süreç içi çağrıldığı ve kapanışların çalıştığı GRPOTrainer'dan bir farktır.

Rollout süreci de CUDA_VISIBLE_DEVICES="" ile çalıştığından GPU kullanamaz. GPU destekli bir ödül modeli (örneğin AutoModelForSequenceClassification puanlayıcısı) hata vermeden yüklenir ancak sessizce CPU'ya geri düşer. Ödül fonksiyonlarını hafif tutun (accuracy_reward gibi doğrulayıcılar, biçim veya uzunluk kontrolleri). GPU ödül modeline ihtiyacınız varsa, bunu ayrı GPU'larda kendi çıkarım motorunun (vLLM, TGI, …) arkasında barındırın ve picklenebilir bir ödül fonksiyonunun HTTP üzerinden ona çağrı yapmasını sağlayın.

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

Aşağıda, daha uzun tamamlamaları ödüllendiren bir ö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 = [[{"role": "user", "content": "The sky is"}], [{"role": "user", "content": "The sun is"}]]  # not used in the reward function, but the trainer will pass it
>>> completions = [[{"role": "assistant", "content": " blue."}], [{"role": "assistant", "content": " 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 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ınmıştır. Veri seti, ground_truth adlı bir sütun içerir.

import re

def reward_func(completions, ground_truth, **kwargs):
    # Regular expression to capture content inside \boxed{}
    matches = [re.search(r"\\boxed\{(.*?)\}", completion[0]["content"]) 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 = [
...     [{"role": "user", "content": "Solve the equation $2x + 3 = 7$."}],
...     [{"role": "user", "content": "Solve the equation $3x - 5 = 10$."}],
... ]
>>> completions = [
...     [{"role": "assistant", "content": r"The solution is \boxed{2}."}],
...     [{"role": "assistant", "content": 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, AsyncGRPOTrainer 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 AsyncGRPOTrainer

# Define a dataset that contains both math and coding problems
dataset = Dataset.from_list(
    [
        {"prompt": [{"role": "user", "content": "What is 2+2?"}], "task": "math"},
        {"prompt": [{"role": "user", "content": "Write a function that returns the sum of two numbers."}], "task": "code"},
        {"prompt": [{"role": "user", "content": "What is 3*4?"}], "task": "math"},
        {"prompt": [{"role": "user", "content": "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
if __name__ == "__main__":
    trainer = AsyncGRPOTrainer(
        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 bir 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 AsyncGRPOTrainer geçerli fonksiyonlar ve görevlerle devam eder. Bu, AsyncGRPOTrainer'ın farklı uygulama alanlarına sahip birden fazla ödül fonksiyonunu işleyebilmesini sağlar.

AsyncGRPOTrainer'ın, ödül fonksiyonları tarafından döndürülen None ödüllerini yoksaydığını ve yalnızca ilgili fonksiyonlar tarafından döndürülen ödüleri dikkate aldığı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ş I/O'ya (örneğin, uzak bir servise çağrı yapmaya) bağlıysa bu işe yarar. Birden fazla asenkron ödül fonksiyonu geçirdiğinizde AsyncGRPOTrainer bunları eşzamanlı olarak çalıştırır ve gecikmeleri üst üste bindirir.

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

import asyncio

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

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

Özel ödül fonksiyonunuzu kullanmak için, bunu AsyncGRPOTrainer sınıfına aşağıdaki gibi iletin:

from trl import AsyncGRPOTrainer

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

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

ve ödül, her bir fonksiyondan gelen ödüllerin toplamı olarak hesaplanacaktır.

Rollout döngüsünü özelleştirme

Üretim, ödül, avantaj ve filtreleme işlemleri AsyncRolloutLoop içindeki rollout sürecinde çalışır. Bunlardan birini değiştirmek için döngünün bir alt sınıfını oluşturup ilgili adımın metodunu geçersiz kılın ve bu alt sınıfı bir trainer alt sınıfında loop_cls olarak ayarlayın. Trainer’ın yapıcısı değişmez.

YöntemÇağrıldıVarsayılan
filter_prompt(row_index, row, epoch)her istem başına, üretimden önceher istemi kabul eder
generate_one(prompt, tools, group_id)her rollout başına bir kezçok turlu araç döngüsü
generate_one_turn(prompt_ids)örnekleme isteği başına bir kezyapılandırmanın örnek alma ayarlarıyla tek bir vLLM isteği
compute_advantages(group)her grup için bir kez, ödüller group.rewards içine toplanır toplanmazgrupta standartlaştırılmış ödül
setup(), close()döngülerin ne zaman başlayıp duracağıhiçbir şey

Örneğin, politikanın zaten çözdüğü istemleri örneklemeyi durduran bir müfredat, eşiği bir yapılandırma alt sınıfında tanımlanır:

from dataclasses import dataclass

import numpy as np

from trl import AsyncGRPOConfig, AsyncGRPOTrainer
from trl.trainer.async_grpo_trainer import AsyncRolloutLoop


@dataclass
class CurriculumConfig(AsyncGRPOConfig):
    pass_rate_cap: float = 0.9


class CurriculumRolloutLoop(AsyncRolloutLoop):
    def filter_prompt(self, row_index, row, epoch):
        return self.pass_rates.get(row_index, 0.0) < self.config.pass_rate_cap

    async def setup(self):
        self.pass_rates = {}

    def compute_advantages(self, group):
        scored = group.rewards[~np.isnan(group.rewards)]
        if len(scored):
            self.pass_rates[group.row_index] = float(np.mean(scored > 0))
        return super().compute_advantages(group)


class CurriculumTrainer(AsyncGRPOTrainer):
    loop_cls = CurriculumRolloutLoop

Ödüller, reward_funcs, get_reward tanımlayan ortamlar ve özel bir generate_one'in Rollout üzerinde ayarladığı reward üzerinden toplanır: bir yargıçla puanlamak için asenkron bir ödül fonksiyonu iletin veya puanlamayı generate_one içinde yapın. compute_advantages, puanlanan ödüllerinin tümü eşit olduğu için daha sonra atılan gruplar dahil olmak üzere her grup için çalışır; atma işlemi avantajlara değil, ödüllere bakar. Döngü ayrı bir süreçte oluşturulduğundan, alt sınıfı modül düzeyinde tanımlayın ve eğitim kodunu if __name__ == "__main__": altında tutun. İstemcileri, döngünün olay döngüsünde çalışan setup içinde oluşturun; bunun yerine __init__ geçersiz kılın. filter_prompt'in reddettiği bir istem, atılan bir grup gibi o epoch için atlanır ve epoch sayımına dahil edilir. Bir epoch'taki tüm istemleri reddederse döngü bir hata fırlatır.

Kontrol noktasından devam etme

Temel Trainer, üzerinde eğitim yaptığı partileri atlayıp yeniden oynatarak devam eder; bu durum canlı bir rollout kuyruğu için geçerli değildir, bu nedenle ignore_data_skip her zaman True olur. Bunun yerine, üzerinde henüz eğitim yapılmamış ilk istemin indeksi, her checkpoint ile birlikte rollout_state.json dosyasına kaydedilir ve devam sırasında geri yüklenir; böylece worker, örnekleri yeniden oynatmadan o isteme hızlıca ilerler. Bu, üreticinin değil trained konumudur: worker, rollout kuyruğu derinliği kadar eğitimin önünde çalışır ve bu tamponlanan örnekler çalışmanın sona ermesiyle kaybolur; dolayısıyla üreticinin konumundan devam etmek, oluşturulmuş ancak üzerinde eğitim yapılmamış istimleri atlayacaktır. Akış veri kümeleri (IterableDataset) yeniden konumlandırılamaz, bu nedenle worker’ları devam sırasında ilk istemden yeniden başlar.

Ajan Eğitimi

Asynchronous 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 AsyncGRPOTrainer

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

Model, bir aracı adıyla çağırır; bu nedenle her araç __name__ altında kaydedilir ve ayrıca picklable kalmasını sağlayarak rollout worker için uygun olan bir modül düzeyinde işlev olmalıdır. Senkron araçlar, max_concurrent_rollouts boyutunda bir iş parçacığı havuzunda çalışır; bu sayede yavaş bir araç, uçuştaki diğer rollout'ları asla engellemez. Tek bir asistan turu içinde, araç çağrıları modelin onları yaydığı sırada çalışır. Dolayısıyla en fazla max_concurrent_rollouts senkron araç aynı anda çalışabilir; bu nedenle paylaşılan durumu okuyan veya yazan bir aracın iş parçacığı güvenli (thread-safe) olması gerekir.

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.

AsyncGRPOConfig içinde max_tool_calling_iterations parametresini kullanarak araç çağrısı turlarının sayısını sınırlayabilirsiniz. Varsayılan olarak bir sınır yoktur ve model, araç çağrısı içermeyen bir yanıt turu ürettiğinde üretim durur.

Örnek:

from trl import AsyncGRPOTrainer

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 = AsyncGRPOTrainer(
    tools=[multiply, async_add],
    ...,
)

Ortamlar

Araçları environment_factory üzerinden de sağlayabilirsiniz. Bu modda AsyncGRPOTrainer, her rollout için bir ortam örneği oluşturur ve ortamın genel yöntemlerini araçlar olarak sunar.

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 AsyncGRPOConfig, AsyncGRPOTrainer

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

if __name__ == "__main__":
    trainer = AsyncGRPOTrainer(
        model="Qwen/Qwen3-0.6B",
        args=AsyncGRPOConfig(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. 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.

Her ikisi de işçinin araç iş parçacığı havuzunda çalıştığından, yavaş bir ortam yalnızca kendi dağıtımını geciktirir, uçuştaki diğerlerini değil. Süreleri env/reset_s ve env/reward_s olarak kaydedilir.

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

# 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

if __name__ == "__main__":
    trainer = AsyncGRPOTrainer(
        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 ağırlık 1 ile toplanır.

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

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

Ç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 AsyncGRPOConfig, AsyncGRPOTrainer


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
if __name__ == "__main__":
    dataset = Dataset.from_dict({"environment": ["coding", "game"] * 500})

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

Environment örnekleri adımlar arasında yeniden kullanılır (epizodlar arasında sıfırlanır), bu nedenle maliyetli __init__ her adımda değil, yalnızca bir kez ödenir. environment alanı trainer tarafından tüketilir ve reset fonksiyonuna iletilmez.

Çok turlu dağıtımlar

Her tur, tüm sohbeti sohbet şablonu üzerinden işleyerek (render) ve bu işlemeden üretim yapar. Bir sohbet şablonu, büyüyen bir sohbeti her zaman aynı şekilde işlemez (örneğin bazıları önceki turların akıl yürütmesini atar), bu nedenle bir turun istem (prompt) belirteçleri, o ana kadar tutulan belirteçlerden farklı olabilir. Rollout'un sonunda, işçi (worker) turları eğitim örnekleriyle uzlaştırır: istemi, tutulan belirteçlerle başlayan bir tur aynı örneğe eklenir, diğer tüm turlar ise yeni bir örnek başlatır. Her üretilen belirteç tam olarak bir örnekte eğitilir, bu nedenle bir dallanma (fork) ileri yönlü belirteç maliyeti taşır ancak eğitim sinyali kaybettirmez.

Bir rollout'un her örneği, o rollout'un avantajını alır. rollout/fork_frac ve rollout/drift_tokens_*, turların nasıl uzlaştırıldığını gösterir.

Ortam Entegrasyonları

Harbor kum havuzlarındaki kodlama ajanları gibi kendi çalışma ortamında (harness) çalışan ajanları eğitmek için OpenEnv kılavuzundaki harness üzerinde eğitim bölümüne bakın.

Görsel Dil Modellerinin Eğitimi

Görüntü-dil modelleri (Qwen3.5, Qwen3.6, Qwen3-VL, …) sadece metin veri setlerinde eğitilebilir. Model kimliğini normalde olduğu gibi iletin; başka hiçbir değişiklik gerekmez.

Görüntü kulesi dondurulmuştur. Sadece metin içeren bir veri seti asla görüntü jetonları üretmez, bu nedenle kule ileri geçiş tarafından asla kullanılmaz. Metin modelinin dışındaki her şey (görüntü kulesi, çok modlu projeksiyoncu) için requires_grad=False değerine sahiptir: gradyan ve optimizör durumu almaz, ağırlık senkronizasyonu onu atlar, bu da sunucunun checkpoint'ten yüklediği değerleri korumasını sağlar. Kule yine de yüklendiği için ağırlıkları için GPU belleği maliyeti oluşturur.

Görseller henüz desteklenmiyor. Görsel içeren istemler, vLLM sunucusuna veya eğitim ileri geçişine iletilmez. Çok modlu eğitim, görsel ızgarasından 3B M-RoPE konumlarını oluşturmak için dolgu olmadan paketleme yoluna da ihtiyaç duyar; bu yol burada uygulanmamıştır.

AsyncGRPOTrainer

sınıf trl.AsyncGRPOTrainer

< >

( model: str | PreTrainedModelreward_funcs: collections.abc.Callable[..., list[float]] | list[collections.abc.Callable[..., list[float]]] | None = Noneargs: trl.trainer.async_grpo_config.AsyncGRPOConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneprocessing_class: 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)peft_config: PeftConfig | None = Nonetools: list[collections.abc.Callable] | None = Noneenvironment_factory: collections.abc.Callable[[], trl.trainer.async_grpo_trainer._SupportsReset] | dict[str, collections.abc.Callable[[], trl.trainer.async_grpo_trainer._SupportsReset]] | None = None )

Parametreler

  • model (str veya PreTrainedModel) — Eğitilecek model. Şu seçeneklerden 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, yapılandırmasında beyan edilen mimariyle yüklenir: bir görme-dil kontrol noktası için (görme kulesi yüklenir ancak dondurulur, bkz. Görme-Dil Modellerinin Eğitimi) AutoModelForImageTextToText, aksi halde AutoModelForCausalLM.
    • Bir PreTrainedModel nesnesi. Paketli eğitim için dikkat uygulaması, eğitimcinin ağaç dikkat (tree attention) arka ucuna değiştirilir.

    Üretim için kullanılan vLLM sunucusunda modeli tanımlamak için config'teki model adı kullanılır.

  • 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 (prompts) ve tamamlamalar (completions) ile çağırır ve ödülleri toplar. Ödül, ortam tarafından sağlandığında ( environment_factory (aşağıya bakın) atlanabilir. Şu şekillerden biri olabilir:
    • Tek ö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. Ö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ığı çok görevli eğitim için 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 Özel bir ödül fonksiyonu kullanma bölümüne bakın.
    • Her öğesi yukarıda tanımlandığı gibi bir ödül fonksiyonu olan ödül fonksiyonları listesi. Tüm fonksiyonlardan gelen ödüller toplanır.

    GRPOTrainer'den farklı olarak, ödüller türetilmiş bir alt süreçte hesaplanır; bu nedenle her ödül fonksiyonu (birlikte tools ve environment_factory ile) picklable olmalıdır: modül düzeyinde bir fonksiyon, functools.partial veya çağrılabilir bir sınıf örneği kullanın — lambda'lar ve kapanışlar (closures) başlangıçta başarısız olur. Araçlar __name__ altında kaydedilir, bu nedenle modül düzeyinde fonksiyonlar olmalıdır. Alt süreç ayrıca CUDA_VISIBLE_DEVICES="" ile çalışır, bu nedenle GPU destekli bir ödül modeli, eğitimcinin GPU'su yerine CPU'da (yavaş) çalışır.

  • args (AsyncGRPOConfig, 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ğitim için kullanılacak veri seti. Şu sütunu içermelidir "prompt". Veri setindeki ek sütunlar yok sayılır. Örnekler sohbet biçiminde olmalıdır: her örnek yapılandırılmış mesajlar (ör. role ve content) içerir.

    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.

  • processing_class (PreTrainedTokenizerBase, 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ı modelin adıyla from_pretrained kullanılarak yüklenir. Bir dolgu belirteci, tokenizer.pad_token, ayarlanmalıdır. İşleme sınıfı bir dolgu belirteci ayarlamadıysa, varsayılan olarak tokenizer.eos_token kullanılır.
  • 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.
  • peft_config (PeftConfig, isteğe bağlı) — Modeli sarmak için kullanılan PEFT yapılandırması. None ise model sarılmaz. vLLM sunucusu --enable-lora ile başlatıldığında, bir LoRA adaptörü birleştirilmiş ağırlıklar olarak değil, bir adaptör olarak senkronize edilir; AsyncGRPO belgelerinin LoRA bölümüne bakın.
  • 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.
  • 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. Bu trainer, GRPO'nun asenkron sürümüdür; üretim, eğitimle birlikte asenkron olarak çalışan harici bir vLLM sunucusuna devredilir ve bu sayede rollout, gradyan güncelleme döngüsünden ayrıştırılır.

Örnek:

>>> from trl import AsyncGRPOTrainer
>>> from trl.rewards import accuracy_reward
>>> from datasets import load_dataset

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

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

Hangi istemlerin örneklenmesi, bir rollout'un nasıl oluşturulacağı veya avantajların nasıl hesaplanacağı özelleştirilecekse, AsyncRolloutLoop sınıfından türetin ve onu eğitimcinin loop_cls olarak ayarlayın. TRL döngüyü şu şekilde oluşturur

rollout süreci:

>>> class CurriculumTrainer(AsyncGRPOTrainer):
...     loop_cls = CurriculumRolloutLoop

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.

AsyncGRPOConfig

sınıf trl.AsyncGRPOConfig

< >

( 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: str = 'constant'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 = 1logging_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 = Truerestore_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 = 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 = Nonedtype: str = 'float32'trust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonenum_generations: int = 8max_completion_length: int = 2048temperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonechat_template_kwargs: dict | str | None = Nonemax_tool_calling_iterations: int | None = Nonevllm_server_base_url: str = 'http://localhost:8000'vllm_server_timeout: float = 1800.0epsilon: float = 0.2epsilon_high: float | None = Nonescore_centering: bool = Truevllm_importance_sampling_clip_min: float = 0.5vllm_importance_sampling_clip_max: float = 5.0num_sampler_logprobs: int = 8token_budget: int | None = Nonemax_concurrent_rollouts: int = 512max_staleness: int = 4weight_sync_steps: int = 1rollout_worker_timeout: float = 300.0log_completions: bool = Falsenum_completions_to_print: int | None = None )

Modeli kontrol eden parametreler

  • model_init_kwargs (dict[str, Any] veya str, isteğe bağlı) — Modelin bir yoldan örneklenirken from_pretrained için kullanılan anahtar kelime argümanları. revision değeri, işleme sınıfı yüklenirken de kullanılır.
  • dtype (str, optional, defaults to "float32") — Data type to load the model under, one of "auto", "bfloat16", "float16" or "float32". It defaults to "float32" because the training-inference mismatch this trainer is measured against (Defeating the Training-Inference Mismatch via FP16) is sensitive to the trainer’s own precision. Closing that gap end to end also requires serving the vLLM server in the same dtype (vllm serve --dtype); a mismatch is logged as a warning at train start. A dtype in model_init_kwargs takes precedence.

    Bu, yalnızca ağırlıkların yüklendiği dtype'yi belirler. FSDP ile karma hassasiyet kullanıldığında (bf16=True varsayılandır), accelerate, shard'lamadan önce her eğitilebilir parametreyi fp32'ye yükseltir; bu nedenle dtype ne derse desin, ana ağırlıklar ve optimizör durumu fp32'de kalırken, ileri ve geri yayılım bf16 veya fp16'da çalışır. Kontrol noktaları (checkpoint) daha sonra fp32'de değil, bu karma hassasiyet dtype'inde yazılır. FSDP olmadan hiçbir şey yükseltilmez: dtype="bfloat16" ile bf16=True, bf16 ağırlıkları ve optimizör durumlarını korur; bu da saf bf16 eğitimidir.

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

Üretimi kontrol eden parametreler

  • num_generations (int, isteğe bağlı, varsayılan 8) — Her istem için örneklenmesi gereken nesil sayısı.
  • max_completion_length (int, isteğe bağlı, varsayılan 2048) — Her vLLM isteği için, yani çok turlu bir rollout'ta her tur için üretilen maksimum token sayısı.
  • 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 tokenlerin kümülatif olasılığını kontrol eden bir sayı. (0, 1] aralığında olmalıdır. Tüm tokenleri dikkate almak için 1.0 olarak ayarlayın. 1.0'ın altında, top_k'nın da ayarlanması gerekir ve vLLM sunucusu (>= 0.28) --return-sampling-mask --enable-scale-out ile başlatılmalıdır: eğitimci, sunucunun yaptığı gibi, her tokenin örneklemesinin yapıldığı aday kümesi üzerinde log-olasılıklarını yeniden normalize eder. Daha eski bir vLLM, tüm sözlüğü korur.
  • 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 değerlendirilir. Diğer herhangi bir değer, top_p altında açıklanan sunucu bayraklarını gerektirir.
  • 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. 0.0'ın üzerinde, top_p altında açıklanan sunucu bayraklarıyla birlikte top_k de ayarlanmalıdır.
  • chat_template_kwargs (dict[str, Any], isteğe bağlı) — Tamamlamalar oluşturulurken apply_chat_template fonksiyonuna iletilecek ek anahtar kelime argümanları.
  • max_tool_calling_iterations (int, isteğe bağlı) — Bir ajan eğitilirken araç çağırma turlarının maksimum sayısı. None ise sınır yoktur ve model, araç çağrısı içermeyen bir yanıt turu ürettiğinde üretim durur.

vLLM sunucusunu kontrol eden parametreler

  • vllm_server_base_url (str, isteğe bağlı, varsayılan "http --//localhost:8000"): Üretim için kullanılan vLLM sunucusunun temel URL'si (ör. "http://localhost:8000").
  • vllm_server_timeout (float, isteğe bağlı, varsayılan 1800.0) — vLLM sunucusuna yapılan çağrılar için saniye cinsinden zaman aşımı: başlangıçta hazır olmasını bekleme, her üretim isteği ve her ağırlık eşitleme çağrısı. Sunucuyu ve ağırlık eşitleme çağrılarını bekleme sırasında süre dolarsa hata fırlatılır; zaman aşımına uğrayan bir üretim isteği yeniden denenir.

Eğitimi kontrol eden parametreler

  • epsilon (float, optional, defaults to 0.2) — Epsilon value for clipping.
  • 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ılır. DAPO makalesi 0.28 değerini önerir.
  • score_centering (bool, isteğe bağlı, varsayılan True) — Kesilmiş hedef yerine puan merkezleme (makale) ile eğitim yapılıp yapılmayacağı: her örneklenen token'ın önem ağırlıklı puanı, vLLM örnekleyicisi altındaki beklentisinden çıkarılır; böylece sabit bir avantaj, politikayı örnekleyiciye doğru çekmez. Beklenti, her konumda en olası num_sampler_logprobs token üzerinden alınır ve örnekleyici bu token'ların log-olasılıklarını raporlar.
  • vllm_importance_sampling_clip_min (float, isteğe bağlı, varsayılan 0.5) — Politika ile vLLM örnekleyicisi arasındaki önem oranının alt sınırı C_min. Oranı [vllm_importance_sampling_clip_min, vllm_importance_sampling_clip_max] aralığının dışında kalan tokenlar kayıptan (loss) düşürülür (maskeli önem örneklemesi).
  • vllm_importance_sampling_clip_max (float, isteğe bağlı, varsayılan 5.0) — Önem oranının üst sınırı C_max.
  • num_sampler_logprobs (int, isteğe bağlı, varsayılan 8) — Her üretilen token için vLLM örnekleyicisinden istenen en yüksek log-olasılık sayısı, skor merkezileştirmede kullanılır. Daha yüksek değerler, örnekleyicinin olasılık kütlesinin daha büyük bir kısmını kapsar ancak seri hale getirme maliyeti daha yüksektir; sunucunun --max-logprobs parametresi bu değeri sınırlar.
  • token_budget (int, isteğe bağlı) — Tek bir satırda (bir DP rank’ın forward’ında) iletilecek maksimum token sayısı. TokenBudgetBatcher, satırlarının her birinin bu bütçe içinde kalmasını sağlayarak, örnek sayısından bağımsız olarak tepe belleği sınırlayan, dikkat maliyetine dengeli mikro-partiler oluşturur (satır başına örnek sayısı dinamik hale gelir). Bütçe, ham tokenler yerine benzersiz tokenları sınırlar; bu nedenle birden fazla örnek tarafından paylaşılan tokenlar bir kez sayılır ve satırın kayıp terimlerini de sınırlar. None ise (varsayılan), eğitim başlangıcında sorgulanan vLLM sunucusunun max_model_len değerine ayarlanır — istem + tamamlama uzunluğu sınırı — böylece hiçbir rollout örneği bütçeyi aşamaz. token_budget değerinden uzun bir örnek hiçbir satıra sığmaz ve bir uyarıyla düşürülür.

Eşzamanlı olmayan rollout hattını kontrol eden parametreler

  • max_concurrent_rollouts (int, isteğe bağlı, varsayılan 512) — Aynı anda çalışan rolloutların maksimum sayısı. Her biri bir ortamı tutar, senkron araç çağrıları çalıştırabilir ve vLLM sunucusuna bir bağlantıyı açık tutar; bu nedenle bu değeri, söz konusu kaynakların kaldırabileceği seviyeye ayarlayın. Bu değerin altında, uçuştaki rollout sayısı vLLM sunucusunun KV-cache kullanımına ve max_staleness değerine göre belirlenir.
  • max_staleness (int, isteğe bağlı, varsayılan 4) — Bir rollout örneğinin, atılmadan önce mevcut model sürümünün ardında kalabileceği maksimum ağırlık güncelleme adımı sayısı. Üretim buna göre tutulur: kuyrukta ve uçuşta olan jetonlar, eğitimcinin max(max_staleness, 1) adımda tükettiği miktara sığarken yeni bir rollout grubu başlar.
  • weight_sync_steps (int, isteğe bağlı, varsayılan 1) — vLLM sunucusuna ağırlık senkronizasyonları arasındaki eğitim adım sayısı.
  • rollout_worker_timeout (float, isteğe bağlı, varsayılan 300.0) — Rollout işçisinin son kalp atışından bu yana geçen, eğiticinin işçinin takıldığını varsayıp işlemi sonlandırdığı saniye sayısı.

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

AsyncGRPOTrainer için yapılandırma sınıfı.

Bu sınıf, asenkron GRPO eğitimine özgü parametreleri içerir. Eğitim argümanlarının tam listesi için TrainingArguments belgelerine bakın. Bu sınıftaki varsayılan değerlerin TrainingArguments içindeki değerlerden farklı olabileceğini unutmayın.

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

  • logging_steps: Varsayılan olarak 500 yerine 1 değerini alı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.
  • lr_scheduler_type: Varsayılan olarak linear yerine constant olarak ayarlanır (aşağıya bakın).
  • ignore_data_skip: Varsayılan değeri False yerine True'dir; temel Trainer'ın atla ve yeniden oynat döngüsü, asenkron rollout kuyruğuna uygulanmaz.
  • remove_unused_columns: Varsayılan değeri True yerine False olur ve False olarak kalmalıdır: veri setindeki her sütun ödül fonksiyonlarına iletilir.

Mesaj modu uzlaştırmasında eğitim süresi ve öğrenme oranı: Çok turlu bir sohbet, değişken sayıda eğitim satırına ayrılabilir (sohbetin yeniden yazılması yeni bir satır başlatır), bu nedenle örnek sayısı ve dolayısıyla epoch başına optimizör adımı sayısı önceden bilinemez. Sonuç olarak:

  • num_train_epochs, prompt veri setinin üzerinde tam geçişler olarak sınırlar ve sayı, aslında üzerinde eğitim yapılan farklı promptların sayısı olarak hesaplanır. Bu, dalların (forks) ürettiği satır sayısından bağımsızdır; bu nedenle N epoch istendiğinde her zaman veri üzerinde N geçiş yapılır. max_steps ayarlanmadığında, durdurma koşulu budur ve max_steps yalnızca bir güvenlik sınırıdır.
  • max_steps, açıkça ayarlanırsa (> 0), durdurma koşulu olarak devreye girer (epoch yerine optimizör adımlarıyla sınırlandırır) ve epoch tabanlı durdurmayı devre dışı bırakır.
  • lr_scheduler_type, adım sayısı fork oranına bağlı olduğunda önceden bilinemediği için, bozulma ufku optimizasyon adımlarında ölçüldüğünden varsayılan olarak constant değerine ayarlanır. Bozulan bir öğrenme oranı için, açık bir max_steps değeriyle birlikte bozulan bir zaman çizelgesi belirleyin.

AsyncRolloutLoop

sınıf trl.trainer.async_grpo_trainer.AsyncRolloutLoop

< >

( config: AsyncGRPOConfigmodel_name: strdataset: Datasetreward_funcs: list[collections.abc.Callable[..., list[float]]]processing_class: PreTrainedTokenizerBaseeos_token_ids: list[int]rollout_buffer: Queuemodel_version_value: Synchronizedtoken_allowance: Synchronizedheartbeat_value: Synchronizedfailed_event: Eventexception_info_queue: Queuemetrics_queue: Queuetools: list[collections.abc.Callable] | None = Noneenvironment_factory: collections.abc.Callable[[], object] | dict[str, collections.abc.Callable[[], object]] | None = Nonescore_queue_maxsize: int = 16lora_name: str | None = Nonedataset_start_index: int = 0 )

Bir türetilmiş rollout sürecinde AsyncGRPOTrainer için rollout'ları üretir ve puanlar.

Varsayılan, GRPO'yu uygular. Bir çalıştırmayı özelleştirmek için onu alt sınıflandırın, yalnızca değişen yöntemleri geçersiz kılın ve alt sınıfı eğitimcinin loop_cls'i olarak ayarlayın. Her istek sırasıyla şu adımlardan geçer:

  • filter_prompt(): prompt için üretilip üretilmeyeceği.
  • generate_one(): generate_one_turn() fonksiyonunu her örneklemleme isteği için çağıran tek bir tam rollout.
  • num_generations değerindeki rollout grubu puanlanır: ödülleri, eğitimcinin reward_funcs bileşenlerinin, get_reward tanımlayan ortamların ve Rollout.reward değerlerinin toplamıdır. Ardından compute_advantages() her grup için bir kez çalıştırılır.

setup() ve close(), bir HTTP istemcisi gibi, döngünün olay döngüsünde (event loop) kaynakları oluşturur ve serbest bırakır. Bir hook, self.config (kendi alanlarını taşıyabilen bir AsyncGRPOConfig alt sınıfı) ve self.tokenizer değerlerini okuyabilir. Döngü, türetilmiş bir süreçte (spawned process) oluşturulduğundan, alt sınıf içe aktarılabilir (importable) olmalıdır (modül seviyesinde tanımlanmış olmalıdır).

filter_prompt

< >

( row_index: introw: dict[str, typing.Any]epoch: int ) → bool

Parametreler

  • row_index (int) — Eğitim veri setindeki satırın indeksi.
  • row (dict[str, Any]) — Veri seti satırı.
  • epoch (int) — Bundan önce veri setinin üzerinde tamamlanan tam geçiş sayısı.

Dönüş değeri

bool

True, istem için num_generations rollout üretmek için; False, bunu atlamak için.

Bir prompt için üretim yapılıp yapılmayacağını belirtir. Reddedilen bir prompt, bu epoch için atlanır ve tıpkı atılan bir grup gibi tüketilmiş sayılır. Varsayılan olarak her prompt kabul edilir. Tam bir epoch'taki tüm promptların reddedilmesi, o andan sonra hiçbir batch'in trainer'a ulaşamayacağı için bir hata fırlatır.

generate_one

< >

( prompt: list[dict[str, str]]tools: list[collections.abc.Callable]group_id: int = 0 ) → Rollout

Parametreler

  • prompt (list[dict[str, Any]]) — İstek mesajları.
  • tools (list[Callable]) — Bu rollout için kullanılabilir araçlar: eğitimcinin tools değerleri ve environment_factory kullanıldığında ortamın herkese açık yöntemleri.
  • group_id (int, isteğe bağlı, varsayılan 0) — Rollout'un ait olduğu grubun tanımlayıcısı.

Dönüş değeri

Rollout

Tamamlanan rollout.

Bir istem için bir yuvarlak üretin.

Varsayılan olarak, çok turlu bir araç döngüsü çalışır: her turda sohbet şablonuyla tüm konuşma işlenir, generate_one_turn() ile bir yanıt örneklenir ve içindeki araç çağrıları çalıştırılır; model araç çağırmayı durdurana veya max_tool_calling_iterations değerine ulaşıncaya kadar bu işlem devam eder. Örneğin bir ajan çerçevesiyle farklı bir şekilde üretmek için bunu geçersiz kılın. Eğitim dizileri bunlardan oluşturulduğundan, tüm örneklem isteklerini Rollout.turns içinde döndürün ve rollout'u burada puanlamak için Rollout.reward değerini ayarlayın.

generate_one_turn

< >

( prompt_ids: list[int] ) → TurnRecord

Parametreler

  • prompt_ids (list[int]) — Tam istemcinin token kimlikleri.

Dönüş değeri

TurnRecord

İstem ve log-olasılıklarıyla örneklenen jetonlar. top_k veya top_p kullanıldığında, her örneklenen jetonun aday kümesini; num_sampler_logprobs kullanıldığında ise örnekleyicinin en yüksek log-olasılıklarını da içerir.

vLLM sunucusundan, yapılandırmanın örneklem ayarlarını (temperature, top_p, top_k, min_p, repetition_penalty ve max_completion_length) kullanarak bir yanıt örneği alın.

compute_advantages

< >

( group: RolloutGroup ) → np.ndarray

Parametreler

  • group (RolloutGroup) — Bir istemin num_generations rollout'ları, toplam ödülleri group.rewards içinde.

Dönüş değeri

np.ndarray

Her rollout için bir avantaj, group.rewards sırasındadır.

Bir grubun rollout'ları için rollout başına bir avantaj hesaplayın. Varsayılan olarak, her ödül grup içinde standartlaştırılır; NaN ödülüne sahip bir rollout 0 avantajı alır ve ortalama ile standart sapma hesaplamalarının dışında bırakılır.

Her grup için çalışır. Puanlanan ödülleri birbirine eşit olan bir grup, bu işlem ne tür avantajlar döndürürse döndürsün, elenir.

kurulum

< >

( )

Diğer kancaların ihtiyaç duyduğu kaynakları, örneğin bir HTTP istemcisini oluşturur. İlk istemden önce döngünün olay döngüsünde çalışır. Varsayılan olarak hiçbir şey yapmaz.

kapat

< >

( )

setup() tarafından oluşturulanları serbest bırakır. Döngüler durduğunda, hata durumunda dahil olmak üzere çalışır. Varsayılan olarak hiçbir şey yapmaz.

Rollout

sınıf trl.trainer.async_grpo_trainer.Rollout

< >

( completion: list[dict[str, str]]completion_ids: list[int]turns: list[trl.trainer.async_grpo_trainer.TurnRecord]tool_call_count: int = 0tool_failure_count: int = 0reward: float | None = Nonerollout_id: str = <factory> )

Parametreler

  • completion (list[dict[str, Any]]) — İstemden sonra üretilen mesajlar, konuşma biçiminde. Ödül fonksiyonlarına completions olarak iletilir.
  • completion_ids (list[int]) — Üretilen tamamlamanın token kimlikleri. Ödül fonksiyonlarına completion_ids olarak iletilir.
  • turns (list[TurnRecord]) — Rollout'u üreten örneklem istekleri, sırasıyla. Eğitim dizileri bunlardan oluşturulur: örneklenen jetonlar üzerinde eğitim yapılır, her istemin geri kalanı bağlam olarak kullanılır.
  • tool_call_count (int, isteğe bağlı, varsayılan 0) — Rollout sırasında yapılan araç çağrılarının sayısı.
  • tool_failure_count (int, isteğe bağlı, varsayılan 0) — Başarısız olan bu araç çağrılarının sayısı.
  • reward (float, isteğe bağlı) — Örneğin harici bir değerlendirici tarafından, üretim sırasında hesaplanan ödül. Ödül fonksiyonlarının ve ortamların ödüllerine eklenir. None ise, bu rollout bu kaynaktan ödül almaz.
  • rollout_id (str, isteğe bağlı) — Eğitim satırlarındaki rollout'u, hata ayıklama için tanımlar. Varsayılan olarak yeni rastgele bir onaltılık kimlik kullanılır.

generate_one() tarafından döndürülen tamamlanmış bir rollout.

TurnRecord

sınıf trl.trainer.async_grpo_trainer.TurnRecord

< >

( prompt_ids: list[int]output_ids: list[int]output_log_probs: list[float] = <factory>output_mask: list[int] | None = Noneoutput_sampling_mask: list[list[int]] | None = Noneoutput_sampler_logprobs: list[dict[int, float]] | None = None )

Parametreler

  • prompt_ids (list[int]) — Bu tur için gönderilen tam istemcinin token kimlikleri, konuşmanın önceki tüm turlarını da içerir.
  • output_ids (list[int]) — Örnekleme biriminin ürettiği token kimlikleri.
  • output_log_probs (list[float], isteğe bağlı, varsayılan []) — output_ids içindeki her token için Sampler log-olasılık değeri. Bunlardan herhangi biri üzerinde eğitim yapıldığında zorunludur.
  • output_mask (list[int], isteğe bağlı) — output_ids içindeki her token için bir değer: token üzerinde eğitim yapmak için 1, yalnızca bağlam olarak tutmak için 0. None ise, her çıktı token üzerinde eğitim yapılır.
  • output_sampling_mask (list[list[int]], isteğe bağlı) — output_ids içindeki her token için bir liste: örnekleyicinin top_k / top_p kırpma işlemi altında çekebileceği token kimlikleri. None ise, tam sözlük.
  • output_sampler_logprobs (list[dict[int, float]], isteğe bağlı) — output_ids içindeki her token için bir dict: en olası tokenların sampler log-olasılıkları, token kimliği ile anahtarlanır. Skor merkezleme (num_sampler_logprobs) tarafından kullanılır.

Örnekleme isteği: örnekleme birimine gönderilen istem ve ürettiği jetonlar.

RolloutGroup

sınıf trl.trainer.async_grpo_trainer.RolloutGroup

< >

( prompts: list[list[dict[str, str]]]reward_kwargs: dict[str, list[typing.Any]]completions: list[list[dict[str, str]]]completions_ids: list[list[int]]completions_sequences: list[list[trl.trainer.async_grpo_trainer.TrainingSequence]]tool_call_counts: list[int]tool_failure_counts: list[int]model_version: intgroup_id: introw_index: intenv_rewards: list[tuple[type, float] | None]rollout_rewards: list[float | None]queued_at: float = 0.0rewards: numpy.ndarray | None = None )

Parametreler

  • prompts (list[list[dict[str, Any]]]) — Her rollout'un prompt'u.
  • reward_kwargs (dict[str, list[Any]]) — İstemin veri seti satırındaki diğer sütunlar, ödül fonksiyonlarına anahtar kelime argümanları olarak iletilir.
  • completions (list[list[dict[str, Any]]]) — Her rollout'un tamamlama mesajları.
  • completions_ids (list[list[int]]) — Her rollout'un tamamlama token kimlikleri.
  • completions_sequences (list[list[TrainingSequence]]) — Her rollout'dan oluşturulan eğitim dizileri. Tur aralarında yeniden jetonlaştırılmış geçmişi değişen bir rollout birden fazla dizi verir.
  • tool_call_counts (list[int]) — Her rollout'daki araç çağrılarının sayısı.
  • tool_failure_counts (list[int]) — Her rollout'daki başarısız araç çağrılarının sayısı.
  • model_version (int) — Grubun ilk rollout'unun başladığı andaki politika sürümü.
  • group_id (int) — Rollout sürecinde 0'dan sayılan grubun tanımlayıcısı.
  • row_index (int) — Eğitim veri setinde istemin satır indeksi.
  • env_rewards (list[tuple[type, float] or None]) — Ortamı get_reward tanımlayan bir rollout için ortam sınıfı ve ödülü; aksi halde None.
  • rollout_rewards (list[float or None]) — Her rollout'un Rollout.reward değeri.
  • queued_at (float, isteğe bağlı, varsayılan 0.0) — Grup, puanlama için kuyruğa alındığında time.monotonic() değeri.
  • rewards (np.ndarray, isteğe bağlı) — Her rollout'un toplam ödülü, tüm ödül kaynakları üzerinden toplanır; hiçbir kaynak puanlamadıysa NaN. compute_advantages() çağrılmadan önce ayarlanır.

Bir istemin num_generations yürütmesi, birlikte puanlanır. Her listede yürütme başına bir giriş vardır.

Update on GitHub