Indeks Paper

Setiap paper di bawah ini memiliki tautan ke halaman paper Hugging Face-nya. Anda juga dapat membaca salah satunya dari terminal menggunakan CLI hf, misalnya hf papers read 2402.03300 — sangat berguna untuk coding agents.

Optimasi Kebijakan Relatif Grup

Makalah yang berkaitan dengan GRPOTrainer.

DeepSeekMath: Mendorong Batasan Penalaran Matematis dalam Model Bahasa Terbuka

📜 Makalah: https://huggingface.co/papers/2402.03300

Memperkenalkan Group Relative Policy Optimization (GRPO) dan menunjukkan peningkatan penalaran matematika yang signifikan dari pra-pelatihan yang berpusat pada matematika ditambah optimasi bergaya PPO yang relatif terhadap grup. Digunakan di TRL melalui GRPOTrainer.

from trl import GRPOConfig, GRPOTrainer

# The paper doesn't specify its hyperparameters, so here we provide hyperparameters from "DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning" instead.
training_args = GRPOConfig(
    loss_type="grpo",
    beta=0.001,  # "the KL coefficient to 0.001"
    epsilon=10.0, # "the GRPO clip ratio ϵ to 10"
    num_generations=16,  # "For each question, we sample 16 outputs..."
    max_completion_length=32_768,  # "...with a maximum length of 32,768"
    steps_per_generation=16,  # "To accelerate training, each rollout generates 8,192 outputs, which are randomly split into 16 minibatches"
    # "resulting in a training batch size of 512". One way to achieve this setting with 1 device is per_device_train_batch_size=4, gradient_accumulation_steps=128
    per_device_train_batch_size=4,
    gradient_accumulation_steps=128,  
)
trainer = GRPOTrainer(
    ...,
    args=training_args,
)

DeepSeek-R1: Mendorong Kemampuan Penalaran pada LLM melalui Pembelajaran Penguatan

📜 Makalah: https://huggingface.co/papers/2501.12948

DeepSeek-R1 mencapai kinerja penalaran yang setara dengan OpenAI-o1 melalui pipeline multi-tahap yang beralih dari penguatan murni (RL) ke model yang disempurnakan dan selaras dengan manusia. Berbeda dengan pendahulunya, DeepSeek-R1-Zero, yang menggunakan RL murni pada model dasar, R1 mengikuti evolusi empat tahap yang terstruktur:

1. Cold Start: Model dasar dihaluskan (fine-tuned) pada set kecil data Chain-of-Thought (CoT) panjang berkualitas tinggi untuk memberikan titik awal yang stabil.
2. RL Berorientasi Penalaran: RL berskala besar diterapkan untuk meningkatkan kinerja dalam matematika, pemrograman, dan logika, menggunakan hadiah berbasis aturan dan hadiah konsistensi bahasa untuk mengurangi pencampuran bahasa.
3. Rejection Sampling & SFT: Checkpoint RL menghasilkan 600k sampel penalaran melalui rejection sampling, yang digabungkan dengan 200k sampel non-penalaran (umum) untuk membuat dataset baru bagi putaran kedua Supervised Fine-Tuning.
4. RL untuk semua Skenario: Tahap RL terakhir menyelaraskan model dengan preferensi manusia (kebergunaan dan keamanannya) di semua domain sambil mempertahankan kekuatan penalaran.

Distilasi: Memberdayakan Model Kecil

Kontribusi utama dari makalah ini adalah menunjukkan bahwa pola penalaran dapat didistilasi dari model besar (DeepSeek-R1) ke dalam model dense yang lebih kecil (misalnya, seri Qwen dan Llama). Distilasi terbukti lebih efektif untuk model kecil dibandingkan melatihnya dengan RL murni dari awal.

Anda dapat menggunakan GRPOTrainer untuk mereplikasi tahap yang berat dalam penalaran dari pipeline ini.

from trl import GRPOConfig, GRPOTrainer

# Example configuration for a reasoning-oriented GRPO stage
# Based on the Open-R1 recipe for Qwen-7B
training_args = GRPOConfig(
    learning_rate=4.0e-5,
    max_completion_length=32768, # Support for long Chain-of-Thought
    num_generations=16,          # Sample 16 outputs per prompt for group relative advantage
    beta=0.001,                  # KL coefficient
    use_vllm=True,               # Use vLLM backend for accelerated rollout generation
)

trainer = GRPOTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    reward_funcs=[accuracy_reward, format_reward], # R1-Zero used rule-based rewards
)

trainer.train()

Optimasi Kebijakan Urutan Grup

📜 Makalah: https://huggingface.co/papers/2507.18071

GSPO adalah varian GRPO yang menghitung bobot importance sampling pada level sekuens, bukan per-token. Untuk mereproduksi pengaturan dari paper tersebut, gunakan konfigurasi ini:

from trl import GRPOConfig

training_args = GRPOConfig(
    importance_sampling_level="sequence",
    loss_type="grpo",
    beta=0.0,  # GSPO set KL regularization to zero: https://github.com/volcengine/verl/pull/2775#issuecomment-3131807306
    epsilon=3e-4,  # GSPO paper (v2), section 5.1
    epsilon_high=4e-4,  # GSPO paper (v2), section 5.1
    gradient_accumulation_steps=1,
    steps_per_generation=4,  # partition rollout batch into 4 mini-batches. GSPO paper (v2), section 5.1. Must be 4 times gradient_accumulation_steps
)

Perhatikan bahwa metode ini hanya berdampak ketika pelatihan sedikit menyimpang dari kebijakan—misalnya, ketika steps_per_generation > gradient_accumulation_steps atau num_iterations > 1. Jika tidak, metode ini secara efektif setara dengan tidak ada modifikasi.

TRL menyediakan implementasi GSPO-token eksperimental hingga v1.13; fitur ini tidak lagi menjadi bagian dari pustaka dan tetap tersedia dalam riwayat git. Implementasi ini berbeda dari tujuan tingkat urutan di atas hanya ketika advantage bervariasi terhadap $t$, yang saat ini tidak dihasilkan oleh TRL.

Rasio kebijakan: GRPO vs. GSPO

Di GSPO, rasio kebijakan didefinisikan pada level sekuens. Dengan kata lain, rasio ini adalah perbandingan antara probabilitas kebijakan saat ini menghasilkan suatu sekuens dengan probabilitas kebijakan lama menghasilkan sekuens yang sama.

Kemungkinan sekuens didefinisikan sebagai: $$\pi_\theta (o_i | q) = \prod_{t=1}^{|o_i|} \pi_\theta (o_{i,t} | q, o_{i, < t} ),$$

di mana $\pi_\theta$ adalah kebijakan $\pi$ dengan parameter $\theta$, $o_i$ adalah $i$-urutan keluaran ke- $o$ dan $o_{i,t}$ adalah $t$-token ke- dalam urutan ini, $q$ adalah kueri masukan. Rasio kemungkinan urutan $s_i (\theta)$ didefinisikan sebagai: $$s_i (\theta) = \left(\frac{\pi_\theta (o_i | q)}{\pi_{\theta_{old}} (o_i | q)} \right)^{\frac{1}{|o_i|}}$$

Eksponen $\frac{1}{|o_i|}$ mewakili normalisasi panjang sekuens, meminimalkan pengaruh panjang sekuens dalam kemungkinan sekuens. Dengan kata lain, ini menghitung rata-rata geometris probabilitas token, memastikan perbandingan yang adil di antara sekuens dengan panjang yang bervariasi.

Meskipun GSPO mendefinisikan rasio kebijakan pada level sekuens, GRPO beroperasi pada level token. Secara spesifik, GRPO menghitung rasio kepentingan untuk setiap token dalam sekuens: $$w_{i,t}(\theta) = \frac{\pi_\theta (o_{i,t} | q, o_{i,< t})}{\pi_{\theta_{\text{old}}} (o_{i,t} | q, o_{i,< t})}$$

Rasio tingkat token ini kemudian digabungkan dengan keuntungan bersama $\hat{A}_i$, dan tujuan GRPO memotong dan mengoptimalkan setiap token secara independen di sepanjang urutan.

Optimasi Kebijakan Rata-rata Geometris

📜 Makalah: https://huggingface.co/papers/2507.20673

Geometric-Mean Policy Optimization (GMPO) adalah varian GRPO yang memaksimalkan rata-rata geometris dari rasio kepentingan tingkat token, bukan rata-rata aritmetika. Rata-rata geometris jauh kurang sensitif terhadap rasio pencil, sehingga pembaruan kebijakan lebih stabil dan mentoleransi rentang pemotongan (clipping) yang jauh lebih lebar. Pemotongan diterapkan per token, dalam ruang log, dan satu sisi sesuai tanda keuntungan (trust region PPO standar) — yang krusial, hal ini dilakukan sebelum rata-rata geometris diambil. Inilah yang membedakan GMPO dari GSPO (importance_sampling_level="sequence"), yang memotong rasio tingkat sekuens setelah dirata-ratakan.

Objektif GMPO menggantikan rata-rata aritmetik per-token dari GRPO dengan rata-rata geometris dari rasio token (yang dipangkas): $$\mathcal{J}_{\text{GMPO}}(\theta) = \mathbb{E}_{q, \{o_i\}} \left[ \frac{1}{G} \sum_{i=1}^{G} \left( \prod_{t=1}^{|o_i|} \min\left[ w_{i,t}(\theta)^{\operatorname{sgn}(\hat{A}_i)},\ \operatorname{clip}\left(w_{i,t}(\theta)^{\operatorname{sgn}(\hat{A}_i)}, \epsilon_1, \epsilon_2\right) \right]^{\operatorname{sgn}(\hat{A}_i)} \right)^{\frac{1}{|o_i|}} \hat{A}_i \right]$$

di mana $w_{i,t}(\theta)$ adalah rasio kepentingan per-token. Dalam praktiknya, perkalian dan pemotongan dihitung dalam ruang log untuk stabilitas numerik, dan rentang pemotongan $(\epsilon_1, \epsilon_2) = (e^{-0.4}, e^{0.4})$ jauh lebih lebar daripada GRPO/DAPO untuk mendorong eksplorasi.

TRL menyediakan implementasi eksperimental, lihat Eksperimental - GMPO:

from trl.experimental.gmpo import GMPOConfig, GMPOTrainer

training_args = GMPOConfig(
    epsilon=0.4,  # log-space clip range -> ratios clipped to (exp(-0.4), exp(0.4)); paper, Sec. 4
    beta=0.0,
)

DAPO: Sistem Pembelajaran Penguatan LLM Sumber Terbuka dalam Skala

📜 Makalah: https://huggingface.co/papers/2503.14476

Algoritma DAPO mencakup 5 komponen utama:

• Filtering Berlebihan
• Clip-Higher
• Hukuman Lunak untuk Panjang Berlebihan
• Loss pada Tingkat Token
• Pengambilan Sampel Dinamis (⚠️ Tidak didukung di TRL)

Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import GRPOConfig, GRPOTrainer

training_args = GRPOConfig(
    # Overlong Filtering
    mask_truncated_completions=True,
    # Token-level Loss
    loss_type="dapo",
    # Clip-Higher
    epsilon_high=0.28, # DAPO paper: section 4.1
    epsilon=0.2, # DAPO paper: section 4.1
    # Other parameters used
    per_device_train_batch_size=512, # mini-batch size for training in the paper, DAPO paper: section 4.1
    num_generations=16, # number of sample responses in the paper, DAPO paper: section 4.1
    max_completion_length=20480, #  maximum number of tokens for generation in the paper, DAPO paper: section 4.1
    beta=0.0, # section 2.3, DAPO paper

)
# Soft Overlong Punishment
sop_reward = get_soft_overlong_punishment(max_completion_len=20480, soft_punish_cache=4096) # DAPO paper: section 4.1
trainer = GRPOTrainer(
    ...,
    args=training_args,
    reward_funcs=[..., sop_reward],
)

Mengungkap Misteri Penalaran Rantai Pikiran Panjang dalam LLM

📜 Makalah: https://huggingface.co/papers/2502.03373

Kertas ini mempelajari RL rantai-pemikiran panjang dan memperkenalkan dua aturan berbasis aturan yang saling melengkapi:

• reward berskala panjang kosinus (get_cosine_scaled_reward(), Lampiran C.1) yang menskalakan reward kebenaran berdasarkan panjang penyelesaian: penyelesaian yang benar mendapat reward lebih besar jika lebih pendek, sedangkan penyelesaian yang salah dikenai penalti lebih kecil jika lebih panjang (menjaga eksplorasi).
• Hukuman pengulangan n-gram (get_repetition_penalty_reward(), Lampiran C.2) yang mencegah penyelesaian yang degeneratif dan repetitif, yang muncul sebagai strategi reward-hacking di bawah length shaping.

Keduanya dirancang untuk digunakan bersama:

from trl import GRPOTrainer
from trl.rewards import get_cosine_scaled_reward, get_repetition_penalty_reward

# max_len should match the generation budget (in tokens)
cosine_scaled_reward = get_cosine_scaled_reward(max_len=4096)
# Penalize repeated 3-grams, down to -1.0 for fully repetitive completions
repetition_penalty = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0)
trainer = GRPOTrainer(
    ...,
    reward_funcs=[cosine_scaled_reward, repetition_penalty],
)

INTELLECT-2: Model Penalaran yang Dilatih Melalui Penguatan Belajar Terdesentralisasi Global

📜 Makalah: https://huggingface.co/papers/2505.07291

