TRL documentation

Eşzamanlı Olmayan Damıtma

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Eşzamanlı Olmayan Damıtma

Bu eğitimci vllm, transformers>=5.2.0 ve kernels gerektirir (eğitim, FlashAttention'ı Hub üzerinden bu bileşen aracılığıyla yükler). Dağıtık eğitim için yalnızca FSDP2 desteklenir (DeepSpeed ZeRO desteklenmez).

Şu anda vllm ve transformers çelişkili bağımlılık kısıtlamalarına sahip. Bunu aşmak için önce vLLM'yi kurun, ardından transformers'ı zorla kurun ve son olarak transformers'ın kabul ettiği sürümü sabitleyen TRL'in ek paketi üzerinden kernels'i ekleyin:

pip install vllm
pip install 'transformers>=5.2.0' --no-deps
pip install 'trl[kernels]'

Genel Bakış

experimental.async_distillation.AsyncDistillationTrainer, DistillationTrainer'in asenkron karşılığıdır ve AsyncGRPOTrainer gibi tasarlanmıştır: arka planda çalışan bir rollout işçisi, öğrencinin kendi on-policy tamamlamalarını üretir ve bunları bir öğretmen modeline karşı puanlar; eğitim ise üretim ve gradyan güncellemeleri arasında dönüşümlü ilerlemek yerine eşzamanlı olarak devam eder. Senkron eğitimciyle (trainer) aksine, öğretmen model yerel olarak asla yüklenmez; yalnızca bir vLLM sunucu URL'si gereklidir. Bu sayede öğretmen, öğrenci ve eğitimciden tamamen ayrı donanımda çalışabilir ya da öğrenciyle yan yana sığamayacak kadar büyük bir model olabilir.

compute_loss, öğrencinin ve öğretmenin konum başına token dağıtımları arasında genelleştirilmiş Jensen-Shannon Sapmasını minimize eder (beta=0.0 ileri KL, beta=1.0 ters KL, aradaki değerler interpolasyon yapar); bu, DistillationTrainer ve ServerDistillationTrainer'ın kullandığı aynı amaçtır. Eğitim her zaman on-policy'dir: öğrenci, üzerinde eğitim yaptığı her tamamlamayı kendisi üretir.

Çoklu öğretmenli politika içi damıtma (MOPD)

MOPD, bu trainer’ın temel hedefinin dayandığı 2306.13649 makalesinin (eşzamanlı, tek öğretmenli bir ortamı tanımlayan) bir parçası değildir; MOPD: Multi-Teacher On-Policy Distillation for Capability Integration in LLM Post-Training makalesinde ayrı bir yöntem olarak tanımlanmıştır. Orada MOPD, üç aşamanın üçüncüsüdür: genel SFT, ardından her alan için bir uzman olacak şekilde bağımsız alan bazlı RL eğitimi ve son olarak MOPD’nin bu dondurulmuş uzmanları tek bir öğrenciye entegre etmesi. AsyncDistillationTrainer yalnızca bu üçüncü, füzyon aşamasını uygular: alan bazlı uzman öğretmenler zaten var olmalıdır (örneğin GRPOTrainer/RLOOTrainer ile ayrı ayrı eğitilmiş olmalı) ve teacher_server_urls parametresini onlara yönlendirmeden önce HTTP üzerinden sunulmalıdır. Makalenin kendi 3. aşaması, bu trainer’ın varsayılanı olan beta=0.0 (forward KL) yerine ters KL (beta=1.0) kullanır.

teacher_server_urls birden fazla giriş kabul eder. Tek bir girişle, her örnek bu tek öğretmen tarafından puanlanır (sade on-policy distillation). Birden fazla girişle, her eğitim örneğinin teacher_id sütunu, onu puanlayacak öğretmeni seçer — örneğin, matematik istemlerini matematik uzmanı öğretmene, kod istemlerini kod uzmanı öğretmene yönlendirme; her biri bağımsız olarak sunulur. Her örnek, yalnızca kendisine eşleşen tek öğretmene yönlendirilir; öğretmenler arasında ortalama veya ensemble alınmaz. Eksik veya eşlenmemiş bir teacher_id içeren bir örnek, sessizce yanlış öğretmene geri düşmek yerine bir hata fırlatır. Çalıştırılabilir bir örnek için examples/async_distillation_mopd/async_distillation_mopd.py dosyasına bakın; bu örnek, Open-MOPD ile birlikte yayımlanan matematik, kod ve talimat takibi uzmanlarını ortak SFT checkpoint'lerine birleştirir. Ayrıca, bunu tek bir Hugging Face Jobs komutuyla 4 GPU üzerinde çalıştırmak için examples/async_distillation_mopd/launcher.py dosyasını kullanın.

Her öğretmen, öğrencinin tokenizer'ını paylaşmalıdır. Tamamlamalar, öğretmenlere ham token kimlikleri olarak iletilir ve bir öğretmenin geri bildirdiği aday kimlikler, compute_loss içinde doğrudan öğrencinin kendi sözlüğünü indeksler. Öğrenciyle aynı model ailesinden gelen öğretmenler (aynı checkpoint'ten eğitilmiş SmolLM3 uzmanlarından bir SmolLM3 öğrencisinin füzyonla oluşturulduğu MOPD örneğinde olduğu gibi) bu koşulu sağlar; farklı bir sözlüğe sahip bir öğretmen ise öğrenciyi yanlış token'lara karşı eğitir, bu durum sessizce gerçekleşir, eğer sözlüğü öğrencininkinden büyük değilse.