INTELLECT-2 adalah pelatihan penguatan belajar (reinforcement learning) yang didistribusikan secara global pertama kali untuk model bahasa dengan 32 miliar parameter, menggunakan RL asinkron penuh di atas kawanan (swarm) kontributor komputasi heterogen dan dinamis yang bersifat permissionless. Para penulis mengusulkan modifikasi pada resep pelatihan GRPO standar, termasuk pemotongan (clipping) GRPO dua sisi untuk meningkatkan stabilitas pelatihan. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import GRPOConfig

training_args = GRPOConfig(
    delta=4,  # δ in section 4.1 of the paper
    epsilon=0.2,  # ε in section 4.1 of the paper
    beta=0.001,  # KL divergence coefficient in section 4.1 of the paper
    num_generations=16,  # responses per prompt in section 4.1 of the paper
    learning_rate=3e-7,  # section 4.1 of the paper
)

Skywork-OR1: Model Penalaran Terbuka

📜 Makalah: https://huggingface.co/papers/2505.22312

Skywork-OR1 adalah keluarga model penalaran terbuka yang dilatih dengan GRPO. Kertas ini memperkenalkan kontrol entropi adaptif: istilah regularisasi entropi −α·H(π_θ) ditambahkan ke tujuan GRPO, dan koefisien α disesuaikan secara otomatis pada setiap langkah optimizer. Ketika entropi rata-rata per-token model turun ke atau di bawah target, α dinaikkan untuk mendorong lebih banyak eksplorasi; selain itu, nilainya diturunkan. Bonus hanya diterapkan selama entropi berada di atau di bawah target. Untuk mereplikasi kontrol entropi adaptif ini, gunakan konfigurasi berikut:

from trl import GRPOConfig, GRPOTrainer

training_args = GRPOConfig(
    use_adaptive_entropy=True,   # enable adaptive entropy control (Section 3.3 of the paper)
    entropy_coef=0.01,           # initial entropy regularization coefficient
    entropy_target=5.0,          # target mean per-token entropy (nats); tune for your model
    entropy_coef_delta=0.005,    # step size for coefficient updates per optimizer step
)
trainer = GRPOTrainer(
    ...,
    args=training_args,
)

Di Luar Aturan 80/20: Token Minoritas Entropi Tinggi Mendorong Penguatan Pembelajaran yang Efektif untuk Penalaran LLM

📜 Makalah: https://huggingface.co/papers/2506.01939

Sebagian kecil token dengan entropi tinggi berperan sebagai “percabangan” penalaran dalam jalur CoT, mendorong eksplorasi dan peningkatan kinerja untuk RLVR, sementara mayoritas token ber-entropi rendah memberikan kontribusi sedikit atau bahkan menghambat pembelajaran. RLVR terutama menyesuaikan token ber-entropi tinggi, sehingga secara besar-besaran mempertahankan pola entropi keseluruhan model dasar. Dengan demikian, sesuai aturan 80/20, pelatihan hanya pada 20% token dengan entropi tertinggi setara atau melampaui pembaruan gradien penuh untuk model Qwen3.

Hasil utama dari makalah ini menggunakan DAPO vanilla (⚠️ Dynamic Sampling tidak didukung di TRL). Untuk mereplikasi hasil utama, gunakan konfigurasi berikut:

from trl import GRPOConfig, GRPOTrainer
from trl.rewards import get_soft_overlong_punishment

training_args = GRPOConfig(
    # --- vanilla DAPO parameters (80/20 rule: section 5.2) --- #
    # Overlong Filtering
    mask_truncated_completions=True,
    # Token-level Loss
    loss_type="dapo",
    # Clip-Higher
    epsilon_high=0.28, # DAPO paper: section 4.1
    epsilon=0.2, # DAPO paper: section 4.1
    # Other parameters used
    per_device_train_batch_size=512, # mini-batch size for training in the paper, DAPO paper: section 4.1
    num_generations=16, # number of sample responses in the paper, DAPO paper: section 4.1
    max_completion_length=20480, #  maximum number of tokens for generation in the paper, DAPO paper: section 4.1
    beta=0.0, # section 2.3, DAPO paper
    # --- Gradients on the highest entropy tokens --- #
    top_entropy_quantile=0.2
)
# Soft Overlong Punishment
sop_reward = get_soft_overlong_punishment(max_completion_len=20480, soft_punish_cache=4096) # DAPO paper: section 4.1
trainer = GRPOTrainer(
    ...,
    args=training_args,
    reward_funcs=[..., sop_reward],
)

Dr. GRPO: Memahami Pelatihan Mirip R1-Zero: Perspektif Kritis

📜 Makalah: https://huggingface.co/papers/2503.20783

Sebuah studi tentang pelatihan R1-Zero mengidentifikasi efek pra-pelatihan terhadap kinerja RL dan menawarkan Dr. GRPO untuk meningkatkan efisiensi token, mencapai akurasi yang lebih unggul pada AIME 2024. Untuk mereproduksi pengaturan makalah tersebut, gunakan konfigurasi ini:

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="dr_grpo",
    per_device_train_batch_size=1, # train_batch_size_per_device in the Training section of the repository
    num_generations=8, #  num_samples in the Training section of the repository
    max_completion_length=3000, # generate_max_length in the Training section of the repository
    beta=0.0, # β in the Training section of the repository
)

Bagian I: Trik atau Jebakan? Pendalaman tentang RL untuk Penalaran LLM (Lite PPO)

📜 Makalah: https://huggingface.co/papers/2508.08221

Para penulis makalah ini menemukan bahwa kombinasi dari:

1. skala reward dengan deviasi standar yang dihitung di seluruh batch dan
2. mengagregasi loss atas total jumlah token

dapat membuka kemampuan pembelajaran kebijakan tanpa kritikus menggunakan kerugian PPO vanilla. Hasil mereka menunjukkan bahwa kombinasi sederhana ini secara konsisten meningkatkan kinerja, melampaui strategi seperti GRPO dan DAPO.

TRL mendukung penggunaan pembelajaran ini untuk melatih model GRPO dengan cara:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...
    scale_rewards="batch",
    loss_type="dapo",
    # Other parameters used
    beta=0.0,  # = init_kl_coef in the paper
    top_p=0.99,
    top_k=100,
    temperature=0.99,
    num_generations=8, # = num_return_sequences in the paper
    num_iterations=1,  # = ppo_epochs in the paper
    per_device_train_batch_size=4,
    gradient_accumulation_steps=32,
    steps_per_generation=8,  # (rollout_batch_size*num_return_sequences) / (per_device_train_batch_size*gradient_accumulation_steps)
)

Perhatikan bahwa saat menggunakan akumulasi gradien, loss diagregasikan berdasarkan total jumlah token dalam batch, tetapi tidak berdasarkan batch yang diakumulasi. Untuk detail lebih lanjut, lihat GRPO Trainer - Jenis loss.

Sampling Penting Terpotong

📰 Blog: https://fengyao.notion.site/off-policy-rl

📜 Makalah: https://huggingface.co/papers/1606.02647

Metode pembelajaran kebijakan online umumnya menggunakan kerangka inferensi yang dioptimalkan untuk generasi rollout (misalnya vLLM) yang terpisah dari backend pelatihan. Hal ini menimbulkan ketidakcocokan antara rollout dan pelatihan, yang ditunjukkan dalam tujuan PPO berikut: $$\small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }$$

Meskipun $\textcolor{red}{\pi_{\text{inference}}}$ dan $\textcolor{blue}{\pi_{\text{training}}}$ berbagi parameter model yang sama $\theta$, mereka dapat menghasilkan probabilitas token yang sangat berbeda. Perilaku tak terduga ini secara implisit melanggar asumsi on-policy, dan secara diam-diam mengubah pelatihan menjadi off-policy.

Truncated Importance Sampling (TIS) mengatasi masalah ini dengan menyesuaikan pembaruan model melalui koreksi importance-sampling. Perhitungan gradien dari tujuan PPO yang disebutkan sebelumnya menjadi $$\small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \underbrace{\text{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}{\textcolor{red}{\pi_{\text{inference}}}(a, \theta_{\mathrm{old}})}, C_{\min}, C_{\max}\bigr)}_{\text{truncated importance ratio}} \cdot \nabla_\theta \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }$$

di mana $C_{\min}$ dan $C_{\max}$ adalah hiperparameter. TIS diimplementasikan dalam GRPO, dan diaktifkan dengan memilih varian vllm_importance_sampling_mode yang mencakup istilah truncate, seperti "sequence_truncate" atau "token_truncate".

from trl import GRPOConfig

training_args = GRPOConfig(
    ...
    use_vllm=True,
    vllm_importance_sampling_correction=True, # default True
    vllm_importance_sampling_mode="sequence_truncate", # or "token_truncate"
    vllm_importance_sampling_clip_max=2.0, # hyper-parameter C_max
)

Sampling Penting Bermasker

📰 Blog: https://ringtech.notion.site/icepop

📜 Makalah: https://huggingface.co/papers/2510.18855

📰 Blog: https://yingru.notion.site/When-Speed-Kills-Stability-Demystifying-RL-Collapse-from-the-Training-Inference-Mismatch-271211a558b7808d8b12d403fd15edda

Masked Importance Sampling (MIS) mengatasi masalah yang sama dengan Truncated Importance Sampling namun mengganti clipping dengan masking. MIS mengambil sikap yang lebih tegas dengan membuang update yang selisihnya berada di luar rentang $[C_{\min}, C_{\max}]$.

$$\small{ \mathbb{E}_{a\sim\textcolor{red}{\pi_{\text{inference}}}(\theta_{\mathrm{old}})} \Bigl[ \underbrace{\mathbf{1}\left[ C_{\min} \le \frac{\pi_{\text{training}}(a, \theta_{\mathrm{old}})} {\pi_{\text{inference}}(a, \theta_{\mathrm{old}})} \le C_{\max} \right] \cdot \frac{\pi_{\text{training}}(a, \theta_{\mathrm{old}})} {\pi_{\text{inference}}(a, \theta_{\mathrm{old}})}}_{\text{masked importance ratio}} \cdot \nabla_\theta \min\Bigl( \frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})}\,\hat A, \;\mathrm{clip}\bigl(\frac{\textcolor{blue}{\pi_{\text{training}}}(a, \theta)}{\textcolor{blue}{\pi_{\text{training}}}(a, \theta_{\mathrm{old}})},\,1-\epsilon,\,1+\epsilon\bigr)\,\hat A \Bigr) \Bigr] }$$

MIS diimplementasikan untuk GRPO, dan diaktifkan dengan memilih varian vllm_importance_sampling_mode yang memuat istilah "mask", seperti "sequence_mask" atau "token_mask".

from trl import GRPOConfig

training_args = GRPOConfig(
    ...
    use_vllm=True,
    vllm_importance_sampling_correction=True, # default True
    vllm_importance_sampling_mode="sequence_mask", # or "token_mask"
    vllm_importance_sampling_clip_max=2.0, # hyper-parameter C_max
    vllm_importance_sampling_clip_min=0.5, # hyper-parameter C_min
)

Di dalam experimental.async_grpo.AsyncGRPOTrainer, log-probabilitas lama adalah milik sampler, sehingga rasio diambil langsung antara kebijakan yang dilatih dan sampler, serta token di luar $[C_{\min}, C_{\max}]$ dibuang dari loss. Fitur ini aktif secara default:

from trl.experimental.async_grpo import AsyncGRPOConfig

training_args = AsyncGRPOConfig(
    ...,
    vllm_importance_sampling_clip_min=0.5,  # hyper-parameter C_min
    vllm_importance_sampling_clip_max=5.0,  # hyper-parameter C_max
)

Sampling Penting pada Tingkat Urutan

📰 Blog: https://yingru.notion.site/When-Speed-Kills-Stability-Demystifying-RL-Collapse-from-the-Training-Inference-Mismatch-271211a558b7808d8b12d403fd15edda

Cara yang secara teoretis berprinsip untuk mengoreksi pergeseran distribusi antara pelatihan dan inferensi adalah importance sampling, sebagaimana diperkenalkan dalam dua paper di atas Truncated Importance Sampling dan Masked Importance Sampling. Namun, pemilihan formulasi sangat krusial untuk menjaga agar gradien tetap tidak bias dan memastikan pelatihan yang stabil.

Karya ini menunjukkan bahwa importance sampling tingkat urutan adalah pendekatan yang tepat untuk mengatasi ketidakcocokan antara pelatihan dan inferensi. Meskipun importance sampling tingkat token mencapai varians yang lebih rendah daripada rasio tingkat urutan, metode ini memperkenalkan bias dan oleh karena itu dianggap tidak cocok untuk model autoregresif. Estimasi gradien tingkat token adalah $$\mathbb{E}_{x\sim\mathcal{D},\, y\sim \pi^{\text{inference}}_\theta(\cdot|x)} \Bigg[ R(x,y)\,\cdot\, \sum_{t=0}^{|y|-1} \frac{\pi^{\text{training}}_\theta(y_t\,|\,x, y_{<t})} {\pi^{\text{inference}}_\theta(y_t\,|\,x, y_{<t})} \,\nabla_\theta \log \pi^{\text{training}}_\theta(y_t\,|\,x, y_{<t}) \Bigg]$$ Estimator gradien kebijakan yang benar dan tidak bias menerapkan satu rasio importance untuk seluruh urutan yang dihasilkan (trajektori) $y$, Estimator IS tingkat urutan terlihat seperti ini: $$\mathbb{E}_{x\sim\mathcal{D},\, y\sim \pi^{\text{inference}}_\theta(\cdot|x)} \Bigg[ \frac{\pi^{\text{training}}_\theta(y|x)} {\pi^{\text{inference}}_\theta(y|x)} \, R(x,y)\, \nabla_\theta \log \pi^{\text{training}}_\theta(y|x) \Bigg]$$

TRL mengekspos tingkat granularitas Importance Sampling melalui parameter konfigurasi vllm_importance_sampling_mode, di mana mode "sequence_*" mengimplementasikan rasio importance sampling tingkat sekuens dan "token_*" rasio per-token.

Seni Skala Penguatan Pembelajaran

📜 Makalah: https://huggingface.co/papers/2510.13786

Studi sistematis yang mendefinisikan kerangka kerja untuk menganalisis dan memprediksi penskalaan pembelajaran penguatan dalam model bahasa besar, mengidentifikasi pilihan desain utama yang memengaruhi efisiensi komputasi, dan mengusulkan resep praktik terbaik yang disebut ScaleRL.

Anda dapat mereproduksi sebagian resep ScaleRL menggunakan GRPOTrainer dengan konfigurasi berikut:

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="cispo",
    epsilon_high=5.0,
    num_generations=16,
    scale_rewards="batch",
    cast_lm_head_to_fp32=True
)

Butuh Dua: GRPO Anda Sebenarnya DPO

📜 Makalah: https://huggingface.co/papers/2510.00977

Menunjukkan bahwa efektivitas GRPO berasal dari tujuan kontrastif implisit, bukan dari estimasi keuntungan yang akurat melalui ukuran grup besar. Hal ini menetapkan hubungan formal antara GRPO dan DPO, di mana ukuran grup hanya memengaruhi estimator Monte Carlo dari tujuan kontrastif. Para penulis memperkenalkan 2-GRPO — yang hanya menggunakan dua rollout — yang menyamai kinerja 16-GRPO dengan biaya pelatihan yang jauh lebih rendah. Digunakan di TRL melalui GRPOTrainer dengan num_generations=2. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import GRPOConfig, GRPOTrainer

training_args = GRPOConfig(
    num_generations=2,  # minimal two-rollout case (2-GRPO) from the paper
    loss_type="grpo",
)
trainer = GRPOTrainer(
    ...,
    args=training_args,
)

Optimasi Kebijakan Adaptif Lunak

📜 Makalah: https://huggingface.co/papers/2511.20347

Soft Adaptive Policy Optimization (SAPO) menggantikan pemotongan keras (hard clipping) dengan gerbang halus yang dikendalikan suhu, yang secara adaptif meredam pembaruan off-policy sambil mempertahankan sinyal pembelajaran yang berguna. Dibandingkan dengan GSPO dan GRPO, SAPO bersifat koheren-sekuens dan adaptif-token. Seperti GSPO, SAPO mempertahankan koherensi pada tingkat sekuens, tetapi gerbang lunaknya membentuk wilayah kepercayaan (trust region) kontinu yang menghindari pita pemotongan keras yang rapuh yang digunakan dalam GSPO.

Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="sapo",
    sapo_temperature_pos=1.0,  # default value
    sapo_temperature_neg=1.05,  # default value
    scale_rewards="group",
    ...
)

DeepSeek-V3.2: Mendorong Batas Model Bahasa Besar Terbuka

📜 Makalah: https://huggingface.co/papers/2512.02556

Laporan teknis DeepSeek-V3.2 memperkenalkan beberapa teknik untuk meningkatkan kinerja GRPO. Di TRL kami mengimplementasikan:

• Perkiraan KL Tanpa Bias Unbiased KL Estimate, yang mengoreksi estimator K3 (seperti yang digunakan dalam implementasi GRPO asli) untuk mendapatkan perkiraan KL tanpa bias menggunakan rasio importance-sampling antara kebijakan saat ini $\pi_\theta$ dan kebijakan perilaku $\pi_{\text{old}}$. $$\mathrm{D}_{\mathrm{KL}}\!\left(\pi_\theta(o_{i,t}) \,\|\, \pi_{\text{ref}}(o_{i,t})\right) = \textcolor{red}{\frac{\pi_\theta(o_{i,t}\mid q, o_{i,<t})}{\pi_{\text{old}}(o_{i,t}\mid q, o_{i,<t})}} \left( \frac{\pi_{\text{ref}}(o_{i,t}\mid q, o_{i,<t})}{\pi_\theta(o_{i,t}\mid q, o_{i,<t})} - \log \frac{\pi_{\text{ref}}(o_{i,t}\mid q, o_{i,<t})}{\pi_\theta(o_{i,t}\mid q, o_{i,<t})} - 1 \right).$$

Fitur ini diaktifkan secara default (use_bias_correction_kl=True di GRPOConfig), sehingga Anda hanya perlu mengatur beta > 0:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    beta=0.001,  # the paper doesn't specify the value used, so we use the value from "DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning"
)

• Off-Policy Masking, yang menstabilkan pelatihan dengan mengabaikan urutan di mana kebijakan berkinerja buruk (keuntungan negatif) dan telah menyimpang secara signifikan dari kebijakan lama (divergensi KL tinggi).

Topeng biner off-policy $\textcolor{red}{M_{i,t}}$ didefinisikan sebagai: $$\textcolor{red}{M_{i,t}} = \begin{cases} 0 & \text{if } \hat{A}_{i,t} < 0 \quad \text{and} \quad \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \log \frac{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})}{\pi_\theta(o_{i,t} \mid q, o_{i,<t})} > \textcolor{blue}{\delta} \\ 1 & \text{otherwise} \end{cases}$$

Mask ini kemudian diterapkan pada loss GRPO sebagai berikut: $$\mathcal{L}_{\text{GRPO}}(\theta) = -\frac{1}{G} \sum_{i=1}^G \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \left[ \min \left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})} \hat{A}_{i,t}, \, \text{clip}\left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,< t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,< t})}, 1 - \epsilon, 1 + \epsilon \right) \hat{A}_{i,t} \right) \textcolor{red}{M_{i,t}} - \beta \mathbb{D}_{\text{KL}}\left[\pi_\theta \| \pi_{\text{ref}}\right] \right]$$

Untuk mengaktifkan fitur ini, gunakan off_policy_mask_threshold (yang sesuai dengan $\textcolor{blue}{\delta}$) di GRPOConfig:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    off_policy_mask_threshold=0.5,
)

Meskipun makalah tersebut tidak menentukan $\textcolor{blue}{\delta}$ nilai yang digunakan, titik awal yang baik bisa berupa $\textcolor{blue}{\delta} = 0.5$. Jika pelatihan terasa terlalu konservatif atau terlalu banyak urutan yang dimasker, Anda dapat meningkatkan nilainya. Sebagai referensi, $\textcolor{blue}{\delta} = 1.0$ berkorespondensi dengan divergensi rasio log rata-rata sebesar 1 nat per token, yaitu pada urutan di mana ambang batas ini dilampaui, kebijakan lama secara rata-rata $e^1 \approx 2.7$ kali lebih mungkin untuk menghasilkan token-token ini dibandingkan kebijakan saat ini.

• Strategi Keep Sampling Mask yang menjaga agar sampling top-k/top-p tetap tidak bias. Sampler menarik setiap token dari dukungan yang dipangkas $\textcolor{red}{\mathcal{S}_{i,t}}$, yaitu token yang tersisa setelah pemangkasan, sehingga log-probabilitas kebijakan dinormalisasi ulang di atas dukungan yang sama: $$\log \pi_\theta(o_{i,t} \mid q, o_{i,<t}) = z_{o_{i,t}} - \log \sum_{v \in \textcolor{red}{\mathcal{S}_{i,t}}} e^{z_v}.$$

Tanpa hal ini, rasio kepentingan menjadi bias rendah dan gradien terus mendorong massa probabilitas ke token yang tidak pernah diambil oleh sampler, yang menyebabkan pelatihan runtuh. Hal ini didukung di experimental.async_grpo.AsyncGRPOTrainer: dengan top_p < 1.0, top_k > 0 atau min_p > 0.0, worker rollout mencatat dukungan setiap token dari vLLM (>= 0.28, dimulai dengan --return-sampling-mask --enable-scale-out) dan trainer melakukan normalisasi ulang di atasnya:

from trl.experimental.async_grpo import AsyncGRPOConfig

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

Fitur ini juga didukung di GRPOTrainer dengan vLLM dalam mode colocate (>= 0.28): dengan top_k > 0 dan koreksi importance sampling diaktifkan (default), vLLM mengembalikan support untuk setiap token dan trainer melakukan normalisasi ulang di atasnya:

from trl import GRPOConfig

training_args = GRPOConfig(
    ...,
    use_vllm=True,
    top_p=0.95,
    top_k=512,
)

GDPO: Optimasi Kebijakan Normalisasi yang Dipisahkan Hadiah per Kelompok untuk Optimasi RL Multi-hadiah

📜 Makalah: https://huggingface.co/papers/2601.05242

GDPO adalah metode optimasi pembelajaran penguatan yang dirancang untuk pelatihan multi-reward. Meskipun pendekatan yang ada umumnya menerapkan Group Relative Policy Optimization (GRPO) dalam pengaturan multi-reward, para penulis menunjukkan bahwa hal ini menyebabkan kolapsnya keunggulan reward, yang mengurangi resolusi sinyal pelatihan dan menyebabkan konvergensi yang tidak stabil atau gagal. GDPO menyelesaikan masalah ini dengan memisahkan normalisasi reward di antara reward individual, sehingga mempertahankan perbedaan relatif mereka dan memungkinkan optimasi preferensi yang lebih akurat. Untuk memungkinkan GDPO untuk pelatihan RL multi-reward, cukup atur:

Untuk sekelompok $N$ reward dan $G$ sampel per kelompok, GDPO menormalisasi setiap reward secara independen: $$A_n^{(i,j)} = \frac{r_n^{(i,j)} - \text{mean}\{r_n^{(i,1)}, \ldots, r_n^{(i,G)}\}}{\text{std}\{r_n^{(i,1)}, \ldots, r_n^{(i,G)}\} + \epsilon}$$

Kemudian, keuntungan grup yang dinormalisasi diagregasikan di seluruh reward: $$A^{(i,j)} = \sum_{n=1}^{N} w_n A_n^{(i,j)}$$

Normalisasi per-batch akhir menghasilkan: $$\hat{A}^{(i,j)} = \frac{A^{(i,j)} - \text{mean}_{i',j'}\{A^{(i',j')}\}}{\text{std}_{i',j'}\{A^{(i',j')}\} + \epsilon}$$

Di sini, $\text{mean}_{i',j'}\{A^{(i',j')}\}$ dan $\text{std}_{i',j'}\{A^{(i',j')}\}$ menunjukkan statistik atas semua grup dalam batch.

from trl import GRPOConfig


training_args = GRPOConfig(
    ...,
    multi_objective_aggregation="normalize_then_sum",
)

Perhatikan bahwa metode ini hanya berdampak ketika pelatihan melibatkan lebih dari satu fungsi reward.

Para penulis menyediakan contoh pelatihan yang mudah digunakan dan bebas slurm yang memungkinkan komunitas untuk dengan cepat memvalidasi efektivitas GDPO dibandingkan GRPO, lihat Experiment-”Aha” moment.

Optimasi Kebijakan Urutan Tanpa Bias Panjang: Mengungkap dan Mengontrol Variasi Panjang Respons dalam RLVR

📜 Makalah: https://huggingface.co/papers/2602.05261

Length-Unbiased Sequence Policy Optimization (LUSPO) memodifikasi GSPO dengan menskalakan loss setiap urutan berdasarkan panjangnya. Hal ini mengoreksi bias gradien GSPO yang menghukum respons yang lebih panjang. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="luspo",
    importance_sampling_level="sequence",
    epsilon=2e-3, # section 5.1 of the paper
    epsilon_high=2.5e-3, # section 5.1 of the paper
)

VESPO: Optimasi Kebijakan Lunak Tingkat Urutan Variasional untuk Pelatihan LLM Off-Policy yang Stabil

📜 Makalah: https://huggingface.co/papers/2602.10693

VESPO mengatasi ketidakstabilan pelatihan dalam RL off-policy yang disebabkan oleh keusangan kebijakan, pembaruan asinkron, dan ketidakcocokan antara pelatihan dan inferensi. Alih-alih mengandalkan pemotongan level token heuristik (GRPO) atau normalisasi panjang urutan (GSPO), VESPO menurunkan kernel pembentukan ulang yang berprinsip dari kerangka variasional. Dalam praktiknya, ini menghasilkan fungsi penimbangan Gamma yang mulus dan asimetris, yang secara halus menekan bobot kepentingan level urutan yang ekstrem tanpa memperkenalkan bias panjang. $$\mathcal{L}_{\text{VESPO}}(\theta) = - \mathbb{E}_{\tau \sim \mu} \left[ \underbrace{W(\tau)^{k} \cdot \exp\left(\lambda (1 - W(\tau))\right)}_{\phi(W) \text{ detached }} \cdot \mathcal{A}(\tau) \cdot \log \pi_\theta(\tau) \right]$$

dengan $W(\tau) = \frac{\pi_\theta(\tau)}{\mu(\tau)}$ rasio kepentingan level sekuens, dan $\phi(W)$ dipisahkan dari graf komputasi untuk berfungsi sebagai koefisien penskalaan gradien.

from trl import GRPOConfig

training_args = GRPOConfig(
    loss_type="vespo",
    use_vllm=True,  # or False if not using any token-level `vllm_importance_sampling_correction` methods
    vllm_importance_sampling_mode="token_truncate",  # default correction mode for VESPO, `token_mask` also supported
    vespo_k_pos=2.0,  # power exponent (c1 in paper Section 3.4) for positive advantages
    vespo_lambda_pos=3.0,  # decay factor (c2 in paper Section 3.4) for positive advantages
    vespo_k_neg=3.0,  # power exponent (c1 in paper Section 3.4) for negative advantages
    vespo_lambda_neg=2.0,  # decay factor (c2 in paper Section 3.4) for negative advantages
)