Kontrol noktası ve devam: ignore_data_skip varsayılan olarak True'dir; temel Trainer'ın atla ve yeniden oynat döngüsü, canlı bir rollout kuyruğuna uygulanmaz. Bunun yerine, henüz eğitim görmemiş ilk istemin indeksi, her kontrol noktasıyla birlikte rollout_state.json dosyasına kaydedilir ve devam sırasında geri yüklenir; böylece işçi, örnekleri yeniden oynatmadan o isteme hızlıca ilerler. Bu, üreticinin değil eğitim konumudur: işçi, 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 eğitim görmemiş istimleri atlar. Akış veri kümeleri (IterableDataset) yeniden konumlandırılamaz; işçileri devam sırasında 0. istimden yeniden başlar. FSDP ile bf16=True (varsayılan) veya fp16=True kullanıldığında, ana ağırlıklar fp32 olsa bile model.safetensors bu veri türünde yazılır; bu nedenle itilen kontrol noktası, sunulan modelin boyutundadır, iki katı değil. fp32 ana ağırlar ve optimizör durumu yine de devam dosyalarına (pytorch_model_fsdp.bin, optimizer.bin) gider; devam sırasında okunan dosyalar bunlardır, bu yüzden devam etme işleminden etkilenmez. FSDP olmadan kontrol noktası aynı zamanda devam dosyasıdır, bu nedenle ana veri türünü korur.

DistillationTrainer'dan farkı

DistillationTrainer içinde öğretmen, yerel olarak yüklenen bir modeldir: üretim, öğretmen ileri geçişi ve gradyan güncellemesi, hepsi aynı süreçte sıralı olarak gerçekleşir. experimental.async_distillation.AsyncDistillationTrainer, bu endişeleri AsyncGRPOTrainer'ın GRPO'nun rollout'unu güncellemesinden ayırma biçiminde aynı şekilde ayırır:

  • Rollout worker (arka plan süreci) — öğrencinin vLLM sunucusundan tamamlamalar üretir, öğretmen tarafından zorlanmış puanlama için (öğretmenin yeni token üretmeden) tam diziyi prompt_logprobs ile çözülen öğretmenin /v1/completions uç noktasına gönderir ve eğitime hazır örnekleri bir kuyruğa iter.
  • Eğitim döngüsü (ana süreç) — kuyruktan örnekleri alır, genelleştirilmiş-JSD kaybını hesaplar ve öğrencinin ağırlıklarını günceller.

Öğretmen, yerel bir ileri geçiş yerine HTTP üzerinden puanlandığı için, dağılımının yalnızca seyrek, üst-k dilimi (teacher_top_k) iletilir; tam sözlük değil — her beta rejiminde kablolama protokolünün bir öğretmen logprob'u için hangi adayları garanti ettiğini tam olarak görmek için experimental.async_distillation.AsyncDistillationConfig'in beta ve teacher_top_k belgelerine bakın.

Her weight_sync_steps eğitim adımı sonrasında, güncellenmiş öğrenci ağırlıkları NCCL üzerinden vLLM sunucusuna aktarılır. AsyncGRPOTrainer'de olduğu gibi, üretim eğitimden önde ilerlediğinden örnekler biraz eski bir politikayı yansıtabilir; max_staleness, bir örneğin atılmadan önce kaç ağırlık güncellemesi gerisinde kalabileceğini kontrol eder.

Hızlı başlangıç

# train_async_distillation.py
from datasets import load_dataset
from trl.experimental.async_distillation import AsyncDistillationTrainer

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 = AsyncDistillationTrainer(
        model="Qwen/Qwen2.5-0.5B-Instruct",
        train_dataset=dataset,
    )
    trainer.train()

Öğretmen sunucusu, öğrencinin vLLM sunucusu ve eğitimci ayrı GPU'larda çalışmalıdır. İkisi de düz vllm serve örnekleridir, ancak farklı bayraklara ihtiyaç duyarlar: öğretmen yalnızca puanlanır (teacher_temperature'in döndürülen logprobs'lerine ulaşabilmesi için --logprobs-mode processed_logprobs, teacher_top_k'in vLLM'in 20 olan varsayılan üst sınırını aşabilmesi için --max-logprobs -1), öğrenci ise yalnızca üretilir ve eğitimcinin güncellenmiş ağırlıkları içine itebilmesi için NCCL ağırlık aktarımının etkinleştirilmesi gerekir. Puanlama, öğrencinin tüm dizisini gönderir ve öğretmenden bir token daha ister, bu nedenle öğretmenin --max-model-len'i (veya varsayılanı) öğrencininkinden büyük olmalıdır:

# Terminal 1: teacher server on GPU 0 (static, never updated)
CUDA_VISIBLE_DEVICES=0 vllm serve Qwen/Qwen2.5-1.5B-Instruct \
    --port 8001 \
    --logprobs-mode processed_logprobs \
    --max-logprobs -1
# Terminal 2: student's vLLM server on GPU 1 (dev mode + NCCL weight transfer are required)
CUDA_VISIBLE_DEVICES=1 VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen2.5-0.5B-Instruct \
    --port 8000 \
    --weight-transfer-config '{"backend":"nccl"}'
# Terminal 3: training on GPU 2
CUDA_VISIBLE_DEVICES=2 python train_async_distillation.py

LoRA

Tam model yerine öğrenci üzerinde bir LoRA adaptörü eğitmek için bir peft_config geçin:

from peft import LoraConfig

trainer = AsyncDistillationTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    train_dataset=dataset,
    peft_config=LoraConfig(r=32, lora_alpha=64, target_modules="all-linear"),
)

Her ağırlık senkronizasyonunda güncellenmiş öğrenci modelinin sunucusuna iletilmesi gerekir. 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. Öğrencinin 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:

CUDA_VISIBLE_DEVICES=1 VLLM_SERVER_DEV_MODE=1 VLLM_ALLOW_RUNTIME_LORA_UPDATING=1 vllm serve Qwen/Qwen2.5-0.5B-Instruct \
    --port 8000 \
    --weight-transfer-config '{"backend":"nccl"}' \
    --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. Tensor-parallel sunum yapıyorsanız VLLM_WORKER_MULTIPROC_METHOD=spawn ekleyin ve her durumda --weight-transfer-config parametresini koruyun: eğitimci yalnızca başlangıçta bir senkronizasyon modu seçer, bu noktada sunucu zaten çalışır durumda olur ve birleşik senkronizasyon yedek çözümdür. Öğretmen sunucusu etkilenmez: asla güncellenmez.