Score Centering Menstabilkan Pembelajaran Penguatan Off-policy

📜 Makalah: https://huggingface.co/papers/2609.20807

Di bawah kondisi ketidakcocokan pelatihan-inferensi, skor $\nabla_\theta \log \pi_\theta$ tidak rata-rata menjadi nol di bawah sampler $\mu$, sehingga setiap pembaruan menggeser kebijakan menuju sampler, dengan jumlah yang meningkat seiring dengan keuntungan. Score centering mengurangi ekspektasi tersebut di setiap posisi, sehingga keuntungan konstan tidak lagi menggeser kebijakan: $$\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)},$$

dengan $f$ bobot kepentingan dari Masked Importance Sampling: $f(r) = r$ di dalam $[C_{\min}, C_{\max}]$ dan $0$ di luar. Ekspektasi internal diambil atas token yang paling mungkin dari sampler di setiap posisi, yang log-probabilitasnya dilaporkan; untuk sisa kosakata, sampler dianggap sebagai kebijakan terlatih yang diskalakan ulang ke massa yang tersisa.

Ini adalah tujuan default dari experimental.async_grpo.AsyncGRPOTrainer, di mana worker rollout-nya meminta log-probabilitas teratas dari setiap token yang dihasilkan dari vLLM:

from trl.experimental.async_grpo import AsyncGRPOConfig

training_args = AsyncGRPOConfig(
    ...,
    score_centering=True,  # default; `False` trains with the clipped objective instead
    vllm_importance_sampling_clip_min=0.5,  # hyper-parameter C_min
    vllm_importance_sampling_clip_max=5.0,  # hyper-parameter C_max
    num_sampler_logprobs=8,  # tokens per position the expectation is taken over
)

Regresi Keuntungan Optimal

Makalah yang berkaitan dengan experimental.a2po.A2POTrainer.

Meningkatkan Kecepatan RL untuk Penalaran LLM dengan Regresi Keuntungan Optimal

📜 Makalah: https://huggingface.co/papers/2505.20686

A*-PO (Optimal Advantage Regression) adalah metode RL dua tahap untuk penalaran LLM yang menghindari penggunaan critic online maupun rollout grup multi-sampel. Tahap 1 memperkirakan nilai optimal V*(x) = β·log E_{y∼π_ref}[exp(r(x, y)/β)] secara offline dari sampel kebijakan referensi; Tahap 2 melakukan pembaruan on-policy dengan satu generasi per prompt menggunakan kerugian regresi kuadrat-kesalahan (β·log(π(y|x)/π_ref(y|x)) − (r(x, y) − V*(x)))². Hal ini menghasilkan pelatihan yang lebih cepat dan memori puncak yang lebih rendah dibandingkan PPO/GRPO/REBEL. Metode ini mengasumsikan reward yang dapat diverifikasi secara biner dan tidak dapat melampaui Pass@K dari kebijakan referensi. Lihat A2PO. Kode resmi dapat ditemukan di ZhaolinGao/A-PO.

from trl.experimental.a2po import A2POConfig, A2POTrainer

# Hyperparameters from the paper (Qwen2.5, GSM8K/MATH)
training_args = A2POConfig(
    beta1=0.5,  # KL temperature for offline V* estimation
    beta2=1e-3,  # KL temperature for the on-policy regression target
    num_value_samples=8,  # N samples per prompt from the reference policy
)
trainer = A2POTrainer(
    model=...,
    reward_funcs=...,  # should return a binary reward in {0, 1}
    args=training_args,
    train_dataset=...,
)
trainer.train()

Optimasi Kebijakan Langsung

Makalah yang berkaitan dengan DPOTrainer

Direct Preference Optimization: Model Bahasa Anda Sebenarnya adalah Model Reward

📜 Makalah: https://huggingface.co/papers/2305.18290

Direct Preference Optimization (DPO) melakukan fine-tuning model bahasa secara lebih efisien dan dengan kinerja yang lebih baik dibandingkan reinforcement learning from human feedback (RLHF), dengan mengoptimalkan pelatihan kebijakan secara langsung berdasarkan preferensi manusia. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid", # losses in Appendix B of the paper
    per_device_train_batch_size=64, #  batch size in Appendix B of the paper
    learning_rate=1e-6, # learning rate in Appendix B of the paper
    beta=0.1, # β in Appendix B of the paper
)

SLiC-HF: Kalibrasi Kemungkinan Urutan dengan Umpan Balik Manusia

📜 Makalah: https://huggingface.co/papers/2305.10425

Sequence Likelihood Calibration (SLiC) terbukti menjadi alternatif yang efektif dan lebih sederhana daripada Reinforcement Learning from Human Feedback (RLHF) untuk belajar dari preferensi manusia pada model bahasa. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="hinge", # Section 2 of the paper
    per_device_train_batch_size=512, #  batch size in Section 3.2 of the paper
    learning_rate=1e-4, # learning rate in Section 3.2 of the paper
)

Parameter ini hanya muncul di versi yang dipublikasikan

Penolakan Sampel Statistik Meningkatkan Optimasi Preferensi

📜 Makalah: https://huggingface.co/papers/2309.06657

Mengusulkan RSO, untuk memilih pasangan preferensi yang lebih kuat melalui penolakan sampling statistik guna meningkatkan optimasi preferensi offline; melengkapi DPO/SLiC. Mereka juga memperkenalkan loss baru yang didefinisikan sebagai: $$\mathcal{L}_{\text{hinge-norm}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ \max\left(0,\; 1 - \left[\gamma \log \frac{\pi_\theta(y_w \mid x)}{\pi_\text{ref}(y_w \mid x)} - \gamma \log \frac{\pi_\theta(y_l \mid x)}{\pi_\text{ref}(y_l \mid x)}\right]\right) \right]$$

Untuk melatih dengan data yang difilter RSO dan kerugian hinge-norm, Anda dapat menggunakan kode berikut:

from trl import DPOConfig, DPOTrainer

dataset = ...

def rso_accept(example):  # replace with your actual filter/score logic
    return example["rso_keep"]

train_dataset = train_dataset.filter(rso_accept)

training_args = DPOConfig(
    loss_type="hinge",
    beta=0.05,  # correspond to γ in the paper
)

trainer = DPOTrainer(
    ...,
    args=training_args,
    train_dataset=train_dataset,
)
trainer.train()

Selain Reverse KL: Menggeneralisasi Direct Preference Optimization dengan Kendala Divergensi yang Beragam

📜 Makalah: https://huggingface.co/papers/2309.16240

Mengusulkan f-DPO, yang memperluas DPO dengan mengganti regularizer reverse-KL yang biasa dengan divergensi f umum, memungkinkan Anda menyeimbangkan perilaku mode-seeking vs mass-covering (misalnya forward KL, JS, divergensi α). Satu-satunya perubahan adalah mengganti margin log-ratio DPO dengan skor f′: $$\mathcal{L}_{f\text{-DPO}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ -\log \sigma\left( \beta \textcolor{red}{f'}\textcolor{red}{\Big(}\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)}\textcolor{red}{\Big)} - \beta \textcolor{red}{f'}\textcolor{red}{\Big(}\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\textcolor{red}{\Big)} \right) \right]$$

di mana $f'$ adalah turunan dari fungsi konveks yang mendefinisikan (( f \)-divergensi yang dipilih.

Untuk mereproduksi:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid",
    beta=0.1,
    f_divergence_type="js_divergence",  # or "reverse_kl" (default), "forward_kl", "js_divergence", "alpha_divergence"
    f_alpha_divergence_coef=0.5,  # only used if f_divergence_type="alpha_divergence"
)

Paradigma Teoritis Umum untuk Memahami Pembelajaran dari Preferensi Manusia

📜 Makalah: https://huggingface.co/papers/2310.12036

Belajar dari preferensi manusia dapat ditulis sebagai satu tujuan yang diregularisasi KL atas probabilitas preferensi pairwise, $$\max_\pi ;\mathbb{E}\big[\Psi\left(p^*(y \succ y' \mid x)\right)\big] - \tau\mathrm{KL}(\pi||\pi_{\text{ref}}),$$

yang mengungkapkan RLHF dan DPO sebagai kasus khusus yang sesuai dengan pilihan logit dari $\Psi$. Kertas ini menunjukkan bahwa transformasi logit ini memperkuat preferensi yang hampir deterministik dan secara efektif melemahkan regularisasi KL, sehingga menjelaskan overfitting. Dengan menggunakan Transformasi Identitas (IPO) menghindari patologi ini dengan mengoptimalkan preferensi secara langsung, tanpa mengasumsikan model reward Bradley–Terry. Untuk mereproduksi pengaturan dari kertas tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="ipo",  # Section 5.1 of the paper
    per_device_train_batch_size=90,  #  mini-batch size in Section C.1 of the paper
    learning_rate=1e-2,  # learning rate in Section C.1 of the paper
)

Parameter ini hanya muncul di versi yang dipublikasikan

Menuju Optimasi yang Efisien dan Tepat untuk Penyelarasan Model Bahasa

📜 Makalah: https://huggingface.co/papers/2402.00856

Paper ini menunjukkan bahwa metode preferensi langsung seperti DPO mengoptimalkan arah KL yang salah, yang menyebabkan penangkapan preferensi yang kabur, dan mengusulkan EXO sebagai cara yang efisien untuk mengoptimalkan secara tepat tujuan keselarasan preferensi manusia dengan memanfaatkan pencocokan probabilitas reverse KL alih-alih aproksimasi forward KL. Untuk mereproduksi pengaturan paper, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="exo_pair", # Section 3.2 of the paper
    # From Section B of the paper
    per_device_train_batch_size=64,
    learning_rate=1e-6,
    beta=0.1,
)

Penyelarasan Kontrasif Kebisingan Model Bahasa dengan Hadiah Eksplisit

📜 Makalah: https://huggingface.co/papers/2402.05369

Paper ini membingkai ulang penyesuaian model bahasa sebagai masalah klasifikasi kontrasif kebisingan, mengusulkan InfoNCA untuk mempelajari kebijakan dari imbalan eksplisit (atau preferensi) dengan mencocokkan distribusi target yang diinduksi imbalan di atas respons, dan menunjukkan bahwa DPO adalah kasus biner khusus. Paper ini kemudian memperkenalkan NCA, yang menambahkan istilah kemungkinan absolut untuk mencegah kolaps kemungkinan yang terlihat pada tujuan relatif (kontrasif) murni.

Dengan preferensi pairwise, perlakukan chosen/rejected$K=2$, definisi skor$r=\beta(\log\pi_\theta-\log\pi_{\text{ref}})$, dan terapkan loss preferensi NCA$-\log\sigma(r_w)-\tfrac12\log\sigma(-r_w)-\tfrac12\log\sigma(-r_l)$.

Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="nca_pair",
    # From Section C of the paper
    per_device_train_batch_size=32,
    learning_rate=5e-6,
    beta=0.01,
)

DPO yang Terbukti Robust: Menyelaraskan Model Bahasa dengan Umpan Balik Berisik

📜 Makalah: https://huggingface.co/papers/2403.00409

DPO gagal dengan preferensi manusia yang berisik karena pembalikan label membias tujuan. Robust DPO memperbaiki ini dengan mendebias secara analitis kerugian DPO di bawah model noise sederhana, dengan jaminan yang dapat dibuktikan. $$\mathcal{L}_{\text{robust}}(\pi_\theta) = \frac{(1-\varepsilon)\mathcal{L}_{\text{DPO}}(y_w, y_l) - \varepsilon\mathcal{L}_{\text{DPO}}(y_l, y_w)} {1-2\varepsilon}$$

Di mana $\mathcal{L}_{\text{DPO}}$ adalah loss DPO yang didefinisikan dalam Direct Preference Optimization: Your Language Model is Secretly a Reward Model dan $\varepsilon$ adalah probabilitas label flip.

Koreksi tunggal ini mengubah data preferensi yang berisik menjadi estimator tanpa bias dari tujuan DPO yang bersih.

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="robust",
    per_device_train_batch_size=16,  # batch size in Section B of the paper
    learning_rate=1e-3,  # learning rate in Section B of the paper
    beta=0.1,  # β in Section B of the paper,
    max_length=512,  # max length in Section B of the paper
    label_smoothing=0.1  # label smoothing {@html "$\varepsilon$"} in Section 6 of the paper
)

Optimasi Klasifikator Biner untuk Penyelarasan Model Bahasa Besar

📜 Makalah: https://huggingface.co/papers/2404.04656

Analisis teoretis dan algoritma baru, Binary Classifier Optimization, menjelaskan dan meningkatkan keselarasan model bahasa besar menggunakan sinyal umpan balik biner. Untuk mereproduksi pengaturan makalah, gunakan konfigurasi ini:

BCO membingkai ulang penyesuaian model bahasa sebagai kloning perilaku dari distribusi berbobot imbalan yang optimal, menghasilkan tujuan pengawasan sederhana yang menghindari RL sambil tetap berlandaskan teori. Ini mendukung data imbalan yang tidak berpasangan dan data preferensi berpasangan, dengan formulasi yang invarian terhadap pergeseran imbalan yang berkurang menjadi kerugian bergaya DPO dalam pengaturan preferensi.

Untuk pengaturan preferensi pairwise, loss BCO didefinisikan sebagai: $$\mathcal{L}_{\text{bco\_pair}}(\pi_\theta) = \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ -\log \sigma\Big( \beta[(\log\pi_\theta-\log\pi_{\text{ref}})(y_w) - (\log\pi_\theta-\log\pi_{\text{ref}})(y_l)] \Big) \right]$$

Untuk mereproduksi makalah dalam pengaturan ini, gunakan konfigurasi berikut:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="bco_pair",
    # From Section C of the paper
    per_device_train_batch_size=128,
    learning_rate=5e-7,
    beta=0.01,
)

Pelajari Model Referensi Anda untuk Perataan yang Benar-Benar Baik

📜 Makalah: https://huggingface.co/papers/2404.09656

Trust Region DPO (TR-DPO) memperbarui kebijakan referensi selama pelatihan, menunjukkan efektivitas terhadap DPO pada dataset Anthropic HH dan TLDR, melampaui DPO hingga 19% yang diukur dengan evaluasi otomatis menggunakan GPT-4, serta meningkatkan koherensi, kebenaran, tingkat detail, kegunaan, dan ketidaktertindakan. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    sync_ref_model=True,  # enable TR-DPO (Section 3 of the paper)
    ref_model_mixup_alpha=0.6,  # α soft update weight (Table 1 of the paper)
    ref_model_sync_steps=512,  # τ update frequency in steps (Table 1 of the paper)
    beta=0.05,  # β temperature (Table 1 of the paper)
    learning_rate=1e-6,  # learning rate (Table 2 of the paper)
    num_train_epochs=1,  # Table 2 of the paper
    max_length=1024,  # max tokens length (Table 2 of the paper)
    max_grad_norm=2,  # max gradient norm (Table 2 of the paper)
    warmup_steps=100,  # warm-up steps (Table 2 of the paper)
)

Optimasi Preferensi Penalaran Iteratif

📜 Makalah: https://huggingface.co/papers/2404.19733

Iterative RPO meningkatkan penalaran dengan secara berulang menghasilkan kandidat chain-of-thought, membangun pasangan preferensi dari jawaban yang benar dan salah, serta melatih dengan tujuan DPO + NLL. Istilah NLL tambahan merupakan kunci untuk belajar benar-benar menghasilkan jejak yang menang.

TRL dapat menyatakan tujuan DPO + NLL dengan mencampurkan "sigmoid" (DPO) dengan "sft" (NLL):

from trl import DPOConfig, DPOTrainer

training_args = DPOConfig(
    loss_type=["sigmoid", "sft"],
    loss_weights=[1.0, 1.0],  # alpha in the paper, recommended value is 1.0
)
trainer = DPOTrainer(
    ...,
    args=training_args,
)

Perhatikan bahwa makalah tersebut menggunakan loop iteratif: setiap iterasi menghasilkan ulang kandidat CoT dengan model saat ini, kemudian melatih ulang pada pasangan preferensi baru. TRL tidak mengotomatiskan loop tersebut untuk Anda.

Optimasi Preferensi Bermain Mandiri untuk Penyelarasan Model Bahasa

📜 Makalah: https://huggingface.co/papers/2405.00675

Metode self-play yang disebut SPPO untuk penyesuaian model bahasa mencapai kinerja state-of-the-art dengan mengaproksimasi kebijakan ekuilibrium Nash dalam pengaturan permainan jumlah konstan, melampaui pendekatan lain dengan data terbatas. Untuk mereproduksi pengaturan makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sppo_hard",
    # From Section 5 of the paper
    beta=0.001,  # β = η^−1
    per_device_train_batch_size=64,
    learning_rate=5e-7,
)

Mereduksi Overoptimization dalam RLHF Secara Terbukti: Loss SFT Anda Secara Implisit Merupakan Regularizer Adversarial

📜 Makalah: https://huggingface.co/papers/2405.16436

Regularized Preference Optimization (RPO) memitigasi overoptimization dalam RLHF dengan menggabungkan loss DPO dengan loss SFT, yang secara terbukti mencegah policy memilih aksi dengan proxy reward tinggi yang tidak valid. Untuk mereproduksi setting dari paper tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type=["sigmoid", "sft"],  # RPO loss = DPO + SFT (Section 5 of the paper)
    loss_weights=[1.0, 0.005],  # η=0.005 SFT weight in Appendix E.1 of the paper
    beta=0.01,  # β in Appendix E.1 of the paper
    learning_rate=5e-7,  # learning rate in Appendix E.1 of the paper
    num_train_epochs=1,  # Appendix E.1 of the paper
)

Penyelarasan Preferensi Distribusional LLM melalui Transportasi Optimal

📜 Makalah: https://huggingface.co/papers/2406.05882

Alignment via Optimal Transport (AOT) menyelaraskan model bahasa besar secara distribusional dengan menghukum pelanggaran dominasi stokastik antara distribusi sampel positif dan negatif, sehingga mencapai kinerja state-of-the-art pada benchmark penyelarasan. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="aot",
    beta=0.01,  # from the caption of Figure 2
)

atau, untuk versi tidak berpasangan:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="aot_unpaired",
    beta=0.01,  # from the caption of Figure 2
)

Tidak ada hiperparameter tambahan dalam makalah tersebut.

Menemukan Algoritma Optimasi Preferensi dengan dan untuk Model Bahasa Besar

📜 Makalah: https://huggingface.co/papers/2406.08414

Metode yang didorong oleh LLM secara otomatis menemukan algoritma optimasi preferensi yang performan, yang menghasilkan algoritma baru bernama DiscoPOP yang memadukan kerugian logistik dan eksponensial. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="discopop",
    per_device_train_batch_size=64,  # batch size in Section B.1 of the paper
    learning_rate=5e-7,  # learning rate in Section B.1 of the paper
    beta=0.05,  # β in Section B.1 of the paper,
    discopop_tau=0.05  # τ in Section E of the paper
)

WPO: Meningkatkan RLHF dengan Weighted Preference Optimization

📜 Makalah: https://huggingface.co/papers/2406.11827

WPO menimbang ulang pasangan preferensi berdasarkan probabilitas kebijakan untuk mengurangi celah off-policy dalam pelatihan gaya DPO. Loss-nya adalah: $$\mathcal{L}_{\text{WPO}} = -\mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} \left[ \textcolor{red}{w(x, y_w) w(x, y_l)} \log p(y_w \succ y_l \mid x) \right]$$

di mana bobot $w(x, y)$ didefinisikan sebagai: $$w(x, y) = \exp\left(\frac{1}{|y|}\sum_{t=1}^{|y|} \log \frac{\pi_\theta(y_t \mid x, y_{<t})}{\sum_{v \in \mathcal{V}} \pi_\theta(v \mid x, y_{<t})^2}\right)$$

Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid",  # DPO loss used in the paper
    beta=0.01,  # Section 4 of the paper
    use_weighting=True,
)

Optimasi Preferensi Berjangkar dan Revisi Kontras: Mengatasi Kurangnya Spesifikasi dalam Penyelarasan

📜 Makalah: https://huggingface.co/papers/2408.06266

CLAIR dan APO meningkatkan keselarasan LLM melalui pasangan preferensi kontras yang lebih banyak dan tujuan keselarasan yang terkendali, sehingga meningkatkan kinerja model mendekati GPT4-turbo. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="apo_zero",  # Section 4 of the paper
    per_device_train_batch_size=64,  # batch size in Section B.1 of the paper
    learning_rate=2e-7,  # learning rate in Section 5.2 of the paper
    beta=0.1,  # β in Section 5.2 of the paper,
)

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="apo_down",  # Section 4 of the paper
    per_device_train_batch_size=64,  # batch size in Section B.1 of the paper
    learning_rate=2e-7,  # learning rate in Section 5.2 of the paper
    beta=0.1,  # β in Section 5.2 of the paper,
)

Parameter ini hanya muncul di versi yang dipublikasikan

Desensitisasi Panjang dalam Optimasi Preferensi Langsung

📜 Makalah: https://huggingface.co/papers/2409.06411

Menunjukkan bahwa DPO standar secara inheren sensitif terhadap panjang, yang sering mendorong model ke arah generasi yang terlalu panjang atau bertele-tele. Kertas ini mengusulkan LD-DPO, yang memodifikasi agregasi log-probabilitas urutan dengan memecah respons yang lebih panjang menjadi prefiks bersama (hingga panjang respons yang lebih pendek) dan ekor berlebih, kemudian menurunkan bobot ekor tersebut dengan faktor $\alpha \in [0,1]$: $$\log \pi_\theta(y_{\text{long}}|x) = \log \pi_\theta(y_{1:l_p}|x) + \alpha \cdot \log \pi_\theta(y_{l_p+1:l}|x, y_{1:l_p}), \quad l_p=\min(|y_w|,|y_l|).$$

Pengaturan $\alpha=1$ mengembalikan DPO standar; nilai yang lebih kecil $\alpha$ mengurangi kecerewetan sambil mempertahankan kualitas preferensi. Nilai optimal $\alpha$ bergantung pada keluarga model dan apakah Anda melatih model base atau instruct, tetapi makalah tersebut menyarankan $\alpha=0.5$ sebagai titik awal default yang kuat.

from trl import DPOConfig

training_args = DPOConfig(
    ld_alpha=0.5,
)

Meningkatkan Kemampuan Penalaran Model Bahasa Besar Multimodal melalui Optimasi Preferensi Campuran

📜 Makalah: https://huggingface.co/papers/2411.10442

Memperkenalkan Mixed Preference Optimization (MPO) untuk meningkatkan penalaran multimodal pada MLLM, dengan mengatasi pergeseran distribusi dan Chain-of-Thought (CoT) yang lemah setelah pra-pelatihan standar dan SFT. Kontribusi makalah ini adalah (1) MMPR, sebuah pipeline otomatis untuk data preferensi multimodal berkualitas tinggi, dan (2) MPO, sebuah tujuan preferensi gabungan (pairwise + gaya BCO + SFT) yang meningkatkan CoT. InternVL2-8B-MPO mencapai skor 67.0 pada MathVista (+8.7 dibandingkan InternVL2-8B), yang sebanding dengan InternVL2-76B yang 10 kali lebih besar. Digunakan di TRL melalui DPOConfig dengan loss komposit. Untuk mereproduksi pengaturan makalah, gunakan konfigurasi ini:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type=["sigmoid", "bco_pair", "sft"],  # ℒ = w_p·ℒ_p + w_q·ℒ_q + w_g·ℒ_g (Section 3.2 of the paper)
    loss_weights=[0.8, 0.2, 1.0],  # w_p, w_q, w_g loss weights (Section 7 of the paper)
    learning_rate=5e-6,  # learning rate (Section 7 of the paper)
)

TÜLU 3: Mendorong Batas dalam Pelatihan Lanjutan Model Bahasa Terbuka

📜 Makalah: https://huggingface.co/papers/2411.15124

Loss sigmoid yang dinormalisasi berdasarkan panjang mengatasi bias panjang dalam DPO dengan membagi skor log-ratio yang dipilih dan ditolak oleh panjang penyelesaian masing-masing sebelum menghitung loss Bradley-Terry. Normalisasi per-token ini diperkenalkan dalam SimPO (Lampiran I “DPO w/ LN” ablation) sebagai reward log-probabilitas rata-rata untuk pengaturan tanpa referensi, dan kemudian diadopsi untuk DPO standar berbasis model referensi dalam resep post-training seperti Tülu 3 (Bagian 4.3). Loss-nya adalah: $$\mathcal{L}_{\text{sigmoid\_norm}} = -\log\sigma\!\left(\beta \left({\color{red}\frac{1}{|y_w|}}\log\frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - {\color{red}\frac{1}{|y_l|}}\log\frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\right)\right),$$ yang dapat diatur dengan:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid_norm",
)

Optimasi Kahneman–Tversky

Makalah yang berkaitan dengan KTOTrainer

KTO: Penyelarasan Model sebagai Optimasi Teori Prospek

📜 Makalah: https://huggingface.co/papers/2402.01306

KTO menurunkan tujuan keselarasan dari teori prospek dan belajar langsung dari umpan balik manusia biner (suka/tidak suka), menyamai atau melampaui metode bergaya DPO sambil menangani sinyal tidak seimbang/berisik dengan baik. Untuk mereproduksi pengaturan dari makalah tersebut, Anda dapat menggunakan konfigurasi bawaan dari KTOTrainer:

from trl import KTOConfig, KTOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(model_id)
tokenizer = AutoTokenizer.from_pretrained(model_id)

trainer = KTOTrainer(
    model=model,
    processing_class=tokenizer,
    args=KTOConfig(),
    train_dataset=...,
)
trainer.train()

Fine-Tuning Berpengawas

Makalah yang berkaitan dengan SFTTrainer

TailSFT: Fine-Tuning Terfilter Meningkatkan Kinerja Pelatihan Pasca

📜 Makalah: https://huggingface.co/papers/2608.25756

TailSFT mempertahankan cakupan respons untuk penguatan pembelajaran (reinforcement learning) berikutnya dengan menyaring urutan yang memiliki peningkatan loss yang dinormalisasi berdasarkan panjang paling besar relatif terhadap kebijakan awal. Contoh tail_sft_gsm8k mengimplementasikan penyaringan batch seleksi terdistribusi dari makalah tersebut dengan membuat subkelas dari SFTTrainer. Contoh ini mencatat loss kebijakan awal untuk setiap urutan sebelum pelatihan dan menyaring contoh secara independen di setiap batch seleksi.

python examples/tail_sft_gsm8k/tail_sft.py

EMA Tanpa Lag: Skema Rata-rata Iterasi yang Dikoreksi Bias

📜 Makalah: https://huggingface.co/papers/2508.00180