--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 adaptörü sunarken token başına yaklaşık 1.33–1.39x daha yavaş üretim yapar ve genellikle duvar saati süresini üretim belirler. Buna karşılık, her senkronizasyonda çok daha kısa bir duraklama ve senkronizasyon bant genişliğinin yaklaşık %1'ini elde edersiniz. Üretim verimliliği darboğazınızsa, birleşik senkronizasyon genellikle hâlâ daha iyi bir seçimdir.

Kaydedilen metrikler

Bir rollout, bir gradyan haline gelmeden önce birkaç aşamadan geçer. Önce bir prompttan nihai batch kompozisyonumuza kadar olan farklı aşamalara bir bakalım:

Dataset row = PROMPT (message list + optional `teacher_id`)
 └─ ROLLOUT            (1 prompt -> 1 student completion -> 1 teacher scoring call)
     ├─ generate       (student's vLLM /v1/completions, sampled)
     └─ score          (the routed teacher's /v1/completions with `prompt_logprobs`, teacher-forced)
         └─ SAMPLE     (prompt + completion + the teacher's sparse per-position distribution)

════════════ Trainer process boundary: `rollout_buffer` (mp.Queue) ════════════

         └─ SAMPLE (Pulled 1 at a time; dropped if staleness > `max_staleness`)
             └─ ROW            (Planner assigns it to one of `dp` rows, Σ Lᵢ²-balanced)
                 └─ MICRO-BATCH (`dp` rows, one per rank)
                     └─ PACKED ROW (1 concat sequence, `position_ids` reset per sample)
                         └─ FORWARD (`compute_loss`, bs=1, inter-rank padding stripped)
             └─ OPTIMIZER STEP (from `grad_accum` micro-batches)

Üstten alta okunduğunda:

  • a rollout, bir kez üretilen ve bir kez puanlanan tek bir prompt'tur. Grup yoktur: distillation, nesiller arasında hesaplanacak bir avantaj baz çizgisine sahip olmadığından, prompt tekrarlanmaz ve bir rollout tam olarak bir eğitim örneği üretir.
  • a örnek, tamamlama ile her tamamlama konumu için öğretmenin en iyi teacher_top_k adaylarından oluşur. Bu, süreç sınırını aşan veridir.
  • sınırın ötesinde trainer, örnekleri rows (her DP rank için bir tane) olarak planlar, her satırı tek bir birleştirilmiş dizide paketler ve grad_accum mikro-toplu işlemini tek bir optimizer adımında biriktirir.

Buna göre metriklerimizi, hangi aşamanın (veya varlığın) hakkında olduklarına göre bölüyoruz:

namespacesaydığı varlık
rollout/bir üret ve puanla gidiş-dönüşü: ne kadar sürdü, ne kadar ileri gitti
completions/öğrencinin (vLLM) bir istem için ürettiği çıktı
sample/kuyrukta geldiği haliyle tek bir eğitim örneğini temsil eder
batch/bir mikro-toplu (micro-batch) veya bir optimizör adımı (bir veya birden fazla örnekten oluşturulur)
perf/ölçülen saniyeler ve FLOP

Kaybın kendisinin ölçtüğü her şey öneksiz olarak kaydedilir (jsd, entropy, teacher_entropy), MOPD altında ise teacher/<teacher_id>/* kırılımı bulunur — aşağıdaki divergence bölümüne bakın.

Token metriklerinin belirsizliğini gidermek için bazı terimleri de tanımlayalım:

  • generated jetonları, öğrencinin ürettikleridir (completions/*).
  • forwarded jetonlar, forward geçişinin işlediği tüm jetonlardır: istem ve üretilen jetonlar.
  • trained tokenler, completion_mask == 1 olan ve kaybın (loss) bu alt küme üzerinden hesaplandığı tokenlerdir. Trained ≠ generated: öğretmen modelin (teacher) aday ataması yapmadığı bir tamamlama konumu, sapma (divergence) hesabından maskelenir ancak yine de ileriye (forward) iletilir.

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:

  • rollout/duration_s ve rollout/score_s gibi, 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, 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.

GRPOTrainer'ın kaydettiği diğer metrikler GRPO adlarını korur (completions/mean_length, completions/clipped_ratio).

Toplu işlem numaralarının nasıl oluşturulduğu

Satır, bir DP rank'ın bir mikro-batch'te ileriye işlediği tek birimdir: her örnek sınırında position_ids sıfırlanan, tek bir dizide birleştirilmiş birkaç örnektir. Planlayıcı, örneklerin hangi satıra yerleştirileceğini belirler (hiçbir rank'ın geride kalmaması için Σ Lᵢ² dengesini sağlar) ve birleştirme işlemini bir veri toplayıcı (data collator) gerçekleştirir.

Tüm metriklerimizde “step” her zaman TAM bir optimizer adımını ifade eder, asla bir micro-batch değildir. gradient_accumulation_steps micro-batch bir adım oluşturur ve _per_step adlı her metrik, global_step, logging_steps ve Trainer sözlüğünün geri kalanıyla uyumlu şekilde optimizer başına adımı temsil eder. Bir metrik micro-batch başına ise bu açıkça belirtilir (batch/microbatches_per_step) ya da satır başına bir büyüklüktür (batch/row_*, batch/samples_per_row).

Dolayısıyla bir adım, sabit sayıda row-slots içerir:

row-slots per step = gradient_accumulation_steps x world_size

bu da parti metriklerinin birbirleriyle karşılaştırılabileceğiniz bir merdiven oluşturmasını sağlar:

sample                                     sample/forwarded_tokens_mean
  └─ packed into a ROW                     batch/samples_per_row, batch/row_tokens_mean
      └─ one row per DP rank               = one micro-batch
          └─ gradient_accumulation_steps micro-batches = one STEP
                                           batch/samples_per_step, batch/forwarded_tokens_per_step

Dolayısıyla batch/samples_per_step ≈ row-slots x batch/samples_per_row ve aynı mantık token'lar için de geçerlidir. İki taraf yalnızca adım içindeki mikro-partiler arasındaki değişkenliğe kadar eşleşir — adım başına metrikler toplamlar, satır başına olanlar ise ortalamalardır — bu nedenle tam bir eşleşme yerine yüzde birin kesri kadar bir sapma bekleyin.

batch/row_fill_frac, örnekler uzun olduğunda dikkat edilmesi gereken metriktir: 10k token'lık bir örnek, 32k bütçesini kötü bir şekilde doldurur (üçü sığar, dördü asla sığmaz, bu yüzden paketleyici genellikle ikisini alır ve satır ~%77 dolu kalır), oysa 1k token'lık örnekler onu neredeyse mükemmel bir şekilde doldurur. Bu bir hata değil, kuantizasyondur ve token_budget ayarlanabilir parametredir — her dizide dikkat (attention) O(L²) olduğundan, uzun dizilerden oluşan daha dolu bir satırın bellek maliyetinin doğrusal olarak artmadığını göz önünde bulundurmak gerekir.

Rollout kuyruğu

Worker, puanlanmış örnekleri bir kuyruğa iter ve trainer ondan çeker. Bu tek kuyruğu dört metrik tanımlar ve farklı sorulara yanıt verir:

metrikquestion
rollout/queue_sizeşu anda bekleyen örnek sayısı
sample/time_in_queue_seğitilmeden önce tek bir örnek orada ne kadar süre bekledi — politika dışı olmasının saniye yarısı
perf/rollout_wait_skuyruk boş olduğu için eğitim ne kadar süre boyunca engellenmiş olarak kaldı
rollout/backpressure_süretim (işçi), eğitimden max_staleness adım önde olduğu için ne kadar süre bekledi

Son iki metrik (perf/rollout_wait_s ve rollout/backpressure_s) birbirinin aynasıdır. Bunları kuyruk boyutuyla birlikte okuyarak darboğazın hangi tarafta olduğunu anlarsınız:

  • 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_s 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 sıkı: uçuştaki rollouts, örnekleri kuyruğa ulaşmadan önce bu sınırı doldurur, bu da trainer'ın generation geri tutulurken beklemesine neden olur. max_staleness değerini artırın.
  • her ikisi de sıfıra yakın → dengeli!

Tamamlamalar

Bir completion, öğrencinin vLLM sunucusunun bir istem için ürettiğidir.

metrikanlam
completions/mean_lengthrollout başına üretilen token sayısı
completions/min_length, completions/max_lengthpenceredeki en kısa ve en uzun tamamlama
completions/clipped_ratioEOS ile bitmeyen, yani max_completion_length tarafından kesilen tamamlamaların oranı
completions/mean_terminated_length, completions/min_terminated_length, completions/max_terminated_lengthEOS ile biten tamamlamalar üzerinde aynı uzunluklar

Rollout'lar

Bir rollout, baştan sona işlenen tek bir istemdir: öğrenci tarafından üretilir, ardından öğretmen tarafından öğretmen zorlamalı (teacher-forced) olarak işlenir. Öğretmen çağrısı, her rollout'un kritik yolunda yer aldığı için (GRPO'da puanlamanın tamamlanan gruplar üzerinde ayrı bir döngüde yapılmasının aksine), yavaş bir öğretmen doğrudan rollout/duration_s olarak görünür.

metrikanlam
rollout/duration_sbir rollout için duvar saati, dağıtımdan puanlanmış örneğe kadar: üretim ve öğretmen çağrısı
rollout/score_sbunun, öğretmenin /v1/completions çağrısının ne kadar sürdüğü
teacher/<id>/score_sMOPD only: aynı, öğretmen başına. Yavaş bir uzman, yalnızca kendisine yönlendirilen rollout'ları sınırlar; bu durum, karışık ortalama tarafından gizlenir
rollout/generated_tokens_per_sson aralık boyunca (pencereleme yapılarak) üretim verimi, böylece bir duraksama görünür
rollout/concurrencyuçuştaki rollout'lar, yani üretilen veya puanlanan
rollout/vllm_retry_countyeniden denenen vLLM istekleri, ya öğrencinin sunucusuna ya da bir öğretmenin sunucusuna yönlendirilir. Aksi takdirde, bozulmuş bir sunucu açıklanamayan bir yavaşlık gibi görünür. Bu, istekleri üretilen metin değil, bir sunucuya yapılan istekler olarak saydığı için completions/ altında değil de burada yer alır
rollout/backpressure_süretim, max_staleness adım önde olduğu için ne kadar süre bekledi. rollout kuyruğuna bakın
rollout/queue_sizerollout kuyruğunda bekleyen puanlanmış örnekler, trainer'ın bunları çektiği yerde ölçülür. rollout kuyruğu

Kuyruktan gelen örnekler

Her örnek bir RolloutSample'dır: bir istem, öğrencinin tamamlaması ve öğretmenin buna verdiği seyrek puanlama. İşçi bunları rollout_buffer'a iter; aşağıdaki her şey, eğitim için bunları çekerken eğitimci tarafında ölçülür.

metrikanlam
sample/forwarded_tokens_mean, sample/forwarded_tokens_maxbir örnekteki tokenler: prompt + üretilen. Packing satır düzeyinde bir konudur, bkz. batch/row_*
sample/trained_tokens_meanbunlardan kaçının üzerinde kayıp alınır
sample/time_in_queue_sBu örneğin eğitimden önce o kuyrukta ne kadar süre beklediğini gösterir. perf/rollout_wait_s ile aynı değildir — bkz. rollout kuyruğu
sample/staleness_mean, sample/staleness_maxverinin ne kadar policy sürümü gerisinde olduğunu gösterir. jsd, off-policy olmanın kayıp üzerindeki etkisini gösterir; bu da nedeni gösterir
sample/dropped_stale_countmax_staleness değerini aşan örnekler düşürüldü

Partiler

Bir mikro-batch world_size satırdır (paketleme, düzleştirme ile 1 diziye indirger), bu nedenle her DP rank'ı için bir tane olur ve i rank'ı i satırını iletir. Bunların gradient_accumulation_steps adedi bir optimizör adımı oluşturur. Bir adım, toplamda gradient_accumulation_steps × world_size satırı kapsar. Aşağıdaki her _per_step metriği, tüm adım ve tüm rank'lar üzerinden bir toplamdır; batch/row_* olanlar ise satırlar üzerinden ortalama değerlerdir.

metrikanlam
batch/forwarded_tokens_per_step, batch/trained_tokens_per_stepbir optimizör adımındaki tokenler, sırasıyla ileriye aktarılan ve eğitilen
batch/samples_per_stepher optimizasyon adımı başına eğitim örnekleri
batch/microbatches_per_stepsayıldı, yapılandırmadan okunmadı
batch/masked_token_fraccompletion_mask == 0 olan ileri yönlendirilen tokenler — gradyan kazanmayan ileri yönlendirme payı
batch/samples_per_row, batch/row_tokens_mean, batch/row_tokens_maxplanlayıcının her sıranın satırını ne kadar yoğun paketlediği
batch/row_fill_fracrow token'ları token_budget ile karşılaştırılır. Düşük, bütçenin kullanılmadığı anlamına gelir
batch/row_imbalanceSatırlar boyunca max Σ Lᵢ² / mean Σ Lᵢ². Dikkat O(L²) olduğundan, bu, gradyan all-reduce işleminin hangi sıralarda tıkanacağını tahmin eder. 1.0 mükemmeldir
batch/pad_fracrütbe arası dolgu. Sadece yayın baytlarına mal olur; ileri yönlü işlem öncesi kaldırılır
batch/dropped_oversize_counttoken_budget aşımı nedeniyle düşürülen örnekler

Divergence

Hedefin kendisinin, penceredeki eğitim görmüş jetonlar üzerinden ortalama olarak ölçtüğü değer. Bunlar, işleme hızı (throughput) için değil, öğrenme için izlenmesi gereken sayılardır.

metrikanlam
jsdYapılandırılan beta değeri için kaybın minimize ettiği genelleştirilmiş JSD. Düşüş, öğrencinin dağılımının öğretmenin dağılımına yakınsadığını gösterir
entropyöğrencinin kendi tahmini entropisi. Burada jsd düşerken bir çöküş, öğrencinin öğrenmek yerine daraldığını gösterir
teacher_entropyöğretmenin bildirdiği adaylar üzerindeki entropisi. Sadece teacher_top_k adayın kabloya geçtiği için gerçek değerin altında sınırlıdır
teacher/<id>/jsdSadece MOPD: jsd, öğretmenin puan verdiği jetonlarla sınırlıdır. Farklı alanlardaki öğretmenler çok farklı hızlarda sapabilir ve karışık jsd bunu karıştırır
teacher/<id>/entropySadece MOPD: teacher_entropy için aynı kırılım
teacher/<id>/token_fracSadece MOPD: öğretmen tarafından alınan puanlanmış tokenlerin payı. Yönlendirme sapması aksi halde görünmezdir: satırlardan yoksun bırakılmış bir öğretmen yine de sağlıklı bir teacher/<id>/jsd raporlar.
aux_lossMoE yönlendiricisinin mikro-baş başına yük dengeleme kaybı, ranklar üzerinde ortalama alınmış, model yönlendirici logitlerini döndürdüğünde ve router_aux_loss_coef 0 olmadığında kaydedilir. Yukarıdaki satırlardan farklı olarak, bu bir token başına ortalama değildir

Öğretmen başına entropy yoktur: öğrencinin entropisi, örneği hangi öğretmenin puanladığıyla değil, kendi politikasının bir özelliğiyle ilgilidir; bu nedenle karışık metrik bunu zaten kapsar.

Performans

Throughput, eğitimcinin saniyede kaç token işlediğini ölçer. Model FLOPs Utilization (MFU), modelin ileri ve geri geçişleri için kullanılan eğitim cihazlarının teorik hesaplama kapasitesinin yüzdesini tahmin eder. Bu tahmin için kullanılan kapasite, donanıma ve eğitim hassasiyetine bağlıdır.

Throughput ve MFU iki zaman temelinde raporlanır:

  • fwd_bwd_, ileri ve geri geçişler sırasında performansı ölçer.
  • wall_clock_, optimizasyon güncellemelerini, ağırlık senkronizasyonunu ve rollout'lar için harcanan bekleme süresini de içeren tam optimizasyon adımındaki performansı ölçer.

Bu fark, hesaplama performansını bekleme ve koordinasyon maliyetinden ayırt etmeye yardımcı olur. Her iki MFU metriği de yalnızca eğitim cihazlarını açıklar: harici rollout veya öğretmen sunucularının hesaplama veya donanım kapasitesini içermezler. Duvar saati MFU, bu hizmetlerin kendi kullanım oranlarını değil, eğitimcinin bu hizmetleri beklemek için harcadığı süreyi yansıtır.

MFU, yalnızca seçilen hassasiyette yerel eğitim cihazının tepe hesaplama kapasitesinin bilindiği ve FLOPs tahmininin model mimarisini (Llama, Qwen2, Qwen3, Qwen3-MoE veya Qwen3-VL gibi) desteklediği durumlarda raporlanır. Aksi takdirde MFU atlanır; eğitim devam eder ve veri aktarımı ile zamanlama metrikleri kullanılabilir kalmaya devam eder.

metrikanlam
perf/step_soptimizasyon adımları arasındaki duvar saati: hesaplama, optimizasyon, ağırlık senkronizasyonu ve kuyruk bekleme süreleri dahil
perf/fwd_bwd_sforward + backward, adımın mikro-partiler üzerinden toplanmış hali. Aşağıdaki her fwd_bwd_ metriğinin paydasıdır
perf/fwd_sön (forward) kısmı. fwd_s / fwd_bwd_s oranının 1/3 civarında olması yaygın bir dağılımdır; daha yüksek olması, geriye yayılımın (backward) ucuz olduğunu ya da yeniden hesaplamanın (recompute) forward sırasında yapıldığını gösterir.
perf/optimizer_soptimizer.step()
perf/rollout_wait_skuyruk boş olduğu için trainer'ın ne kadar süre boyunca bloke kaldığı. rollout kuyruğu'na bakın
perf/weight_sync_stam bir senkronizasyon, ayrıca _pause_s (vLLM için bekleme), _barrier_s (rank sapması) ve _transfer_s (baytlar)
perf/fwd_bwd_forwarded_tokens_per_s, perf/wall_clock_forwarded_tokens_per_sher bazda saniyede iletilen token sayısı
perf/wall_clock_trained_tokens_per_saynı, yalnızca kaybın gördüğü tokenları sayarak
perf/fwd_bwd_mfu, perf/wall_clock_mfuher bazda model FLOPs kullanımı

Tasarım felsefesi

Bu eğitimci bilinçli olarak minimal tutulmuş olup genel amaçlı bir çözüme dönüşmesi hedeflenmemektedir. Desteklenmeyen bir özelliğe ihtiyacınız varsa, depoyu klonlayıp eğitimciyi doğrudan ihtiyaçlarınıza göre uyarlamanızı öneririz. Yeni özellikler yalnızca anlamlı bir topluluk talebi olduğunda değerlendirilecektir.

AsyncDistillationConfig

sınıf trl.experimental.async_distillation.AsyncDistillationConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool | None = Nonegradient_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 = Truelabel_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 = Nonemax_completion_length: int = 2048temperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonerepetition_penalty: float = 1.0chat_template_kwargs: dict | str | None = Nonevllm_server_base_url: str = 'http://localhost:8000'vllm_server_timeout: float = 1800.0teacher_server_urls: dict[str, str] | str | None = Nonebeta: float = 0.0teacher_temperature: float = 1.0teacher_top_k: int = 8add_tail_bucket: bool = Truetoken_budget: int | None = Nonemax_concurrent_rollouts: int = 512max_staleness: int = 4weight_sync_steps: int = 1rollout_worker_timeout: float = 300.0log_completions: bool = Falselog_completions_steps: int = 100num_completions_to_print: int | None = None )

Modeli kontrol eden parametreler

  • model_init_kwargs (dict[str, Any] veya str, isteğe bağlı) — Bir yoldan öğrenci modelini örneklerken kullanılan from_pretrained için anahtar kelime argümanları. revision değeri, işleme sınıfı yüklenirken de kullanılır.
  • dtype (str, isteğe bağlı, varsayılan olarak "float32") — öğrenci modelinin yükleneceği veri tipi, aşağıdakilerden biri "auto", "bfloat16", "float16" veya "float32". varsayılan olarak "float32" asenkron eğitimcilerin ölçüldüğü eğitim-çıkarsama uyumsuzluğuFP16 ile Eğitim-Çıkarsama Uyumsuzluğunun Aşılması) eğitmenin kendi hassasiyetine duyarlıdır. Bu farkı uçtan uca kapatmak, öğrencinin vLLM sunucusunu da aynı veri tipiylevllm serve --dtype). A dtype içinde model_init_kwargs öncelik taşır. Öğretmen sunucuları etkilenmez: asla güncellenmezler.

    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

  • max_completion_length (int, isteğe bağlı, varsayılan 2048) — Tamamlama başına üretilecek maksimum token sayısı.
  • temperature (float, isteğe bağlı, varsayılan 1.0) — Öğrencinin politika içi tamamlamalarını örneklemekte kullanılan sıcaklık.
  • top_p (float, isteğe bağlı, varsayılan 1.0) — On-policy üretim için Top-p (nucleus) örneklemesi parametresi.
  • top_k (int, isteğe bağlı, varsayılan 0) — On-policy üretim için top-k örneklemesi parametresi. 0, top-k filtrelemeyi devre dışı bırakır.
  • min_p (float, isteğe bağlı) — En olası token'ın olasılığına göre ölçeklendirilen minimum token olasılığı. 0.0 ile 1.0 arasında bir değer olmalıdır. Tipik değerler 0.01-0.2 aralığındadır.
  • repetition_penalty (float, isteğe bağlı, varsayılan 1.0) — İstemde ve şu ana kadar üretilen metinde görünüp görünmediklerine göre yeni token'ları cezalandıran bir ondalık sayı. 1.0'dan büyük değerler modelin yeni token'lar kullanmasını teşvik ederken, 1.0'dan küçük değerler modelin token'ları tekrarlamasını teşvik eder.
  • chat_template_kwargs (dict[str, Any], isteğe bağlı) — Tamamlamalar oluşturulurken apply_chat_template fonksiyonuna iletilecek ek anahtar kelime argümanları.

vLLM sunucularını kontrol eden parametreler

  • vllm_server_base_url (str, isteğe bağlı, varsayılan "http --//localhost:8000"): Öğrencinin vLLM sunucusunun temel URL'si; hem üretim hem de ağırlık güncellemelerinin akışında kullanılır.
  • vllm_server_timeout (float, isteğe bağlı, varsayılan 1800.0) — vLLM sunucularına yapılan çağrılar için saniye cinsinden zaman aşımı: başlangıçta öğrenci sunucusunun hazır olmasını bekleme, her üretim veya puanlama isteği ve her ağırlık eşitleme çağrısı. Sunucuyu bekleme ve ağırlık eşitleme çağrıları süre dolduğunda hata fırlatır; zaman aşımına uğrayan bir üretim veya puanlama isteği yeniden denenir.
  • teacher_server_urls (dict[str, str], isteğe bağlı, varsayılan {"default" -- "http://localhost:8001"}): Her biri vllm serve <teacher-model> --logprobs-mode processed_logprobs --max-logprobs -1 ile başlatılan öğretmen vLLM sunucusu/sunucuları. Her öğretmen statiktir: bu eğitimci asla ağırlık güncellemelerini bunlardan herhangi birine akış olarak göndermez, bu nedenle bir öğretmenin ne VLLM_SERVER_DEV_MODE ne de bir ağırlık aktarım altyapısına ihtiyacı vardır; yalnızca skorlamayı kesin kılan bu iki bayrağa ihtiyacı vardır (bkz. teacher_temperature ve teacher_top_k). Her öğretmenin öğrencinin tokenizer'ını paylaşması gerekir: tamamlamalar ham token kimlikleri olarak gönderilir ve bir öğretmenin geri bildirdiği kimlikler, compute_loss içinde öğrencinin kendi sözlüğünü doğrudan indekslemek için kullanılır. Farklı bir sözlüğe sahip bir öğretmen, yanlış token'lara karşı eğitim görür; sözlüğü öğrencinkinden büyük veya eşit değilse bu durum sessizce gerçekleşir. Skorlama, öğrencinin kendi tamamlama token'larına karşı yapılan bir öğretmen-zorlamalı istektir (max_tokens=1, prompt_logprobs=teacher_top_k, temperature=teacher_temperature); bu, senkron sunucu-öğretmenli eğitimciler için get_sequence_logprobs() tarafından yapılan istekle aynıdır. Bu atıl token nedeniyle, bir öğretmenin --max-model-len değeri öğrencinkinden büyük olmalıdır, aksi halde en uzun tamamlamalar skorlanamaz. Tek bir giriş, her örneği skorlar (sade tek-öğretmenli on-policy distillasyon, varsayılan). Birden fazla giriş MOPD'yi (çoklu-öğretmenli on-policy distillasyon, bkz. MOPD) etkinleştirir: her eğitim satırının teacher_id sütunu, hangi girişin onu skorlayacağını seçer, örneğin satır başına "math" veya "code" olan bir teacher_id ile {"math": "http://localhost:8002", "code": "http://localhost:8003"}.

Damıtma kaybını kontrol eden parametreler

  • beta (float, isteğe bağlı, varsayılan 0.0) — Genelleştirilmiş Jensen-Shannon Sapması için interpolasyon katsayısı. 0.0 ileri KL (ortalama arayan), 1.0 ters KL (mod arayan) olup aradaki değerler, DistillationTrainer'ın içsel olarak hesapladığı aynı genelleştirilmiş-JSD formülasyonuna göre interpolasyon yapar. Sapmanın hesaplandığı destek kümesi, ServerDistillationTrainer'ı yansıtarak rejime göre değişir: beta=0.0 olduğunda, ileri KL'nin ağırlıklandırmasının tam olarak bu destek tarafından sağlandığı için, tam teacher_top_k genişliğindeki öğretmen bildirimi destek kümesi (kuyruk kovası dahil) kullanılır. beta != 0.0 olduğunda ise destek kümesi, yalnızca iki adaya daraltılır: öğretmenin kendi en iyi 1 jetonu ve tamamlamanın gerçekleşen/gerçek jetonu; çünkü kablolama protokolü, daha geniş (veya tam) bir sözlük aktarmadan, öğretmen logprob'u için garanti edilen tek iki jeton kimliği bunlardır; daha geniş bir kapsam, öğrencinin kendi olası jetonlarını kapsamanın yalnızca olasılıksal bir yaklaşımı olurdu, bir garanti değil.
  • teacher_temperature (float, isteğe bağlı, varsayılan 1.0) — Divergence için softmax sıcaklığı, her iki tarafa da uygulanır: vLLM'in logprobs'lerini bu sıcaklıkta sunucu tarafında hesaplaması için öğretmene gönderilir (kesin, istemci tarafında yeniden ölçekleme değildir) ve compute_loss içinde öğrencinin kendi logits'lerine uygulanır, bu da ServerDistillationTrainer'ın tek temperature değerini yansıtır. Öğrencinin tamamlamalarını nasıl örneklediğini kontrol eden temperature parametresiyle ilgisi yoktur. Öğretmenin sunucusunun, bu ayarın döndürülen logprobs'lerine ulaşabilmesi için --logprobs-mode processed_logprobs ile çalıştırılması gerekir; aksi takdirde öğretmen sessizce ham logprobs'leri raporlar ve bu ayar yalnızca öğrenci tarafını etkiler.
  • teacher_top_k (int, isteğe bağlı, varsayılan 8) — Öğretmenden prompt_logprobs üzerinden istenen, konum başına aday token sayısı. Öğretmenin dağılımını yaklaşık olarak hesaplamak için yalnızca bu adaylar (gerçekleşen token, vLLM bunu top-k dışında olsa bile her zaman raporlar, ve kalan olasılık kütlesini yakalayan bir kuyruk kovası, bkz. add_tail_bucket) kullanılır; tam sözlük asla HTTP üzerinden iletilmez. Sapmanın öğrenci tarafı kesin olarak hesaplanır (yaklaşık değil, yerel olarak hesaplanır), çünkü öğrenci eğitilen modeldir ve tam logitleri zaten compute_loss içinde mevcuttur. 8, duman testleri için hafif bir varsayılandır; komşu RL çerçevelerindeki üretim ortamındaki on-policy-distillation kurulumları, kabaca aynı aralıkta seyreden seyrek bir öğretmen desteği kullanır (miles varsayılanı 16, EasyOPD 64), bu nedenle gerçek eğitime geçildiğinde bu değeri 16–64 aralığına doğru yükseltmek makuldür. 20'nin üzerindeki değerler, öğretmen sunucusunun vLLM'nin token başına varsayılan logprob sınırını kaldıran --max-logprobs -1 ile başlatılmış olmasını gerektirir.
  • add_tail_bucket (bool, isteğe bağlı, varsayılan True) — teacher_top_k dışında kalan olasılık kütlesini temsil eden bir kuyruk kovasını ekleyip eklemeyeceğini belirtir; teacher_top_k küçük olduğunda basitçe küçük bir sapmayı önlemek için kullanılır.
  • token_budget (int, isteğe bağlı) — Tek bir satıra (bir DP rank’ın ileri geçişine) sığdırılan gerçek token sayısının üst sınırı. TokenBudgetBatcher, satırlarının her birinin bu bütçe içinde kalmasını sağlayarak Σ Lᵢ² dengeli mikro-toplamlar oluşturur; bu sayede tepe bellek, örnek sayısından bağımsız olarak sınırlandırılır (satır başına örnek sayısı dinamik hale gelir). None (varsayılan) ise, değer, öğrenci vLLM sunucusunun max_model_len değerine (eğitim başlangıcında sorgulanır) ayarlanır — istem + tamamlama uzunluğu için üst 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, bir uyarıyla atılır ve batch/dropped_oversize_count olarak sayılır.

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

  • max_concurrent_rollouts (int, isteğe bağlı, varsayılan 512) — Aynı anda öğrencinin ve öğretmenlerin vLLM sunucularına karşı, üretilmekte veya puanlanmakta olan rollout'ların maksimum sayısı.
  • 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 sınırlanır: bir rollout, kuyrukta ve işlenmekte olan token'ların, eğitimcinin max(max_staleness, 1) adımda tükettiği miktara sığması koşuluyla başlar.
  • weight_sync_steps (int, isteğe bağlı, varsayılan 1) — Öğrencinin 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 log_completions_steps puanlanan örnekten bir (prompt, completion) çifti örneğinin günlüğe kaydedilip kaydedilmeyeceği.
  • log_completions_steps (int, isteğe bağlı, varsayılan 100) — Tamamlanma kayıtları arasında puanlanan örnek sayısı. Yalnızca log_completions True ise kullanılır. Optimizer adımları değil, rollout işçisinin puanladığı örnekler üzerinden sayılır: işçi, eğitimciden ayrı bir süreçte çalışır ve self.state.global_step değerine erişemez.
  • 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.

experimental.async_distillation.AsyncDistillationTrainer için yapılandırma sınıfı.

Bu sınıf, asenkron on-policy distillasyona özgü parametreleri içerir. Eğitim argümanlarının tam listesi için TrainingArguments belgelerine başvurun. Bu sınıftaki varsayılan değerlerin TrainingArguments içindeki değerlerden farklı olabileceğini unutmayın. Yapısı AsyncGRPOConfig ile aynıdır (asenkron pipeline, vLLM sunucusu ve günlük alanları aynıdır); GRPO’nun kırpma/grup alanları aşağıdaki öğretmen-distillasyon kaybı alanlarıyla değiştirilmiştir.

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

AsyncDistillationTrainer

sınıf trl.experimental.async_distillation.AsyncDistillationTrainer

< >

( model: str | PreTrainedModelargs: trl.experimental.async_distillation.async_distillation_config.AsyncDistillationConfig | 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 = None )

Parametreler

  • model (str veya PreTrainedModel) — Eğitilecek öğrenci modeli. Şunlardan biri olabilir:
    • Bir dize, huggingface.co'daki 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. from_pretrained ile yüklenir.
    • Bir PreTrainedModel nesnesi. Dikkat uygulaması, dolgusuz eğitim için trainer'ın FlashAttention arka ucuna değiştirilir.

    Yapılandırma dosyasındaki model adı, öğrenci modelini vLLM sunucusunda tanımlamak için kullanılır.

  • args (experimental.async_distillation.AsyncDistillationConfig, 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) — Eğitim için kullanılacak veri seti. Bir "prompt" sütunu içermelidir (conversational biçimi). Ek sütunlar yok sayılır.
  • processing_class (PreTrainedTokenizerBase, isteğe bağlı) — Verileri işlemek için kullanılan işleme sınıfı. None ise, model adıyla from_pretrained kullanılarak yüklenir. Dolgu (padding) sembolü yoksa tokenizer.eos_token kullanılır.
  • callbacks (TrainerCallback listesi, isteğe bağlı) — Eğitim döngüsünü özelleştirmek için eklenen geri çağrılar listesi, varsayılan geri çağrılara eklenir (bkz. burası).
  • 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. Varsayılan olarak AdamW ve args tarafından kontrol edilen doğrusal bir zamanlama kullanılır.
  • peft_config (PeftConfig, isteğe bağlı) — Modeli sarmak için kullanılan PEFT yapılandırması. None ise model sarılmaz. Öğrencinin vLLM sunucusu --enable-lora ile başlatıldıysa, bir LoRA adaptörü birleştirilmiş ağırlıklar olarak değil, bir adaptör olarak senkronize edilir; AsyncDistillation belgelerinin LoRA bölümüne bakın.

DistillationTrainer'ın asenkron karşılığı, tam olarak AsyncGRPOTrainer mimarisine sahiptir: arka planda çalışan bir rollout işçisi, öğrencinin on-policy tamamlamalarını üretir ve bunları bir öğretmen sunucusuna karşı puanlarken eğitim eşzamanlı olarak devam eder; bu sayede rollout, gradyan güncelleme döngüsünden ayrıştırılır. GRPO'nun kırpılmış politika-gradyan kaybı grup-göreli bir avantaj okurken, bu trainer'ın compute_loss fonksiyonu seyrek, konum bazlı bir öğretmen dağılımı okur ve buna karşı genelleştirilmiş bir JSD'yi minimize eder (bkz. AsyncDistillationConfig.beta); her zaman on-policy çalışır: öğrenci, üzerinde eğitim yaptığı her tamamlamayı kendisi üretir.

Eşzamanlı DistillationTrainer'ın aksine, bu trainer yalnızca HTTP üzerinden sunulan bir öğretmen modeline karşı puanlamayı destekler (harici bir vLLM sunucusu). Yerel (süreç içi, GPU) öğretmen ileri geçişi, GRPO'nun ödül fonksiyonlarının yapabildiği gibi, CUDA devre dışı bırakılmış rollout worker'ının türetilmiş alt sürecinde çalışamaz; bunun yerine ana eğitim sürecinde çalıştırılması gerekir. Bu yol henüz uygulanmamıştır.

Örnek:

>>> from trl.experimental.async_distillation import AsyncDistillationTrainer
>>> from datasets import load_dataset

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

>>> trainer = AsyncDistillationTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()
Update on GitHub