Bias-Corrected Exponential Moving Average (BEMA) meningkatkan stabilitas dan efisiensi fine-tuning model bahasa dengan mengurangi stochasticity dan menghilangkan bias. Untuk menggunakan BEMA dengan SFT seperti yang dijelaskan dalam paper, Anda dapat menggunakan BEMACallback:

from trl import BEMACallback, SFTTrainer

trainer = SFTTrainer(
    ...
    callbacks=[BEMACallback()],
)

Tentang Generalisasi SFT: Perspektif Pembelajaran Penguatan dengan Perbaikan Hadiah

📜 Makalah: https://huggingface.co/papers/2508.05629

Dynamic Fine-Tuning (DFT) meningkatkan generalisasi Large Language Models (LLM) dengan melakukan rescaling gradien secara dinamis, melampaui Supervised Fine-Tuning (SFT) standar, dan menunjukkan hasil yang kompetitif dalam reinforcement learning offline. $$\mathcal{L}_{\text{DFT}}(\theta) = \mathbb{E}_{(x,y) \sim \mathcal{D}} \left[ - \sum_{t=1}^{|y|} \textcolor{red}{\text{sg}\big(\pi_\theta(y_t \mid y_{<t}, x)\big)} \; \log \pi_\theta(y_t \mid y_{<t}, x) \right]$$

di mana $\text{sg}(\cdot)$ adalah operator stop-gradient. Untuk menggunakan DFT dengan SFT seperti yang dijelaskan dalam makalah, Anda dapat menggunakan argumen loss_type="dft" :

from trl import SFTConfig

training_args = SFTConfig(
    loss_type="dft",
    ...
)

Untuk mencocokkan secara ketat dengan pengaturan di makalah, Anda dapat menggunakan konfigurasi berikut (lihat Sek. 4.1). Para penulis juga menyebutkan bahwa hiperparameter tidak terlalu sensitif (Sek. 4.3):

SFTConfig(
    loss_type="dft",
    learning_rate=5e-5,
    max_length=2048,
    # Target batch size 256; achieved via per-device batch 8 * grad accumulation 32
    per_device_train_batch_size=8,
    gradient_accumulation_steps=32,
)

Lebih Sedikit Pemotongan Meningkatkan Pemodelan Bahasa

📜 Makalah: https://huggingface.co/papers/2404.10830

Paper tersebut menunjukkan bahwa prapemrosahan standar concatenate-then-split (packing_strategy="wrapped") yang digunakan untuk pelatihan LLM menyebabkan banyak dokumen dipotong secara sewenang-wenang, yang merugikan proses pembelajaran. Paper ini mengusulkan pengemasan potongan dokumen ke dalam jendela konteks menggunakan algoritma bin-packing Best-Fit Decreasing, yang sangat mengurangi pemotongan sambil mempertahankan pemanfaatan token yang tinggi dan meningkatkan kinerja model. TRL mengimplementasikan ini sebagai strategi pengemasan "bfd_split" di SFTConfig. Untuk detail lebih lanjut tentang pengemasan, lihat dokumentasi SFT.

from trl import SFTConfig

training_args = SFTConfig(
    packing=True,
    packing_strategy="bfd_split",
    max_length=4096,
)

Menjelajahi Batasan Transfer Learning dengan Transformer Teks-ke-Teks yang Terpadu

📜 Makalah: https://huggingface.co/papers/1910.10683

Paper T5 mengusulkan kerangka kerja teks-ke-teks terpadu untuk transfer learning dan memperkenalkan sequence packing (Bagian 3.5.2): pengelompokan beberapa urutan pendek menjadi blok berpanjang tetap untuk mengurangi padding dan meningkatkan efisiensi pelatihan. Packing didukung di TRL melalui SFTConfig dengan SFTTrainer. Untuk mengaktifkan packing dengan TRL, gunakan konfigurasi ini:

from trl import SFTConfig

training_args = SFTConfig(
    packing=True,  # enable sequence packing (Section 3.5.2 of the paper)
    max_length=512,  # packed sequence length (Section 3.5.2 of the paper)
)

Mereparameterisasi Model Difusi Seragam: Denoiser Leave-One-Out

📜 Makalah: https://huggingface.co/papers/2605.22765

Untuk model difusi diskrit seragam, cross-entropy plug-in yang biasa digunakan tidak mempelajari denoiser polos$\mathbb{E}[X_0 \mid X_t]$ melainkan posterior leave-one-out (LOO), yang memprediksi setiap token tanpa menggunakan nilai korupsinya sendiri. Kertas kerja ini menurunkan konversi eksak antara denoiser, posterior LOO, dan skor, sehingga jaringan dapat dilatih sebagai salah satu parameterisasi dengan cross-entropy yang sama. Diberikan logits$f_\theta$ yang softmax-nya memparameterisasi posterior LOO, denoiser yang digunakan dalam loss adalah $$d_\theta(x_t, t)^\ell = \mathrm{softmax}\!\left( f_\theta(x_t, t)^\ell + \log\!\left(1 + \frac{K\,\alpha_t}{1 - \alpha_t}\, x_t^\ell\right) \right),$$

yaitu koreksi aditif pada logit token yang diamati, di mana$K$ adalah ukuran kosakata dan$\alpha_t$ adalah probabilitas bahwa forward seragam mempertahankan token bersih. Kertas tersebut melaporkan bahwa parameterisasi LOO secara konsisten meningkatkan generasi. Contoh SFT block-diffusion examples/sft_diffusion_gemma/sft_diffusion_gemma.py mengungkap kedua parameterisasi melalui --model_prediction_type (mean untuk denoiser polos, sesuai dengan checkpoint yang dirilis, atau mean_loo untuk posterior LOO):

accelerate launch --config_file examples/accelerate_configs/deepspeed_zero3.yaml \
    examples/sft_diffusion_gemma/sft_diffusion_gemma.py \
    --use_peft \
    --gradient_checkpointing \
    --model_prediction_type mean_loo \
    --output_dir diffusiongemma-26B-A4B-it-gsm8k-lora

Mengurangi Perhitungan Ulang Aktivasi pada Model Transformer Besar

📜 Makalah: https://huggingface.co/papers/2205.05198

Full activation checkpointing menghitung ulang setiap op di area yang di-checkpoint selama backward, termasuk attention, meskipun hanya beberapa op (termasuk attention) yang menyumbang sebagian besar biaya komputasi ulang dibandingkan dengan memori yang akan dibutuhkan untuk menyimpannya. Metode selective activation recomputation dari paper tersebut hanya melakukan checkpointing pada op-op yang mahal tersebut, bukan seluruh area. TRL mengimplementasikan ini sebagai selective activation checkpointing (SAC) untuk SFTTrainer, dengan menyimpan output attention selama forward pass sehingga backward tidak perlu menghitungnya ulang:

from trl import SFTConfig

training_args = SFTConfig(
    gradient_checkpointing=True,
    gradient_checkpointing_kwargs={"selective": True},
)

Fine-Tuning yang Efisien Parameter (PEFT)

Untuk detail umum tentang penggunaan PEFT dengan TRL, silakan merujuk ke panduan Integrasi PEFT.

LoRA: Adaptasi Rank Rendah untuk Model Bahasa Besar

📜 Makalah: https://huggingface.co/papers/2106.09685

Low-Rank Adaptation (LoRA) mengurangi jumlah parameter yang dapat dilatih dan penggunaan memori GPU pada model pre-trained berskala besar, sambil mempertahankan atau meningkatkan kinerja pada tugas downstream. TRL mengintegrasikan LoRA melalui PEFT library dan dapat diaktifkan dengan mudah di trainer TRL mana pun dengan meneruskan LoraConfig ke argumen peft_config. Berikut adalah contoh penggunaan LoRA dengan SFTTrainer:

from trl import SFTTrainer
from peft import LoraConfig

trainer = SFTTrainer(
    ...,
    peft_config=LoraConfig(),
)

DoRA: Adaptasi Rank Rendah yang Terdekomposisi Bobot

📜 Makalah: https://huggingface.co/papers/2402.09353

Weight-Decomposed Low-Rank Adaptation (DoRA) dapat meningkatkan kinerja LoRA, terutama pada rank rendah. DoRA menguraikan bobot pre-trained menjadi dua komponen: magnitudo dan arah. Arah ditangani oleh LoRA normal, sedangkan magnitudo adalah parameter yang dapat dipelajari. TRL mengintegrasikan DoRA melalui PEFT library dan dapat diaktifkan dengan mudah melalui pengaturan use_dora=True pada LoraConfig.

from peft import LoraConfig

config = LoraConfig(use_dora=True, ...)

Reinforce Leave-One-Out

Makalah yang berkaitan dengan RLOOTrainer

Kembali ke Dasar: Meninjau Ulang Optimasi Gaya REINFORCE untuk Pembelajaran dari Umpan Balik Manusia pada LLM

📜 Makalah: https://huggingface.co/papers/2402.14740

RLOO adalah varian dari REINFORCE yang mengurangi varians dengan menggunakan baseline leave-one-out. Metode ini menghitung reward dengan membandingkan setiap sampel terhadap rata-rata dari semua sampel lain dalam batch, sehingga memberikan gradien yang lebih stabil daripada REINFORCE standar. Untuk mereproduksi pengaturan dari paper tersebut, gunakan konfigurasi ini:

from trl import RLOOConfig

training_args = RLOOConfig(
    per_device_train_batch_size=512,  # section C Training Detail of the paper
    steps_per_generation=2,  # section C Training Detail of the paper
    beta=0.03,  # section C Training Detail of the paper
    num_generations=2,  # experiments of paper different num_generations={2,4}
    learning_rate=1e-6,  # section C Training Detail of the paper
)

REINFORCE++: Pendekatan Sederhana dan Efisien untuk Menyelaraskan Model Bahasa Besar

📜 Makalah: https://huggingface.co/papers/2501.03262

REINFORCE++ adalah varian yang ditingkatkan dari algoritma REINFORCE klasik yang mengintegrasikan teknik optimasi utama dari PPO sambil menghilangkan kebutuhan akan jaringan kritikus. Algoritma ini mencapai kesederhanaan, stabilitas pelatihan yang lebih baik, dan pengurangan overhead komputasi melalui normalisasi keuntungan global di seluruh batch. Untuk mengaproksimasi pengaturan dari paper dengan RLOOTrainer, gunakan konfigurasi ini:

from trl import RLOOConfig

training_args = RLOOConfig(
    normalize_advantages=True,  # global advantage normalization, core of REINFORCE++
)

Optimasi Preferensi Rasio Peluang

Makalah yang berkaitan dengan experimental.orpo.ORPOTrainer

ORPO: Optimasi Preferensi Monolitik tanpa Model Referensi

📜 Makalah: https://huggingface.co/papers/2403.07691

Perkenalan algoritma optimasi preferensi rasio peluang monolitik tanpa model referensi (ORPO) meningkatkan keselarasan preferensi selama penyesuaian halus yang diawasi, melampaui model yang lebih besar dalam evaluasi utama. Untuk mereproduksi pengaturan makalah, gunakan konfigurasi ini:

from trl.experimental.orpo import ORPOConfig

training_args = ORPOConfig(
    beta=0.1,  # λ odds ratio loss weight (Table 7 of the paper, Mistral-ORPO-β)
    learning_rate=5e-6,  # learning rate (Appendix C of the paper)
    lr_scheduler_type="inverse_sqrt",  # scheduler (Appendix C of the paper)
    num_train_epochs=5,  # Appendix C of the paper
    warmup_steps=200,  # warm-up steps (Appendix C of the paper)
    per_device_train_batch_size=8,  # batch size (Appendix C of the paper)
)

Optimasi Preferensi Kontras

Makalah yang berkaitan dengan experimental.cpo.CPOTrainer

Optimasi Preferensi Kontrastif: Mendorong Batas Kinerja LLM dalam Penerjemahan Mesin

📜 Makalah: https://huggingface.co/papers/2401.08417

Memperkenalkan Contrastive Preference Optimization (CPO), sebuah metode berbasis preferensi untuk penerjemahan mesin yang melatih model untuk menghindari terjemahan yang memadai namun tidak sempurna, alih-alih meniru referensi seperti pada SFT. Kertas kerja ini menganalisis keterbatasan SFT pada MT (termasuk masalah kualitas referensi) dan menunjukkan bahwa penerapan CPO pada ALMA dengan hanya 22K kalimat paralel menghasilkan ALMA-R, yang menyamai atau melampaui pemenang kompetisi WMT dan GPT-4 pada WMT’21–WMT’23. Digunakan di TRL melalui experimental.cpo.CPOTrainer. Untuk mereproduksi pengaturan kertas kerja, gunakan konfigurasi ini:

from trl.experimental.cpo import CPOConfig

training_args = CPOConfig(
    loss_type="sigmoid",  # preference learning loss (Section 3 of the paper)
    cpo_alpha=1.0,  # NLL regularizer weight (Section 3 of the paper)
    beta=0.1,  # β temperature (Section 4.2 of the paper)
    learning_rate=1e-4,  # learning rate (official code)
    lr_scheduler_type="inverse_sqrt",  # scheduler (official code)
    num_train_epochs=1,  # Section 4.2 of the paper
    warmup_ratio=0.01,  # warm-up ratio (Section 4.2 of the paper)
    max_length=512,  # max sequence length (Section 4.2 of the paper)
)

SimPO: Optimasi Preferensi Sederhana dengan Hadiah Tanpa Referensi

📜 Makalah: https://huggingface.co/papers/2405.14734

SimPO adalah pendekatan optimasi preferensi yang lebih sederhana namun lebih efektif, yang menggunakan probabilitas log rata-rata dari sebuah urutan sebagai imbalan implisit, sehingga menghilangkan kebutuhan akan model referensi. Pendekatan ini memperkenalkan margin imbalan target ke dalam tujuan Bradley-Terry untuk mendorong margin yang lebih besar antara respons pemenang dan respons kalah. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl.experimental.cpo import CPOConfig

training_args = CPOConfig(
    loss_type="simpo",  # SimPO loss (Section 3 of the paper)
    cpo_alpha=0.0,  # no BC regularizer for SimPO
    beta=2.5,  # β in Appendix B of the paper
    simpo_gamma=1.375,  # γ target reward margin, from γ/β=0.55 in Appendix B of the paper
    learning_rate=1e-6,  # learning rate in Appendix B of the paper
    num_train_epochs=1,  # Appendix B of the paper
)

AlphaPO — Bentuk reward penting untuk keselarasan LLM

📜 Makalah: https://huggingface.co/papers/2501.03884

AlphaPO adalah metode Direct Alignment Algorithms (DAAs) baru yang memanfaatkan parameter alpha untuk membantu mengubah bentuk fungsi reward di luar log reward standar. AlphaPO membantu mempertahankan kontrol terperinci atas pergeseran likelihood dan over-optimization. Untuk mereproduksi pengaturan dari makalah tersebut, gunakan konfigurasi ini:

from trl.experimental.cpo import CPOConfig

# Mistral-Instruct from Table 3 of the paper
training_args = CPOConfig(
    loss_type="alphapo",
    alpha=0.25,
    beta=2.5,
    simpo_gamma=0.1,
    learning_rate=7e-7,
    ...
)

Triple Preference Optimization

Triple Preference Optimization: Mencapai Penyelarasan yang Lebih Baik dengan Optimasi Satu Langkah

📜 Makalah: https://huggingface.co/papers/2405.16681

Memperkenalkan Triple Preference Optimization (TPO), sebuah metode pembelajaran preferensi yang menyelaraskan LLM dengan tiga respons per prompt — penyelesaian emas (reference), penyelesaian yang disukai (chosen) dan penyelesaian yang tidak disukai (rejected) — dalam satu langkah optimasi. TPO menggabungkan tujuan kontras pada pasangan (chosen, rejected) dengan istilah NLL terawasi pada respons emas, sehingga menghilangkan kebutuhan akan tahap SFT terpisah dan model referensi yang digunakan dalam DPO. TRL menyediakan implementasi sebagai TPOTrainer hingga v1.16; fitur ini tidak lagi menjadi bagian dari pustaka dan tetap tersedia dalam riwayat git.

Nash Learning from Human Feedback

Nash Learning from Human Feedback

📜 Makalah: https://huggingface.co/papers/2312.00886

Memperkenalkan Nash-MD, alternatif dari RLHF standar yang mempelajari model preferensi yang dikondisikan pada dua input dan menemukan kebijakan pada ekuilibrium Nash. Alih-alih mengoptimalkan terhadap model reward, Nash-MD menghasilkan kebijakan yang secara konsisten menghasilkan respons yang lebih disukai dibandingkan respons dari kebijakan kompetitor mana pun. Algoritma ini didasarkan pada prinsip mirror descent. TRL menyediakan implementasi sebagai NashMDTrainer hingga v1.13; hal ini tidak lagi menjadi bagian dari pustaka dan tetap tersedia dalam riwayat git.

Pemodelan Reward

Makalah yang berkaitan dengan RewardTrainer

Membantu atau Menggiring? Ansambel Model Reward Meredam tetapi tidak Menghilangkan Reward Hacking

📜 Makalah: https://huggingface.co/papers/2312.09244

Kertas ini mengusulkan fungsi loss tambahan yang dirancang untuk mempelajari model reward terpusat secara langsung. Fungsi loss tambahan ini meminimalkan jumlah kuadrat dari reward, mendorong model untuk secara alami menghasilkan output dengan rata-rata nol, dan dengan demikian menyelesaikan masalah underdetermination. $$\mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \textcolor{red}{- \eta \cdot (r_\theta(x, y^+) + r_\theta(x, y^-))^2} \right].$$

Untuk menggunakan loss tambahan ini dengan RewardTrainer, Anda dapat menggunakan argumen center_rewards_coefficient di RewardConfig sebagai berikut:

from trl import RewardConfig

training_args = RewardConfig(
    center_rewards_coefficient=0.01,  # η in the paper
    ...
)

Llama 2: Model Fondasi Terbuka dan Model Obrolan yang Disesuaikan

📜 Makalah: https://huggingface.co/papers/2307.09288

Dalam makalah ini, para penulis mengusulkan untuk memanfaatkan penilaian preferensi mereka yang didekomposisi menjadi skala empat poin (misalnya, jauh lebih baik) untuk memberikan umpan balik yang lebih informatif ke model reward. Hal ini dilakukan dengan menambahkan margin ke fungsi loss, yang mendorong model reward untuk memberikan selisih skor yang lebih besar untuk pasangan dengan penilaian preferensi yang lebih tinggi. $$\mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-,\textcolor{red}{m}) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-) \textcolor{red}{- m}) \right].$$

Anda dapat menambahkan margin ke loss dengan menambahkan kolom margin ke dataset. Contoh berikut menunjukkan cara mengatur setting “Margin Small” dari paper tersebut.

def add_margin(example):
    preference_to_margin = {
        "significantly better": 1.0,
        "better": 2.0/3.0,
        "slightly better": 1.0/3.0,
        "negligibly better / unsure": 0.0,
    }
    return {"margin": preference_to_margin[example["preference_label"]]}

dataset = dataset.map(add_margin)

Optimasi Preferensi Langsung Online

Makalah yang berkaitan dengan experimental.online_dpo.OnlineDPOTrainer

Penyelarasan Model Bahasa Langsung dari Umpan Balik AI Online

📜 Makalah: https://huggingface.co/papers/2402.04792

Online DPO meningkatkan metode penyesuaian langsung dari preferensi dengan menyediakan umpan balik real-time dari model, sehingga melampaui metode DPO dan PPO.

Untuk menggunakan Online DPO, Anda dapat menggunakan experimental.online_dpo.OnlineDPOTrainer.

Optimasi Preferensi Eksploratif: Memanfaatkan Aproksimasi Q* Implisit untuk RLHF yang Efisien Sampel

📜 Makalah: https://huggingface.co/papers/2405.21046

XPO memperluas tujuan DPO dengan bonus eksplorasi yang baru dan berprinsip, sehingga memungkinkan algoritma untuk mengeksplorasi di luar dukungan model awal dan data umpan balik manusia. Ini adalah perubahan satu baris pada online DPO yang terbukti efisien dalam penggunaan sampel dan konvergen ke kebijakan model bahasa yang hampir optimal. TRL menyediakan implementasi sebagai XPOTrainer hingga v1.13; fitur ini tidak lagi menjadi bagian dari pustaka dan tetap tersedia dalam riwayat git.

Distilasi

Makalah yang berkaitan dengan pelatihan model siswa dengan bantuan model guru.

Distilasi On-Policy Model Bahasa: Belajar dari Kesalahan yang Dihasilkan Sendiri

📜 Makalah: https://huggingface.co/papers/2306.13649

Memperkenalkan Generalized Knowledge Distillation (GKD), yang mengatasi ketidakcocokan distribusi dalam KD untuk model auto-regresif dengan melatih student pada output yang dihasilkannya sendiri dengan umpan balik dari teacher, alih-alih menggunakan set sekuens yang tetap. GKD mendukung fungsi loss yang fleksibel (misalnya, di luar KL ketika student tidak dapat menyamai teacher) dan terintegrasi dengan fine-tuning RL (RLHF). Kertas kerja ini melaporkan hasil pada summarization, translation, penalaran aritmatika, dan instruction-tuning. Digunakan dalam TRL melalui experimental.gkd.GKDTrainer, yang mengekspos pencampuran on/off-policy dari kertas kerja (lmbda). DistillationTrainer mengimplementasikan tujuan generalized-JSD yang sama untuk kasus always-on-policy. Untuk mereproduksi pengaturan kertas kerja, gunakan konfigurasi ini:

from trl.experimental.gkd import GKDConfig

# XSum summarization task (Table A.1 of the paper)
training_args = GKDConfig(
    lmbda=0.5,  # λ student data fraction (Section 3 of the paper)
    beta=0.5,  # β Generalized JSD interpolation, 0=KL, 1=reverse KL (Section 3 of the paper)
    temperature=1.0,  # student training temperature (Appendix A of the paper)
    max_steps=40000,  # training steps (Table A.1 of the paper)
    learning_rate=3e-4,  # learning rate (Table A.1 of the paper)
    per_device_train_batch_size=32,  # batch size (Table A.1 of the paper)
    warmup_steps=2000,  # warm-up steps (Table A.1 of the paper)
    max_new_tokens=64,  # max output tokens (Table A.1 of the paper)
)

MOPD: Distilasi On-Policy Multi-Guru untuk Integrasi Kemampuan dalam Pelatihan Lanjutan LLM

📜 Makalah: https://huggingface.co/papers/2606.30406

Menyusun pascapelatihan menjadi tiga tahap: SFT umum, pelatihan RL per domain secara independen untuk satu ahli per domain (misalnya RL jawaban yang dapat diverifikasi untuk matematika, RL agen ber-sandbox untuk rekayasa perangkat lunak), dan tahap MOPD akhir yang melebur ahli domain yang dibekukan menjadi satu siswa terpadu. Pada tahap akhir tersebut, siswa menghasilkan satu trajektori per prompt, setiap trajektori dikirim ke guru domain yang sesuai (tidak pernah dirata-rata atau di-ensemble antar guru), dan siswa diperbarui dengan meminimalkan KL terbalik per token terhadap distribusi guru tunggal tersebut sepanjang trajektori. Digunakan di TRL melalui experimental.async_distillation.AsyncDistillationTrainer, yang mengimplementasikan tahap ketiga, yaitu peleburan: memasukkan lebih dari satu entri di teacher_server_urls mengaktifkan MOPD, dengan kolom teacher_id pada setiap baris memilih guru (yang sudah dilatih) mana yang memberikan skor. Gunakan beta=1.0 untuk sesuai dengan tujuan KL-terbalik pada makalah.

Tentang Bias Posisi pada Distilasi On-Policy

📜 Makalah: https://huggingface.co/papers/2606.22600

Memperkenalkan Importance-Weighted On-Policy Distillation (IW-OPD), yang mengatasi bias posisi dalam OPD dengan menimbang ulang pembaruan distilasi token yang disampelkan berdasarkan akumulasi perbedaan prefiks antara guru dan siswa. Token awal mempertahankan bobot yang lebih besar, sementara token akhir setelah drift tinggi diberi bobot lebih rendah. Digunakan di TRL melalui experimental.iw_opd.IWOPDTrainer dengan distillation_objective="iw_opd".

Paper ini mengoptimalkan IW-OPD dengan setup policy-gradient yang di-clipping (verl) dan rollout vLLM. IWOPDTrainer mengekspos pengaturan distilasi dan rollout yang sesuai di bawah ini; pengaturan optimasi kebijakan dari paper seperti rentang clipping 0.2, konstanta dual-clip 3.0, epoch PPO internal, koefisien entropi, penalti reward KL, KL tambahan, dan koreksi pentingnya rollout bukanlah parameter IWOPDConfig.

from trl.experimental.iw_opd import IWOPDConfig

# Table 6 and Algorithm 1 of the paper, mapped to IWOPDConfig where available.
training_args = IWOPDConfig(
    distillation_objective="iw_opd",
    iw_opd_gamma=0.5,  # γ amplification, Algorithm 1 and Appendix C.3
    lmbda=1.0,  # fully on-policy rollouts
    learning_rate=1e-5,  # Table 6
    per_device_train_batch_size=1,  # Table 6 uses PPO micro-batch size 1 per GPU
    gradient_accumulation_steps=32,  # with 32 GPUs, this gives the paper's 1024-prompt batch
    num_generations=1,  # Table 6 rollout samples per prompt
    temperature=1.0,  # Table 6 training decoding temperature
    top_p=1.0,  # Table 6 training decoding top-p
    max_prompt_length=2048,  # Table 6
    max_completion_length=16384,  # Table 6
    warmup_ratio=0.0,  # Table 6
    use_vllm=True,  # Table 6 uses vLLM rollouts
    vllm_sync_frequency=1,  # refresh rollout policy after each update
    save_steps=10,  # Table 6 checkpoint frequency
    eval_steps=10,  # Table 6 validation frequency
)

Distilasi On-Policy

📰 Blog: https://thinkingmachines.ai/blog/on-policy-distillation/

On-Policy Distillation melibatkan model siswa yang menghasilkan rollouts untuk setiap batch data pelatihan. Selanjutnya, kita memperoleh distribusi probabilitas untuk setiap token dari rollouts tersebut dari kedua model siswa dan guru. Model siswa kemudian dioptimalkan untuk meminimalkan divergensi Kullback-Leibler (KL) negatif antara distribusi tokennya sendiri dengan distribusi token model guru.

On-Policy Distillation telah terbukti melampaui SFT, GRPO, dan dapat digunakan untuk memulihkan kemampuan generalisasi yang hilang selama SFT.

Selain itu, distilasi on-policy lebih efisien dalam hal komputasi dan lebih tidak rentan terhadap overfitting ketika dilatih dengan data terbatas.

Untuk melatih model dengan distilasi on-policy menggunakan TRL, Anda dapat menggunakan konfigurasi berikut, dengan DistillationTrainer dan DistillationConfig:

from trl import DistillationConfig

training_args = DistillationConfig(
    beta=1.0,  # to ensure reverse-kl as the loss function
    teacher_model_name_or_path="teacher-model",  # specify the teacher model
)

Sebagai alternatif, Anda dapat menggunakan experimental.gkd.GKDTrainer dan experimental.gkd.GKDConfig:

from trl.experimental.gkd import GKDConfig

training_args = GKDConfig(
    lmbda=1.0,  # student produces rollouts for all batches
    beta=1.0,  # to ensure reverse-kl as the loss function
    teacher_model_name_or_path="teacher-model",  # specify the teacher model
)

Anda juga dapat menggunakan experimental.gold.GOLDTrainer untuk distilasi on-policy; lihat Unlocking On-Policy Distillation for Any Model Family.

Membuka Kunci Distilasi On-Policy untuk Setiap Keluarga Model

🌐 Proyek: https://huggingface.co/spaces/HuggingFaceH4/general-on-policy-logit-distillation

Memperkenalkan General Online Logit Distillation (GOLD), yang memperluas distilasi on-policy ke pasangan siswa/guru dengan tokenizer dan keluarga model yang berbeda. GOLD menyelaraskan rentang teks antar tokenizer dan dapat menerapkan Universal Logit Distillation (ULD) agar token penyelesaian tidak dihapus. Digunakan di TRL melalui experimental.gold.GOLDTrainer.

from trl.experimental.gold import GOLDConfig

training_args = GOLDConfig(
    lmbda=1.0,  # student produces rollouts for all batches
    beta=1.0,  # to ensure reverse-kl as the loss function
    use_uld_loss=True,  # Universal Logit Distillation for cross-tokenizer pairs
)

X-Token: Distilasi Pengetahuan Antar-Tokener yang Dipandu Proyeksi

📜 Makalah: https://huggingface.co/papers/2605.21699

X-Token memperluas kerangka distilasi GOLD ke pasangan siswa-guru yang tidak berbagi tokenizer. Ini adalah metode off-policy (lmbda=0): dataset menyediakan teks penyelesaian, baik siswa maupun guru menjalankan forward pass pada teks tersebut, dan kerugian KD lintas-tokenizer dihitung antara logits mereka. Tidak diperlukan rollout siswa on-policy. Matriks proyeksi sparse yang telah dihitung sebelumnya W ∈ ℝ^{V_s × V_t} memetakan setiap token siswa ke token guru yang paling mungkin sesuai, memproyeksikan distribusi siswa ke ruang kosakata guru sehingga keduanya dapat dibandingkan secara langsung. Digunakan di TRL melalui experimental.gold.GOLDTrainer dengan xtoken_loss_type="p_kl" atau "h_kl".

Dua formulasi loss disediakan:

Sama seperti pada implementasi referensi, H-KL memotong log-probabilitas seluruh kosakata ke himpunan bersama, dan P-KL merata-ratakan log-probabilitas guru di setiap span tanpa menormalisasi ulang, sehingga istilah KD dapat bernilai negatif. CE dan KD menggunakan jumlah token dan jumlah span yang selaras secara terpisah di setiap jendela akumulasi. Penyeimbangan dinamis CE/KD dan pemilihan top-k P-KL dihitung per microbatch.

Implementasi ini menggunakan matriks proyeksi yang dibekukan. Kertas kerja tersebut juga mempelajari matriks untuk P-KL secara bersama-sama; varian tersebut tidak diimplementasikan di sini.

Pertama, bangun matriks proyeksi dengan skrip persiapan di examples/xtoken/. Langkah 1 melakukan re-tokenisasi kosakata student dengan tokenizer teacher; flag opsional --runtime-top-k kemudian mengurutkan dan memangkas matriks dalam satu langkah (setara dengan menjalankan sort_and_cut_projection_matrix.py setelahnya):

python examples/xtoken/build_projection_matrix.py \
    --student-model meta-llama/Llama-3.2-1B-Instruct \
    --teacher-model Qwen/Qwen3-4B \
    --runtime-top-k 4 \
    --output-dir cross_tokenizer_data

Lalu latih dengan skrip contoh (off-policy, tidak memerlukan vLLM):

python examples/xtoken/xtoken.py \
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
    --teacher_model_name_or_path Qwen/Qwen3-4B \
    --dataset_name trl-lib/chatbot_arena_completions \
    --xtoken_loss_type p_kl \
    --xtoken_projection_matrix_path cross_tokenizer_data/projection_map_Llama-3.2_to_Qwen3_multitoken_top_32_double_special_top4.pt \
    --lmbda 0.0

atau langsung lewati jalur ke experimental.gold.GOLDConfig:

from trl.experimental.gold import GOLDConfig

config = GOLDConfig(
    lmbda=0.0,  # "off-policy knowledge distillation"
    xtoken_temperature=1.0,  # "temperature τ=1.0"
    xtoken_dynamic_scaling=True,  # Eq. (7): stop-gradient CE/KD balance
    xtoken_loss_type="p_kl",
    xtoken_projection_matrix_path="cross_tokenizer_data/projection_map_Llama-3.2_to_Qwen3_multitoken_top_32_double_special_top4.pt",
    teacher_tokenizer_name_or_path="Qwen/Qwen3-4B",
)

Pengetahuan Distilasi dari Model Bahasa Besar

📜 Makalah: https://huggingface.co/papers/2306.08543

MiniLLM adalah metode distilasi pengetahuan on-policy pertama, yang meminimalkan reverse KLD tingkat sekuens antara model guru dan model siswa, serta dioptimalkan dengan pembelajaran penguatan.

Ini adalah versi umum dari On-Policy Distillation dari Think Machine Lab, dengan opsi untuk menambahkan sinyal distilasi satu langkah tingkat distribusi (seperti GKD ketika beta=1) dan sinyal reverse KLD konteks panjang.

TRL menyediakan implementasi sebagai MiniLLMTrainer hingga v1.14; fitur ini tidak lagi menjadi bagian dari pustaka dan tetap tersedia dalam riwayat git.

Pembelajaran Penguatan melalui Distilasi Diri

📜 Makalah: https://huggingface.co/papers/2601.20802

Self-Distillation Policy Optimization (SDPO) meningkatkan reinforcement learning dengan reward yang dapat diverifikasi dengan mengubah umpan balik teks yang kaya (misalnya, error runtime, evaluasi judge) menjadi sinyal pembelajaran yang padat tanpa memerlukan guru eksternal atau model reward eksplisit. SDPO memperlakukan model saat ini yang dikondisikan pada umpan balik sebagai self-teacher dan mendistilkan prediksi next-token yang diinformasikan umpan balik tersebut kembali ke dalam policy. Secara khusus, SDPO juga melampaui baseline di lingkungan RLVR standar yang hanya mengembalikan umpan balik skalar dengan menggunakan rollout yang berhasil sebagai umpan balik implisit untuk percobaan yang gagal.

from trl.experimental.sdpo import SDPOConfig, SDPOTrainer

training_args = SDPOConfig(
    distillation_alpha=0.5,                # Jensen-Shannon divergence (recommended)
    distillation_mode="topk_logits",       # Explicitly select top-K logit distillation
    distillation_topk=100,                 # Required for top-K logit distillation
    distillation_is_clip=2.0,              # Importance sampling clipping
    distillation_weight=1.0,               # Convex weight: (1-w)*policy + w*distillation; 1.0 = pure distillation
    use_successful_as_teacher=True,        # Use successful rollouts as teacher
    teacher_model_kind="ema",              # Supported: "base", "live", "ema"
    teacher_update_rate=0.05,              # EMA update rate
    include_environment_feedback=True,     # required to use the dataset's privileged_context (defaults to False)
)

trainer = SDPOTrainer(
    model="Qwen/Qwen2.5-1.5B-Instruct",
    reward_funcs=...,
    args=training_args,
    train_dataset=...,
)
trainer.train()

Kolom dataset yang diharapkan:

• prompt
• privileged_context untuk umpan balik lingkungan opsional

Untuk detail lebih lanjut, lihat dokumentasi SDPO Trainer.

Self-Distillation Memungkinkan Pembelajaran Berkelanjutan

📜 Makalah: https://huggingface.co/papers/2601.19897

Self-Distilled Fine-Tuning (SDFT) melakukan self-distillation on-policy dengan menghasilkan kelengkapan (completions) selama pelatihan, kemudian mendistilkan pandangan eksplisit yang dikondisikan oleh guru (teacher) dari kelengkapan yang sama tersebut kembali ke siswa (student). Guru dipilih oleh teacher_model_kind: "base" (siswa awal), "live" (siswa saat ini), atau "ema" (guru yang dirata-rata secara eksponensial). Prompt guru disusun secara internal dari prompt siswa ditambah privileged_context dataset.

from datasets import Dataset

from trl.experimental.sdft import SDFTConfig, SDFTTrainer

dataset = Dataset.from_dict(
    {
        "prompt": [[{"role": "user", "content": "Solve 2+2."}]],
        "privileged_context": ["Example answer: 4."],
    }
)

training_args = SDFTConfig(
    distillation_alpha=0.5,
    distillation_mode="topk_logits",
    distillation_topk=5,
    max_completion_length=64,
)

trainer = SDFTTrainer(
    model="Qwen/Qwen2.5-1.5B-Instruct",
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

Kolom dataset yang diharapkan:

• prompt
• privileged_context yang hanya berisi informasi tambahan khusus guru

Untuk detail lebih lanjut, lihat dokumentasi SDFT Trainer.

Self-Distillation yang Sangat Sederhana Meningkatkan Generasi Kode

📜 Makalah: https://huggingface.co/papers/2604.01193

Simple Self-Distillation (SSD) meningkatkan generasi kode dengan mengambil sampel kelengkapan dari model pada suhu dan konfigurasi pemotongan saat pelatihan, kemudian melakukan penyesuaian halus pada sampel mentah yang belum diverifikasi tersebut menggunakan kerugian entropi silang standar. Tidak diperlukan model hadiah, penerus, model guru, atau pembelajaran penguatan. SSD membentuk distribusi token secara bergantung konteks: menekan ekor pengganggu pada posisi “lock” (di mana sintaksis menyisakan sedikit ambiguitas) sambil mempertahankan keragaman pada posisi “fork” (di mana beberapa kelanjutan valid ada).

TRL menyediakan implementasi sebagai SSDTrainer hingga v1.15; fitur ini tidak lagi menjadi bagian dari pustaka dan tetap tersedia dalam riwayat git.

Perbaikan untuk Softmax dan Cross-Entropy

📜 Makalah: https://huggingface.co/papers/2610.31642

Mengidentifikasi keruntuhan softmax pada prediksi dengan keyakinan tinggi dan pembatalan ketika logit siswa dan guru hampir sama. Kepala log-probabilitas berpotongan dan distilasi TRL menggunakan normalisasi yang mengecualikan target dan perbedaan probabilitas dalam ruang log untuk mempertahankan gradien kecil. Perbaikan numerik diterapkan secara otomatis, termasuk untuk KL maju, KL mundur, dan JSD umum dalam DistillationTrainer.

Lampiran B.4 dari Entropy-preserving reinforcement learning sebelumnya mengidentifikasi kegagalan policy-gradient pada tingkat kepercayaan tinggi dan mengusulkan untuk menghitung ulang gradien secara selektif dalam FP64. Kernel TRL mempertahankan gradien ini menggunakan rumus FP32 yang stabil.

Masalah terpisah terkait output-casting FSDP2 yang dibahas di Lampiran B.1 ditangani oleh Accelerate #4403. Versi Accelerate yang lebih lama memerlukan kebijakan presisi campuran dengan output_dtype=None untuk mempertahankan output kernel FP32.

Contoh berikut memetakan hiperparameter yang dilaporkan di Bagian 7 ke tujuan forward-KL dari TRL, yang berbagi gradien siswa dari cross-entropy target lunak. Hal ini mengilustrasikan distilasi model bahasa, bukan mereproduksi eksperimen aritmetika modular dari makalah tersebut. Makalah tersebut menginisialisasi siswa dengan bobot guru; hal ini harus ditangani saat membangun model, secara independen dari config. Nilai default trainer lainnya tetap tidak berubah.

from trl import DistillationConfig

training_args = DistillationConfig(
    beta=0.0,  # Forward KL has the same student gradient as soft-target cross-entropy.
    temperature=4.0,  # "distillation temperature T=4"
    learning_rate=2e-3,  # "eta=2 x 10^-3"
    lr_scheduler_type="constant",
    optim="adamw_torch",  # AdamW with zero weight decay has the same updates as Adam.
    weight_decay=0.0,  # "lambda=0"
    adam_epsilon=1e-8,  # "epsilon=10^-8"
    max_steps=2000,  # "2,000 steps of Adam"
)

Pelatihan Terdistribusi

ZeRO: Optimasi Memori Menuju Pelatihan Model dengan Parameter Triliunan

📜 Makalah: https://huggingface.co/papers/1910.02054

ZeRO (Zero Redundancy Optimizer) menghilangkan redundansi memori dalam pelatihan paralel data dan model dengan mempartisi status optimizer, gradien, dan parameter di antara perangkat, sambil mempertahankan volume komunikasi yang rendah dan granularitas komputasi yang tinggi. Hal ini memungkinkan pelatihan model besar secara efisien yang jika tidak akan tidak muat di memori GPU.

TRL mendukung ZeRO melalui integrasi DeepSpeed. Untuk menggunakannya, berikan file konfigurasi DeepSpeed dengan pengaturan yang Anda inginkan,

# config.yaml
distributed_type: DEEPSPEED
num_processes: 2
deepspeed_config:
  zero_stage: 3

dan jalankan skrip pelatihan menggunakan accelerate launch --config_file config_file.

accelerate launch --config_file config.yaml train.py