TRL documentation

Chỉ mục bài báo

TRL

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.17.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Chỉ mục bài báo

Mỗi bài báo bên dưới đều có liên kết đến trang bài báo Hugging Face tương ứng. Bạn cũng có thể đọc bất kỳ bài nào từ terminal bằng CLI hf, ví dụ hf papers read 2402.03300 — đặc biệt tiện lợi cho các coding agent.

Tối ưu hóa chính sách tương đối theo nhóm

Các bài báo liên quan đến GRPOTrainer.

DeepSeekMath: Đẩy giới hạn của khả năng suy luận toán học trong các mô hình ngôn ngữ mở

📜 Bài báo: https://huggingface.co/papers/2402.03300

Giới thiệu Group Relative Policy Optimization (GRPO) và cho thấy sự cải thiện mạnh mẽ trong khả năng suy luận toán học nhờ tiền huấn luyện tập trung vào toán học kết hợp với tối ưu hóa theo phong cách PPO dựa trên tương đối nhóm. Được sử dụng trong TRL thông qua 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: Khuyến khích khả năng suy luận trong LLM thông qua học tăng cường

📜 Bài báo: https://huggingface.co/papers/2501.12948

DeepSeek-R1 đạt hiệu năng suy luận tương đương với OpenAI-o1 thông qua một quy trình nhiều giai đoạn, chuyển đổi từ học tăng cường (RL) thuần túy sang một mô hình được tinh chỉnh và phù hợp với con người. Khác với người tiền nhiệm DeepSeek-R1-Zero, vốn sử dụng RL thuần túy trên một mô hình cơ sở, R1 tuân theo một quá trình tiến hóa có cấu trúc gồm bốn giai đoạn:

Cold Start: Mô hình cơ sở được tinh chỉnh trên một tập dữ liệu nhỏ gồm các chuỗi suy luận (Chain-of-Thought, CoT) dài và chất lượng cao để cung cấp một điểm khởi đầu ổn định.
RL hướng đến suy luận: RL quy mô lớn được áp dụng để nâng cao hiệu suất trong toán học, lập trình và logic, sử dụng phần thưởng dựa trên quy tắc và phần thưởng nhất quán ngôn ngữ để giảm thiểu sự pha trộn ngôn ngữ.
Rejection Sampling & SFT: Checkpoint RL tạo ra 600k mẫu suy luận thông qua rejection sampling, sau đó được kết hợp với 200k mẫu không suy luận (chung) để tạo thành một tập dữ liệu mới cho vòng Supervised Fine-Tuning thứ hai.
RL cho mọi Kịch bản: Giai đoạn RL cuối cùng điều chỉnh mô hình theo sở thích của con người (tính hữu ích và tính an toàn) trên tất cả các lĩnh vực trong khi vẫn duy trì khả năng suy luận.

Distillation: Trao quyền cho các mô hình nhỏ

Một đóng góp quan trọng của bài báo là chứng minh rằng các mẫu suy luận có thể được chưng cất từ một mô hình lớn (DeepSeek-R1) sang các mô hình dense nhỏ hơn (ví dụ: các dòng Qwen và Llama). Việc chưng cất được phát hiện là hiệu quả hơn đối với các mô hình nhỏ so với việc huấn luyện chúng bằng RL thuần túy từ đầu.

Bạn có thể sử dụng GRPOTrainer để tái hiện các giai đoạn nặng về suy luận của pipeline này.

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

Tối ưu hóa chính sách nhóm trình tự

📜 Bài báo: https://huggingface.co/papers/2507.18071

GSPO là một biến thể của GRPO, tính trọng số lấy mẫu quan trọng ở cấp độ chuỗi thay vì cho từng token. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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
)

Lưu ý rằng phương pháp này chỉ có tác dụng khi quá trình huấn luyện hơi lệch khỏi chính sách (off-policy) — ví dụ, khi steps_per_generation > gradient_accumulation_steps hoặc num_iterations > 1. Ngược lại, nó về cơ bản tương đương với việc không có sự thay đổi nào.

TRL đã phát hành một bản triển khai GSPO-token thử nghiệm cho đến v1.13; nó không còn là một phần của thư viện và vẫn có sẵn trong lịch sử git. Nó khác với mục tiêu cấp chuỗi ở trên chỉ khi lợi thế thay đổi theo $t$ , điều mà TRL hiện tại không tạo ra.

Tỷ lệ chính sách: GRPO so với GSPO

Trong GSPO, tỷ lệ chính sách được định nghĩa ở cấp độ chuỗi. Nói cách khác, đây là tỷ lệ giữa xác suất của chính sách hiện tại tạo ra một chuỗi so với xác suất của chính sách cũ tạo ra cùng chuỗi đó.

Khả năng xảy ra của chuỗi được định nghĩa là: $\pi_\theta (o_i | q) = \prod_{t=1}^{|o_i|} \pi_\theta (o_{i,t} | q, o_{i, < t} ),$

trong đó $\pi_\theta$ là chính sách $\pi$ với tham số $\theta$ , $o_i$ là $i$ -chuỗi đầu ra thứ $o$ và $o_{i,t}$ là $t$ -token thứ trong chuỗi này, $q$ là truy vấn đầu vào. Tỷ lệ khả năng của chuỗi $s_i (\theta)$ được định nghĩa như sau: $s_i (\theta) = \left(\frac{\pi_\theta (o_i | q)}{\pi_{\theta_{old}} (o_i | q)} \right)^{\frac{1}{|o_i|}}$

Số mũ $\frac{1}{|o_i|}$ đại diện cho một phép chuẩn hóa theo độ dài chuỗi, làm giảm ảnh hưởng của độ dài chuỗi trong khả năng xảy ra của chuỗi. Nói cách khác, nó tính trung bình nhân của xác suất các token, đảm bảo so sánh công bằng giữa các chuỗi có độ dài khác nhau.

Trong khi GSPO định nghĩa tỷ lệ chính sách ở cấp độ chuỗi, GRPO hoạt động ở cấp độ token. Cụ thể, GRPO tính toán một tỷ lệ quan trọng cho từng token trong chuỗi: $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})}$

Tỷ lệ ở cấp độ token này sau đó được kết hợp với một lợi thế chung $\hat{A}_i$ , và mục tiêu của GRPO sẽ cắt (clip) và tối ưu hóa từng token một cách độc lập trên toàn bộ chuỗi.

Tối ưu hóa chính sách trung bình hình học

📜 Bài báo: https://huggingface.co/papers/2507.20673

Geometric-Mean Policy Optimization (GMPO) là một biến thể của GRPO, tối đa hóa trung bình hình học của các tỷ lệ quan trọng ở cấp độ token thay vì trung bình số học. Trung bình hình học ít nhạy cảm hơn nhiều với các tỷ lệ ngoại lai, do đó việc cập nhật chính sách ổn định hơn và chấp nhận được phạm vi cắt (clipping) rộng hơn đáng kể. Cắt được áp dụng cho từng token, trong không gian log, và là một phía theo dấu của lợi thế (vùng tin cậy PPO tiêu chuẩn) — quan trọng là, trước khi lấy trung bình hình học. Đây là điểm phân biệt GMPO với GSPO (importance_sampling_level="sequence"), vốn cắt tỷ lệ ở cấp độ chuỗi sau khi đã lấy trung bình.

Mục tiêu GMPO thay thế trung bình cộng theo từng token của GRPO bằng trung bình nhân của các tỷ lệ token (đã cắt): $\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]$

trong đó $w_{i,t}(\theta)$ là tỷ lệ quan trọng trên mỗi token. Trong thực tế, phép nhân và cắt (clipping) được tính trong không gian log để đảm bảo ổn định số học, và khoảng cắt $(\epsilon_1, \epsilon_2) = (e^{-0.4}, e^{0.4})$ rộng hơn đáng kể so với GRPO/DAPO nhằm khuyến khích khám phá.

TRL cung cấp một bản triển khai thử nghiệm, xem Thử nghiệm - 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: Hệ thống học tăng cường cho LLM mã nguồn mở ở quy mô lớn

📜 Bài báo: https://huggingface.co/papers/2503.14476

Thuật toán DAPO bao gồm 5 thành phần chính:

Lọc quá dài
Clip-Higher
Phạt mềm cho câu quá dài
Mất ở cấp độ token
Lấy mẫu động (⚠️ Không được hỗ trợ trong TRL)

Để tái hiện cài đặt của bài báo, hãy sử dụng cấu hình này:

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

Giải mã suy luận chuỗi suy nghĩ dài trong LLM

📜 Bài báo: https://huggingface.co/papers/2502.03373

Bài báo này nghiên cứu RL chuỗi suy luận dài và giới thiệu hai phần thưởng dựa trên quy tắc bổ trợ cho nhau:

Một phần thưởng cosine có tỷ lệ theo độ dài (get_cosine_scaled_reward(), Phụ lục C.1) điều chỉnh phần thưởng độ chính xác theo độ dài của câu trả lời: một câu trả lời đúng sẽ được thưởng nhiều hơn khi ngắn hơn, trong khi một câu trả lời sai sẽ bị phạt ít hơn khi dài hơn (giữ lại khả năng khám phá).
Một phạt lặp n-gram (get_repetition_penalty_reward(), Phụ lục C.2) nhằm ngăn chặn các câu trả lời lặp lại, thoái hóa xuất hiện như một chiến lược khai thác phần thưởng dưới sự điều chỉnh độ dài.

Hai thành phần này được thiết kế để sử dụng cùng nhau:

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: Một mô hình suy luận được huấn luyện thông qua học tăng cường phi tập trung toàn cầu

📜 Bài báo: https://huggingface.co/papers/2505.07291

INTELLECT-2 là lần chạy huấn luyện tăng cường đầu tiên trên phạm vi toàn cầu cho một mô hình ngôn ngữ 32 tỷ tham số, sử dụng RL hoàn toàn bất đồng bộ trên một bầy đàn động, không đồng nhất của các nhà cung cấp máy tính không cần cấp phép. Các tác giả đề xuất các sửa đổi đối với công thức huấn luyện GRPO tiêu chuẩn, bao gồm cắt hai phía GRPO để tăng độ ổn định của quá trình huấn luyện. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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: Các mô hình suy luận mở

📜 Bài báo: https://huggingface.co/papers/2505.22312

Skywork-OR1 là một họ mô hình suy luận mở được huấn luyện bằng GRPO. Bài báo giới thiệu kiểm soát entropy thích ứng: một số hạng chuẩn hóa entropy −α·H(π_θ) được thêm vào mục tiêu GRPO, và hệ số α được điều chỉnh tự động ở mỗi bước tối ưu hóa. Khi entropy trung bình trên mỗi token của mô hình giảm xuống hoặc bằng ngưỡng mục tiêu, α sẽ được tăng lên để khuyến khích khám phá nhiều hơn; ngược lại, nó sẽ được giảm xuống. Phần thưởng chỉ được áp dụng trong khi entropy ở mức bằng hoặc thấp hơn ngưỡng mục tiêu. Để tái hiện cơ chế kiểm soát entropy thích ứng này, hãy sử dụng cấu hình sau:

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

Vượt ra ngoài Quy tắc 80/20: Các token thiểu số có entropy cao thúc đẩy học tăng cường hiệu quả cho suy luận của LLM

📜 Bài báo: https://huggingface.co/papers/2506.01939

Một thiểu số các token có entropy cao đóng vai trò như các “điểm rẽ” trong con đường suy luận CoT, thúc đẩy quá trình khám phá và cải thiện hiệu suất cho RLVR, trong khi phần lớn các token có entropy thấp đóng góp rất ít hoặc thậm chí cản trở việc học. RLVR chủ yếu điều chỉnh các token có entropy cao, phần lớn giữ nguyên các mẫu entropy tổng thể của mô hình cơ sở. Do đó, tuân theo quy tắc 80/20, huấn luyện chỉ trên 20% token có entropy cao nhất cho các mô hình Qwen3 có hiệu quả tương đương hoặc vượt trội so với cập nhật gradient đầy đủ.

Kết quả chính của bài báo sử dụng DAPO thuần (⚠️ Dynamic Sampling không được hỗ trợ trong TRL). Để tái tạo các kết quả chính, hãy sử dụng cấu hình sau:

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: Hiểu về huấn luyện kiểu R1-Zero: Góc nhìn phê phán

📜 Bài báo: https://huggingface.co/papers/2503.20783

Một nghiên cứu về quá trình huấn luyện R1-Zero đã xác định các tác động của tiền huấn luyện lên hiệu suất RL và đề xuất Dr. GRPO để tăng hiệu quả token, đạt độ chính xác vượt trội trên AIME 2024. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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
)

Phần I: Mẹo hay Bẫy? Phân tích sâu về RL cho suy luận LLM (Lite PPO)

📜 Bài báo: https://huggingface.co/papers/2508.08221

Các tác giả của bài báo này nhận thấy rằng sự kết hợp của:

thang phần thưởng theo độ lệch chuẩn được tính trên toàn bộ lô và
tổng hợp loss trên tổng số token

có thể khai thác khả năng học của các chính sách không có critic bằng cách sử dụng tổn thất PPO thông thường. Kết quả của họ cho thấy rằng sự kết hợp đơn giản này cải thiện hiệu suất một cách nhất quán, vượt qua các chiến lược như GRPO và DAPO.

TRL hỗ trợ sử dụng những kiến thức này để huấn luyện một mô hình GRPO bằng cách:

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

Lưu ý rằng khi sử dụng gradient accumulation, loss được tổng hợp trên tổng số token trong batch, nhưng không phải trên accumulated batch. Để biết thêm chi tiết, hãy xem GRPO Trainer - Loss types.

Mẫu hóa tầm quan trọng bị cắt

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

📜 Bài báo: https://huggingface.co/papers/1606.02647

Các phương pháp học chính sách trực tuyến thường sử dụng một khung suy luận được tối ưu hóa để tạo rollout (ví dụ: vLLM), tách biệt với backend huấn luyện. Điều này gây ra sự không khớp giữa rollout và huấn luyện, được minh họa trong mục tiêu PPO sau: $\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] }$

Mặc dù $\textcolor{red}{\pi_{\text{inference}}}$ và $\textcolor{blue}{\pi_{\text{training}}}$ chia sẻ cùng các tham số mô hình $\theta$ , chúng có thể tạo ra các xác suất token khác nhau đáng kể. Hành vi bất ngờ này ngầm phá vỡ giả định on-policy và âm thầm chuyển quá trình đào tạo sang off-policy.

Truncated Importance Sampling (TIS) giải quyết vấn đề này bằng cách điều chỉnh cập nhật mô hình thông qua hiệu chỉnh importance-sampling. Việc tính toán gradient của mục tiêu PPO nêu trên trở thành $\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] }$

trong đó $C_{\min}$ và $C_{\max}$ là các siêu tham số. TIS được triển khai trong GRPO và được bật bằng cách chọn một biến thể vllm_importance_sampling_mode bao gồm thuật ngữ truncate, chẳng hạn như "sequence_truncate" hoặc "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
)

Mẫu quan trọng có mặt nạ

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

📜 Bài báo: 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) giải quyết cùng một vấn đề như Truncated Importance Sampling nhưng thay thế việc cắt (clipping) bằng việc che (masking). MIS đưa ra lập trường quyết đoán hơn bằng cách loại bỏ các cập nhật có độ lệch nằm ngoài khoảng $[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 được triển khai cho GRPO và được bật bằng cách chọn một biến thể vllm_importance_sampling_mode có chứa từ "mask", chẳng hạn như "sequence_mask" hoặc "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
)

Trong experimental.async_grpo.AsyncGRPOTrainer, các log-probability cũ là của bộ lấy mẫu, do đó tỷ số được tính trực tiếp giữa chính sách được huấn luyện và bộ lấy mẫu, và các token nằm ngoài $[C_{\min}, C_{\max}]$ sẽ bị loại khỏi loss. Tính năng này được bật theo mặc định:

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
)

Mẫu quan trọng ở cấp độ chuỗi

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

Cách có nguyên tắc về mặt lý thuyết để hiệu chỉnh sự dịch chuyển phân phối giữa huấn luyện và suy luận là lấy mẫu quan trọng, như được giới thiệu trong hai bài báo ở trên Truncated Importance Sampling và Masked Importance Sampling. Tuy nhiên, việc lựa chọn công thức là rất quan trọng để giữ cho gradient không thiên lệch và đảm bảo huấn luyện ổn định.

Công trình này cho thấy lấy mẫu quan trọng ở cấp độ chuỗi là cách tiếp cận hợp lý để giải quyết sự không khớp giữa huấn luyện và suy luận. Mặc dù lấy mẫu quan trọng ở cấp độ token đạt phương sai thấp hơn so với tỷ lệ ở cấp độ chuỗi, nhưng nó gây ra thiên lệch và do đó được cho là không phù hợp với các mô hình tự hồi quy. Ước lượng gradient ở cấp độ token là $\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]$ Ước lượng gradient chính sách đúng, không thiên lệch áp dụng một tỷ lệ quan trọng duy nhất trên toàn bộ chuỗi (quỹ đạo) được tạo ra $y$ , Ước lượng IS ở cấp độ chuỗi trông như sau: $\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 cung cấp mức độ chi tiết của Importance Sampling thông qua tham số cấu hình vllm_importance_sampling_mode, trong đó các chế độ "sequence_*" triển khai tỷ lệ importance sampling ở cấp độ chuỗi và "token_*" triển khai tỷ lệ ở cấp độ từng token.

Nghệ thuật mở rộng Học tăng cường

📜 Bài báo: https://huggingface.co/papers/2510.13786

Một nghiên cứu có hệ thống xác định một khung phân tích và dự đoán việc mở rộng học tăng cường trong các mô hình ngôn ngữ lớn, xác định các lựa chọn thiết kế chính ảnh hưởng đến hiệu quả tính toán và đề xuất một công thức thực hành tốt nhất có tên là ScaleRL.

Bạn có thể tái tạo một phần công thức ScaleRL bằng cách sử dụng GRPOTrainer với các cấu hình sau:

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
)

Nhất cử lưỡng tiện: GRPO của bạn thực chất là DPO

📜 Bài báo: https://huggingface.co/papers/2510.00977

Cho thấy hiệu quả của GRPO bắt nguồn từ một mục tiêu tương phản ngầm định chứ không phải từ việc ước lượng lợi thế chính xác thông qua kích thước nhóm lớn. Điều này thiết lập một kết nối chính thức giữa GRPO và DPO, trong đó kích thước nhóm chỉ ảnh hưởng đến các ước lượng Monte Carlo của mục tiêu tương phản. Các tác giả giới thiệu 2-GRPO — chỉ sử dụng hai lần rollout — đạt hiệu suất tương đương với 16-GRPO với chi phí huấn luyện thấp hơn đáng kể. Được sử dụng trong TRL thông qua GRPOTrainer với num_generations=2. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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

Tối ưu hóa chính sách thích ứng mềm

📜 Bài báo: https://huggingface.co/papers/2511.20347

Soft Adaptive Policy Optimization (SAPO) thay thế việc cắt cứng (hard clipping) bằng một cổng (gate) mượt, được kiểm soát bởi nhiệt độ, có khả năng suy giảm thích ứng các cập nhật ngoài chính sách (off-policy) trong khi vẫn giữ lại các tín hiệu học tập hữu ích. So với GSPO và GRPO, SAPO vừa nhất quán ở cấp độ chuỗi (sequence-coherent) vừa thích ứng ở cấp độ token (token-adaptive). Giống như GSPO, SAPO duy trì tính nhất quán ở cấp độ chuỗi, nhưng cơ chế cổng mềm của nó tạo thành một vùng tin cậy (trust region) liên tục, tránh được dải cắt cứng (hard clipping band) dễ vỡ được sử dụng trong GSPO.

Để tái hiện cài đặt của bài báo, hãy sử dụng cấu hình này:

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: Đẩy mạnh ranh giới của các mô hình ngôn ngữ lớn mã nguồn mở

📜 Bài báo: https://huggingface.co/papers/2512.02556

Báo cáo kỹ thuật của DeepSeek-V3.2 giới thiệu một số kỹ thuật để nâng cao hiệu suất của GRPO. Trong TRL, chúng tôi triển khai:

Bộ ước lượng KL không thiên lệch, vốn hiệu chỉnh bộ ước lượng K3 (như được sử dụng trong cài đặt GRPO gốc) để thu được ước lượng KL không thiên lệch bằng cách sử dụng tỷ lệ lấy mẫu quan trọng giữa chính sách hiện tại $\pi_\theta$ và chính sách hành vi $\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).$

Tính năng này được bật theo mặc định (use_bias_correction_kl=True trong GRPOConfig), vì vậy bạn chỉ cần đặt 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, giúp ổn định quá trình huấn luyện bằng cách bỏ qua các chuỗi mà chính sách hoạt động kém (lợi thế âm) và đã lệch đáng kể so với chính sách cũ (độ phân kỳ KL cao).

Mặt nạ nhị phân off-policy $\textcolor{red}{M_{i,t}}$ được định nghĩa là: $\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}$

Mặt nạ này sau đó được áp dụng cho tổn thất GRPO như sau: $\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]$

Để bật tính năng này, hãy sử dụng off_policy_mask_threshold (tương ứng với $\textcolor{blue}{\delta}$ ) trong GRPOConfig:

from trl import GRPOConfig

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

Mặc dù bài báo không chỉ rõ giá trị $\textcolor{blue}{\delta}$ được sử dụng, một điểm khởi đầu tốt có thể là $\textcolor{blue}{\delta} = 0.5$ . Nếu quá trình huấn luyện có vẻ quá thận trọng hoặc quá nhiều chuỗi bị che, bạn có thể tăng giá trị này. Để tham khảo, $\textcolor{blue}{\delta} = 1.0$ tương ứng với độ phân kỳ log-ratio trung bình là 1 nat mỗi token, tức là trên các chuỗi vượt quá ngưỡng này, chính sách cũ có xác suất tạo ra các token này trung bình $e^1 \approx 2.7$ lần lớn hơn so với chính sách hiện tại.

Chiến lược Keep Sampling Mask , giúp giữ cho việc lấy mẫu top-k/top-p không bị thiên lệch. Bộ lấy mẫu rút mỗi token từ miền hỗ trợ bị cắt cụt $\textcolor{red}{\mathcal{S}_{i,t}}$ , các token còn lại sau khi cắt cụt, do đó log-probability của chính sách được chuẩn hóa lại trên cùng miền hỗ trợ đó: $\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}.$

Nếu không có nó, tỷ lệ quan trọng sẽ bị lệch thấp và gradient sẽ liên tục đẩy khối lượng xác suất vào các token mà trình lấy mẫu không bao giờ rút ra, khiến quá trình huấn luyện sụp đổ. Tính năng này được hỗ trợ trong experimental.async_grpo.AsyncGRPOTrainer: với top_p < 1.0, top_k > 0 hoặc min_p > 0.0, worker rollout sẽ ghi lại hỗ trợ của từng token từ vLLM (>= 0.28, bắt đầu với --return-sampling-mask --enable-scale-out) và trainer sẽ chuẩn hóa lại trên tập đó:

from trl.experimental.async_grpo import AsyncGRPOConfig

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

Tính năng này cũng được hỗ trợ trong GRPOTrainer với vLLM ở chế độ colocate (>= 0.28): với top_k > 0 và hiệu chỉnh lấy mẫu quan trọng được bật (mặc định), vLLM sẽ trả về tập hỗ trợ của từng token và trainer sẽ chuẩn hóa lại trên tập đó:

from trl import GRPOConfig

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

GDPO: Tối ưu hóa chính sách chuẩn hóa tách phần thưởng nhóm cho tối ưu hóa RL đa phần thưởng

📜 Bài báo: https://huggingface.co/papers/2601.05242

GDPO là một phương pháp tối ưu hóa học tăng cường được thiết kế cho huấn luyện đa phần thưởng. Trong khi các phương pháp hiện có thường áp dụng Group Relative Policy Optimization (GRPO) trong các cài đặt đa phần thưởng, các tác giả chỉ ra rằng điều này dẫn đến sự sụp đổ của lợi thế phần thưởng, làm giảm độ phân giải của tín hiệu huấn luyện và gây ra sự hội tụ không ổn định hoặc thất bại. GDPO giải quyết vấn đề này bằng cách tách rời việc chuẩn hóa phần thưởng giữa các phần thưởng riêng lẻ, giữ nguyên sự khác biệt tương đối của chúng và cho phép tối ưu hóa sở thích trung thực hơn. Để kích hoạt GDPO cho huấn luyện RL đa phần thưởng, chỉ cần đặt:

Đối với một nhóm gồm $N$ phần thưởng và $G$ mẫu mỗi nhóm, GDPO chuẩn hóa từng phần thưởng một cách độc lập: $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}$

Lợi thế nhóm đã chuẩn hóa sau đó được tổng hợp trên các phần thưởng: $A^{(i,j)} = \sum_{n=1}^{N} w_n A_n^{(i,j)}$

Chuẩn hóa theo từng batch cuối cùng tạo ra: $\hat{A}^{(i,j)} = \frac{A^{(i,j)} - \text{mean}_{i',j'}\{A^{(i',j')}\}}{\text{std}_{i',j'}\{A^{(i',j')}\} + \epsilon}$

Ở đây, $\text{mean}_{i',j'}\{A^{(i',j')}\}$ và $\text{std}_{i',j'}\{A^{(i',j')}\}$ ký hiệu cho các thống kê trên tất cả các nhóm trong batch.

from trl import GRPOConfig


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

Lưu ý rằng phương pháp này chỉ có tác dụng khi quá trình huấn luyện liên quan đến nhiều hơn một hàm phần thưởng.

Các tác giả cung cấp một ví dụ huấn luyện dễ sử dụng, không dùng slurm, cho phép cộng đồng nhanh chóng xác minh hiệu quả của GDPO so với GRPO, xem Thí nghiệm - khoảnh khắc “Aha”.

Tối ưu hóa chính sách trình tự không thiên vị về độ dài: Tiết lộ và kiểm soát sự biến thiên độ dài phản hồi trong RLVR

📜 Bài báo: https://huggingface.co/papers/2602.05261

Length-Unbiased Sequence Policy Optimization (LUSPO) điều chỉnh GSPO bằng cách nhân loss của mỗi chuỗi với độ dài của nó. Điều này khắc phục thiên lệch gradient của GSPO vốn trừng phạt các phản hồi dài hơn. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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: Tối ưu hóa chính sách mềm ở cấp độ chuỗi biến phân cho huấn luyện LLM ngoài chính sách ổn định

📜 Bài báo: https://huggingface.co/papers/2602.10693

VESPO giải quyết sự bất ổn trong huấn luyện RL off-policy do sự lỗi thời của chính sách, các bản cập nhật bất đồng bộ và sự không khớp giữa huấn luyện và suy luận. Thay vì dựa vào việc cắt xén heuristic ở cấp độ token (GRPO) hoặc chuẩn hóa theo độ dài chuỗi (GSPO), VESPO suy ra một nhân biến đổi có nguyên tắc từ một khung biến phân. Trên thực tế, điều này tạo ra một hàm trọng số Gamma trơn, bất đối xứng, giúp kìm hãm một cách tinh tế các trọng số quan trọng ở cấp độ chuỗi cực đoan mà không gây ra thiên kiến về độ dài. $\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]$

với $W(\tau) = \frac{\pi_\theta(\tau)}{\mu(\tau)}$ là tỷ lệ quan trọng ở cấp độ chuỗi, và $\phi(W)$ được tách khỏi đồ thị tính toán để đóng vai trò là hệ số tỷ lệ gradient.

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 ổn định Học tăng cường Off-policy

📜 Bài báo: https://huggingface.co/papers/2609.20807

Dưới sự lệch giữa huấn luyện và suy luận, điểm $\nabla_\theta \log \pi_\theta$ không có trung bình bằng không dưới bộ lấy mẫu $\mu$ , nên mỗi lần cập nhật đều làm lệch chính sách về phía bộ lấy mẫu, với mức độ tăng theo lợi thế. Score centering trừ kỳ vọng đó tại mỗi vị trí, nên một lợi thế hằng không còn làm thay đổi chính sách nữa: $\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)},$

với $f$ trọng số quan trọng của Masked Importance Sampling: $f(r) = r$ bên trong $[C_{\min}, C_{\max}]$ và $0$ bên ngoài. Kỳ vọng bên trong được lấy trên các token có khả năng cao nhất của bộ lấy mẫu tại mỗi vị trí, với các log-probability mà nó báo cáo; trên phần còn lại của bảng từ vựng, bộ lấy mẫu được coi là chính sách đã được huấn luyện và được điều chỉnh lại theo khối lượng còn lại.

Đây là mục tiêu mặc định của experimental.async_grpo.AsyncGRPOTrainer, trong đó worker rollout yêu cầu các log-probabilities hàng đầu của mọi token được tạo ra từ 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
)

Quy hồi Lợi thế Tối ưu

Các bài báo liên quan đến experimental.a2po.A2POTrainer.

Tăng tốc RL cho suy luận LLM bằng hồi quy lợi thế tối ưu

📜 Bài báo: https://huggingface.co/papers/2505.20686

A*-PO (Optimal Advantage Regression) là phương pháp RL hai giai đoạn cho suy luận LLM, giúp tránh cả việc sử dụng critic trực tuyến lẫn các lượt rollout nhóm đa mẫu. Giai đoạn 1 ước lượng giá trị tối ưu V*(x) = β·log E_{y∼π_ref}[exp(r(x, y)/β)] ngoại tuyến từ các mẫu của chính sách tham chiếu; Giai đoạn 2 thực hiện cập nhật on-policy với một lần sinh duy nhất cho mỗi prompt, sử dụng tổn thất hồi quy sai số bình phương (β·log(π(y|x)/π_ref(y|x)) − (r(x, y) − V*(x)))². Phương pháp này cho phép huấn luyện nhanh hơn và bộ nhớ đỉnh thấp hơn so với PPO/GRPO/REBEL. Phương pháp này giả định phần thưởng nhị phân có thể kiểm chứng và không thể vượt quá Pass@K của chính sách tham chiếu. Xem A2PO. Mã nguồn chính thức có thể tìm thấy tại 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()

Tối ưu hóa chính sách trực tiếp

Các bài báo liên quan đến DPOTrainer

Tối ưu hóa sở thích trực tiếp: Mô hình ngôn ngữ của bạn thực chất là một mô hình phần thưởng

📜 Bài báo: https://huggingface.co/papers/2305.18290

Tối ưu hóa sở thích trực tiếp (DPO) tinh chỉnh các mô hình ngôn ngữ hiệu quả hơn và cho hiệu suất tốt hơn so với học tăng cường từ phản hồi của con người (RLHF), bằng cách trực tiếp tối ưu hóa việc huấn luyện chính sách dựa trên sở thích của con người. Để tái tạo lại cài đặt của bài báo, hãy sử dụng cấu hình này:

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: Hiệu chuẩn khả năng xảy ra của chuỗi với phản hồi từ con người

📜 Bài báo: https://huggingface.co/papers/2305.10425

Sequence Likelihood Calibration (SLiC) được chứng minh là một phương án thay thế hiệu quả và đơn giản hơn cho Reinforcement Learning from Human Feedback (RLHF) trong việc học từ sở thích của con người trong các mô hình ngôn ngữ. Để tái tạo lại cài đặt của bài báo, hãy sử dụng cấu hình này:

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
)

Các tham số này chỉ xuất hiện trong bản đã công bố

Mẫu từ chối thống kê cải thiện tối ưu hóa sở thích

📜 Bài báo: https://huggingface.co/papers/2309.06657

Đề xuất RSO, chọn các cặp sở thích mạnh hơn thông qua lấy mẫu từ chối thống kê để tăng cường tối ưu hóa sở thích ngoại tuyến; bổ sung cho DPO/SLiC. Họ cũng giới thiệu một hàm mất mát mới được định nghĩa là: $\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]$

Để huấn luyện với dữ liệu đã lọc RSO và hàm mất mát hinge-norm, bạn có thể sử dụng mã sau:

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

Vượt ra ngoài Reverse KL: Tổng quát hóa Tối ưu hóa Sở thích Trực tiếp với các Ràng buộc Phân kỳ Đa dạng

📜 Bài báo: https://huggingface.co/papers/2309.16240

Đề xuất f-DPO, mở rộng DPO bằng cách thay thế bộ điều hòa reverse-KL thông thường bằng một f-divergence tổng quát, cho phép bạn đánh đổi giữa hành vi mode-seeking và mass-covering (ví dụ: forward KL, JS, α-divergences). Thay đổi duy nhất là thay thế biên độ log-ratio của DPO bằng một điểm 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]$

Trong đó $f'$ là đạo hàm của hàm lồi định nghĩa (( f \)-divergence đã chọn.

Để tái hiện:

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

Một khuôn mẫu lý thuyết tổng quát để hiểu về việc học từ sở thích của con người

📜 Bài báo: https://huggingface.co/papers/2310.12036

Học từ sở thích của con người có thể được viết dưới dạng một mục tiêu KL-regularized duy nhất trên các xác suất sở thích theo cặp, $\max_\pi ;\mathbb{E}\big[\Psi\left(p^*(y \succ y' \mid x)\right)\big] - \tau\mathrm{KL}(\pi||\pi_{\text{ref}}),$

trong đó RLHF và DPO được xem là các trường hợp đặc biệt tương ứng với việc chọn logit của $\Psi$ . Bài báo chỉ ra rằng phép biến đổi logit này khuếch đại các sở thích gần như tất định và làm suy yếu hiệu quả của việc chuẩn hóa KL, giải thích hiện tượng overfitting. Sử dụng phép biến đổi Identity (IPO) tránh được vấn đề này bằng cách tối ưu trực tiếp các sở thích, mà không giả định mô hình phần thưởng Bradley–Terry. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình sau:

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
)

Các tham số này chỉ xuất hiện trong bản đã công bố

Hướng tới Tối ưu hóa Hiệu quả và Chính xác cho Việc Cân bằng Mô hình Ngôn ngữ

📜 Bài báo: https://huggingface.co/papers/2402.00856

Bài báo chỉ ra rằng các phương pháp ưu tiên trực tiếp như DPO tối ưu sai hướng KL, dẫn đến việc nắm bắt ưu tiên bị mờ nhạt, và đề xuất EXO như một cách hiệu quả để tối ưu chính xác mục tiêu căn chỉnh ưu tiên của con người bằng cách tận dụng khớp xác suất reverse KL thay vì các xấp xỉ forward KL. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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

Căn chỉnh tương phản nhiễu của các mô hình ngôn ngữ với phần thưởng rõ ràng

📜 Bài báo: https://huggingface.co/papers/2402.05369

Bài báo định khung lại việc căn chỉnh mô hình ngôn ngữ như một bài toán phân loại tương phản nhiễu, đề xuất InfoNCA để học một chính sách từ phần thưởng (hoặc sở thích) rõ ràng bằng cách khớp với phân phối mục tiêu do phần thưởng sinh ra trên các phản hồi, và chỉ ra rằng DPO là một trường hợp nhị phân đặc biệt. Sau đó, bài báo giới thiệu NCA, thêm một số hạng khả năng tuyệt đối để ngăn chặn sự sụp đổ khả năng được quan sát thấy trong các mục tiêu tương đối (tương phản) thuần túy.

Với sở thích theo cặp, coi chosen/rejected là $K=2$ , định nghĩa điểm số $r=\beta(\log\pi_\theta-\log\pi_{\text{ref}})$ , và áp dụng tổn thất sở thích NCA $-\log\sigma(r_w)-\tfrac12\log\sigma(-r_w)-\tfrac12\log\sigma(-r_l)$ .

Để tái hiện cài đặt của bài báo, hãy sử dụng cấu hình này:

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 Vững Chắc Có Thể Chứng Minh: Điều Chỉnh Mô Hình Ngôn Ngữ Với Phản Hồi Ồn

📜 Bài báo: https://huggingface.co/papers/2403.00409

DPO bị suy giảm hiệu suất khi có nhiễu trong sở thích của con người vì việc đảo nhãn làm sai lệch hàm mục tiêu. Robust DPO khắc phục điều này bằng cách khử thiên lệch phân tích cho loss DPO dưới một mô hình nhiễu đơn giản, với các đảm bảo có thể chứng minh. $\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}$

Trong đó $\mathcal{L}_{\text{DPO}}$ là tổn thất DPO được định nghĩa trong Direct Preference Optimization: Your Language Model is Secretly a Reward Model và $\varepsilon$ là xác suất đảo nhãn.

Một sự hiệu chỉnh duy nhất này biến dữ liệu sở thích nhiễu thành một ước lượng không thiên lệch của mục tiêu DPO sạch.

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
)

Tối ưu hóa bộ phân loại nhị phân để căn chỉnh mô hình ngôn ngữ lớn

📜 Bài báo: https://huggingface.co/papers/2404.04656

Phân tích lý thuyết và một thuật toán mới, Binary Classifier Optimization, giải thích và cải thiện việc căn chỉnh các mô hình ngôn ngữ lớn bằng cách sử dụng các tín hiệu phản hồi nhị phân. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

BCO định hình lại việc căn chỉnh mô hình ngôn ngữ như là việc mô phỏng hành vi từ một phân phối có trọng số phần thưởng tối ưu, từ đó tạo ra các mục tiêu giám sát đơn giản, tránh được RL trong khi vẫn có cơ sở lý thuyết vững chắc. Nó hỗ trợ cả dữ liệu phần thưởng không ghép cặp và dữ liệu sở thích theo cặp, với một công thức bất biến theo sự dịch chuyển phần thưởng, giảm về một tổn thất theo phong cách DPO trong bối cảnh sở thích.

Đối với cài đặt ưu thích theo cặp, tổn thất BCO được định nghĩa là: $\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]$

Để tái hiện bài báo trong cài đặt này, hãy sử dụng cấu hình sau:

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

Học Mô hình Tham chiếu của Bạn để Đạt được Sự Căn chỉnh Thực sự

📜 Bài báo: https://huggingface.co/papers/2404.09656

Trust Region DPO (TR-DPO) cập nhật chính sách tham chiếu trong quá trình huấn luyện, thể hiện hiệu quả so với DPO trên các bộ dữ liệu Anthropic HH và TLDR, vượt trội hơn DPO tới 19% khi đo bằng đánh giá tự động với GPT-4, cải thiện tính nhất quán, tính chính xác, mức độ chi tiết, tính hữu ích và tính vô hại. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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

Tối ưu hóa sở thích suy luận lặp

📜 Bài báo: https://huggingface.co/papers/2404.19733

Iterative RPO cải thiện khả năng suy luận bằng cách lặp lại việc tạo ra các ứng viên chain-of-thought, xây dựng các cặp ưu tiên từ câu trả lời đúng so với câu trả lời sai, và huấn luyện với mục tiêu DPO + NLL. Thành phần NLL bổ sung là yếu tố then chốt để học cách thực sự tạo ra các trace chiến thắng.

TRL có thể biểu diễn mục tiêu DPO + NLL bằng cách kết hợp "sigmoid" (DPO) với "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,
)

Lưu ý rằng bài báo sử dụng một vòng lặp lặp lại: mỗi lần lặp sẽ tạo lại các ứng viên CoT bằng mô hình hiện tại, sau đó huấn luyện lại trên các cặp sở thích mới. TRL không tự động hóa vòng lặp đó cho bạn.

Tối ưu hóa sở thích tự chơi cho việc căn chỉnh mô hình ngôn ngữ

📜 Bài báo: https://huggingface.co/papers/2405.00675

Phương pháp tự chơi có tên SPPO để căn chỉnh mô hình ngôn ngữ đạt hiệu suất tiên tiến nhất bằng cách xấp xỉ chính sách cân bằng Nash trong bối cảnh trò chơi tổng bằng hằng số, vượt trội hơn các phương pháp khác với dữ liệu hạn chế. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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

Giảm thiểu tối ưu hóa quá mức trong RLHF một cách có thể chứng minh được: Tổn thất SFT của bạn là một bộ điều hòa đối kháng ngầm

📜 Bài báo: https://huggingface.co/papers/2405.16436

Regularized Preference Optimization (RPO) giảm thiểu hiện tượng tối ưu hóa quá mức trong RLHF bằng cách kết hợp loss DPO với loss SFT, có thể chứng minh được rằng nó ngăn chặn policy chọn các hành động có phần thưởng proxy cao một cách sai lệch. Để tái tạo lại cài đặt của bài báo, hãy sử dụng cấu hình này:

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
)

Căn chỉnh sở thích phân phối của LLMs thông qua Vận chuyển Tối ưu

📜 Bài báo: https://huggingface.co/papers/2406.05882

Alignment via Optimal Transport (AOT) căn chỉnh các mô hình ngôn ngữ lớn về mặt phân phối bằng cách phạt các vi phạm của sự thống trị ngẫu nhiên giữa các phân phối mẫu dương và mẫu âm, đạt được hiệu suất tiên tiến nhất trên các bộ đánh giá căn chỉnh. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

from trl import DPOConfig

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

hoặc, đối với phiên bản không ghép cặp:

from trl import DPOConfig

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

Không có siêu tham số bổ sung nào trong bài báo.

Khám phá các thuật toán tối ưu hóa sở thích với và cho các mô hình ngôn ngữ lớn

📜 Bài báo: https://huggingface.co/papers/2406.08414

Phương pháp do LLM điều khiển tự động khám phá các thuật toán tối ưu hóa sở thích có hiệu suất cao, dẫn đến một thuật toán mới có tên là DiscoPOP, kết hợp giữa tổn thất logistic và tổn thất mũ. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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: Nâng cao RLHF bằng Tối ưu hóa Ưu tiên có Trọng số

📜 Bài báo: https://huggingface.co/papers/2406.11827

WPO gán lại trọng số cho các cặp ưu tiên dựa trên xác suất của chính sách để giảm khoảng cách off-policy trong huấn luyện kiểu DPO. Hàm mất mát là: $\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]$

trong đó trọng số $w(x, y)$ được định nghĩa là: $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)$

Để tái hiện cài đặt của bài báo, hãy sử dụng cấu hình này:

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

Tối ưu hóa sở thích có neo và sửa đổi tương phản: Giải quyết sự thiếu cụ thể trong việc căn chỉnh

📜 Bài báo: https://huggingface.co/papers/2408.06266

CLAIR và APO tăng cường việc căn chỉnh LLM thông qua các cặp sở thích tương phản nhiều hơn và các mục tiêu căn chỉnh được kiểm soát, cải thiện hiệu suất mô hình tiệm cận GPT4-turbo. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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

Các tham số này chỉ xuất hiện trong bản đã công bố

Giảm độ nhạy với độ dài trong Tối ưu hóa Ưu tiên Trực tiếp

📜 Bài báo: https://huggingface.co/papers/2409.06411

Chỉ ra rằng DPO tiêu chuẩn vốn nhạy cảm với độ dài, điều này thường đẩy mô hình hướng tới các chuỗi sinh quá dài hoặc rườm rà. Bài báo đề xuất LD-DPO, trong đó thay đổi cách tổng hợp log-prob của chuỗi bằng cách tách phản hồi dài hơn thành một tiền tố chung (đến độ dài của phản hồi ngắn hơn) và một phần đuôi thừa, sau đó giảm trọng số của phần đuôi bằng hệ số $\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|).$

Cài đặt $\alpha=1$ khôi phục DPO tiêu chuẩn; giá trị nhỏ hơn $\alpha$ giảm tính rườm rà trong khi vẫn duy trì chất lượng ưu tiên. Giá trị tối ưu của $\alpha$ phụ thuộc vào họ mô hình và việc bạn đang huấn luyện mô hình base hay instruct, nhưng bài báo đề xuất $\alpha=0.5$ là điểm khởi đầu mặc định mạnh mẽ.

from trl import DPOConfig

training_args = DPOConfig(
    ld_alpha=0.5,
)

Nâng cao khả năng suy luận của các Mô hình Ngôn ngữ Lớn Đa phương thức thông qua Tối ưu hóa Sở thích Hỗn hợp

📜 Bài báo: https://huggingface.co/papers/2411.10442

Giới thiệu Mixed Preference Optimization (MPO) để cải thiện khả năng suy luận đa phương thức trong MLLM, giải quyết vấn đề dịch chuyển phân phối và suy luận dạng Chain-of-Thought (CoT) yếu sau quá trình huấn luyện trước chuẩn và SFT. Bài báo đóng góp (1) MMPR, một pipeline tự động cho dữ liệu ưu tiên đa phương thức chất lượng cao, và (2) MPO, một mục tiêu ưu tiên kết hợp (pairwise + dạng BCO + SFT) giúp tăng cường CoT. InternVL2-8B-MPO đạt 67.0 trên MathVista (+8.7 so với InternVL2-8B), tương đương với InternVL2-76B lớn hơn 10 lần. Được sử dụng trong TRL thông qua DPOConfig với loss tổng hợp. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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: Đẩy mạnh ranh giới trong huấn luyện sau của mô hình ngôn ngữ mở

📜 Bài báo: https://huggingface.co/papers/2411.15124

Mất sigmoid chuẩn hóa theo độ dài giải quyết thiên lệch độ dài trong DPO bằng cách chia điểm log-ratio của câu trả lời được chọn và bị từ chối cho độ dài hoàn thành tương ứng của chúng trước khi tính mất Bradley-Terry. Việc chuẩn hóa theo từng token này được giới thiệu trong SimPO (Phụ lục I “DPO w/ LN” ablation) như một phần thưởng log-xác suất trung bình cho cài đặt không có mô hình tham chiếu, và sau đó được áp dụng cho DPO dựa trên mô hình tham chiếu tiêu chuẩn trong các công thức hậu huấn luyện như Tülu 3 (Mục 4.3). Mất là: $\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),$ có thể được thiết lập bằng:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid_norm",
)

Tối ưu hóa Kahneman–Tversky

Các bài báo liên quan đến KTOTrainer

KTO: Hiệu chỉnh mô hình như tối ưu hóa theo lý thuyết triển vọng

📜 Bài báo: https://huggingface.co/papers/2402.01306

KTO suy ra mục tiêu căn chỉnh từ lý thuyết triển vọng và học trực tiếp từ phản hồi nhị phân của con người (thích/không thích), đạt hoặc vượt các phương pháp kiểu DPO trong khi xử lý tốt các tín hiệu mất cân bằng/ồn. Để tái tạo cài đặt của bài báo, bạn có thể sử dụng cấu hình mặc định của 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()

Tinh chỉnh có giám sát

Các bài báo liên quan đến SFTTrainer

TailSFT: Tinh chỉnh có lọc cải thiện hiệu suất sau huấn luyện

📜 Bài báo: https://huggingface.co/papers/2608.25756

TailSFT bảo toàn độ bao phủ phản hồi cho việc học tăng cường tiếp theo bằng cách lọc các chuỗi có tổn thất chuẩn hóa theo độ dài cải thiện nhiều nhất so với chính sách ban đầu. Ví dụ tail_sft_gsm8k triển khai lọc theo lô chọn lựa phân tán của bài báo bằng cách kế thừa SFTTrainer. Nó ghi lại tổn thất chính sách ban đầu của từng chuỗi trước khi huấn luyện và lọc các ví dụ độc lập trong mỗi lô chọn lựa.

python examples/tail_sft_gsm8k/tail_sft.py

EMA Không Có Độ Trễ: Các Phương Pháp Trung Bình Hóa Lặp Lại Được Hiệu Chỉnh Sai

📜 Bài báo: https://huggingface.co/papers/2508.00180

Bias-Corrected Exponential Moving Average (BEMA) cải thiện tính ổn định và hiệu quả của việc tinh chỉnh mô hình ngôn ngữ bằng cách giảm tính ngẫu nhiên và loại bỏ độ chệch. Để sử dụng BEMA với SFT như được mô tả trong bài báo, bạn có thể sử dụng BEMACallback:

from trl import BEMACallback, SFTTrainer

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

Về sự tổng quát hóa của SFT: Góc nhìn học tăng cường với hiệu chỉnh phần thưởng

📜 Bài báo: https://huggingface.co/papers/2508.05629

Dynamic Fine-Tuning (DFT) cải thiện khả năng tổng quát hóa của các Large Language Models (LLM) bằng cách tự động điều chỉnh lại tỷ lệ gradient, vượt trội hơn so với Supervised Fine-Tuning (SFT) tiêu chuẩn và cho thấy kết quả cạnh tranh trong học tăng cường ngoại tuyến. $\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]$

trong đó $\text{sg}(\cdot)$ là toán tử stop-gradient. Để sử dụng DFT với SFT như đã mô tả trong bài báo, bạn có thể sử dụng đối số loss_type="dft" :

from trl import SFTConfig

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

Để khớp sát với thiết lập trong bài báo, bạn có thể sử dụng cấu hình sau (xem Mục 4.1). Các tác giả cũng lưu ý rằng các siêu tham số không quá nhạy cảm (Mục 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,
)

Giảm thiểu việc cắt cụt cải thiện mô hình hóa ngôn ngữ

📜 Bài báo: https://huggingface.co/papers/2404.10830

Bài báo cho thấy quy trình tiền xử lý nối-rồi-chia chuẩn (packing_strategy="wrapped") được sử dụng cho việc huấn luyện LLM khiến nhiều tài liệu bị cắt ngắn tùy ý, gây ảnh hưởng xấu đến quá trình học. Bài báo đề xuất việc đóng gói các đoạn tài liệu vào các cửa sổ ngữ cảnh bằng thuật toán đóng gói thùng Best-Fit Decreasing, giảm đáng kể tình trạng cắt ngắn trong khi vẫn duy trì mức sử dụng token cao và cải thiện hiệu suất mô hình. TRL triển khai điều này dưới dạng chiến lược đóng gói "bfd_split" trong SFTConfig. Để biết thêm chi tiết về đóng gói, hãy xem tài liệu SFT.

from trl import SFTConfig

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

Khám phá giới hạn của học chuyển tiếp với bộ biến đổi văn bản-sang-văn bản thống nhất

📜 Bài báo: https://huggingface.co/papers/1910.10683

Bài báo T5 đề xuất một khung làm việc thống nhất từ văn bản sang văn bản cho học chuyển giao và giới thiệu sequence packing (Mục 3.5.2): gom nhiều chuỗi ngắn vào các khối có độ dài cố định để giảm padding và cải thiện hiệu quả huấn luyện. Packing được hỗ trợ trong TRL thông qua SFTConfig với SFTTrainer. Để bật packing với TRL, hãy sử dụng cấu hình sau:

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

Reparameterizing Uniform Diffusion Models: the Leave-One-Out Denoiser

📜 Bài báo: https://huggingface.co/papers/2605.22765

Đối với các mô hình khuếch tán rời rạc đồng nhất, hàm cross-entropy plug-in thông thường không học được denoiser thuần túy $\mathbb{E}[X_0 \mid X_t]$ mà là posterior leave-one-out (LOO), dự đoán từng token mà không sử dụng giá trị bị nhiễu của chính nó. Bài báo suy ra các phép chuyển đổi chính xác giữa denoiser, posterior LOO và score, do đó mạng có thể được huấn luyện dưới dạng bất kỳ tham số hóa nào với cùng một cross-entropy. Với logits $f_\theta$ mà softmax của chúng tham số hóa posterior LOO, denoiser được sử dụng trong loss là $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),$

tức là một hiệu chỉnh cộng vào logit của token quan sát được, trong đó $K$ là kích thước từ vựng và $\alpha_t$ là xác suất mà tiến trình thuận nhất phân phối giữ lại token sạch. Bài báo cho thấy rằng tham số hóa LOO nhất quán cải thiện việc tạo ra văn bản. Ví dụ SFT block-diffusion examples/sft_diffusion_gemma/sft_diffusion_gemma.py tiết lộ cả hai dạng tham số hóa thông qua --model_prediction_type (mean cho bộ khử nhiễu thông thường, khớp với checkpoint đã phát hành, hoặc mean_loo cho hậu nghiệm 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

Giảm tính toán lại kích hoạt trong các mô hình Transformer lớn

📜 Bài báo: https://huggingface.co/papers/2205.05198

Full activation checkpointing tính toán lại mọi op trong một vùng được checkpoint trong quá trình backward, bao gồm cả attention, mặc dù chỉ một vài op (trong đó có attention) chiếm phần lớn chi phí tính toán lại so với bộ nhớ mà chúng sẽ tiêu tốn nếu được giữ lại. Phương pháp selective activation recomputation trong bài báo chỉ checkpoint những op đắt đỏ đó thay vì toàn bộ vùng. TRL triển khai điều này dưới dạng selective activation checkpointing (SAC) cho SFTTrainer, lưu trữ đầu ra của attention trong quá trình forward để backward không cần tính toán lại nó:

from trl import SFTConfig

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

Chỉnh huấn hiệu quả tham số (PEFT)

Để biết chi tiết chung về việc sử dụng PEFT với TRL, vui lòng tham khảo hướng dẫn Tích hợp PEFT.

LoRA: Thích ứng hạng thấp cho các mô hình ngôn ngữ lớn

📜 Bài báo: https://huggingface.co/papers/2106.09685

Low-Rank Adaptation (LoRA) giảm số lượng tham số có thể huấn luyện và mức sử dụng bộ nhớ GPU trong các mô hình pre-trained quy mô lớn, đồng thời duy trì hoặc cải thiện hiệu suất trên các tác vụ downstream. TRL tích hợp LoRA thông qua thư viện PEFT và có thể được bật dễ dàng trong bất kỳ trainer TRL nào bằng cách truyền một LoraConfig vào đối số peft_config. Dưới đây là một ví dụ về việc sử dụng LoRA với SFTTrainer:

from trl import SFTTrainer
from peft import LoraConfig

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

DoRA: Thích ứng hạng thấp phân rã trọng số

📜 Bài báo: https://huggingface.co/papers/2402.09353

Weight-Decomposed Low-Rank Adaptation (DoRA) có thể cải thiện hiệu suất của LoRA, đặc biệt là ở các rank thấp. DoRA phân rã trọng số đã được huấn luyện trước thành hai thành phần: độ lớn và hướng. Hướng được xử lý bởi LoRA thông thường, còn độ lớn là các tham số có thể học được. TRL tích hợp DoRA thông qua thư viện PEFT và có thể dễ dàng kích hoạt bằng cách đặt use_dora=True cho LoraConfig.

from peft import LoraConfig

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

Reinforce Leave-One-Out

Các bài báo liên quan đến RLOOTrainer

Quay về cơ bản: Xem xét lại tối ưu hóa kiểu REINFORCE để học từ phản hồi của con người trong LLM

📜 Bài báo: https://huggingface.co/papers/2402.14740

RLOO là một biến thể của REINFORCE, giúp giảm phương sai bằng cách sử dụng các baseline leave-one-out. Nó tính toán phần thưởng bằng cách so sánh mỗi mẫu với trung bình của tất cả các mẫu khác trong batch, cung cấp các gradient ổn định hơn so với REINFORCE tiêu chuẩn. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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++: Một cách tiếp cận đơn giản và hiệu quả để căn chỉnh các mô hình ngôn ngữ lớn

📜 Bài báo: https://huggingface.co/papers/2501.03262

REINFORCE++ là một biến thể nâng cao của thuật toán REINFORCE cổ điển, tích hợp các kỹ thuật tối ưu hóa chính từ PPO đồng thời loại bỏ nhu cầu về mạng critic. Nó đạt được sự đơn giản, độ ổn định huấn luyện được cải thiện và giảm thiểu chi phí tính toán thông qua việc chuẩn hóa lợi thế toàn cục trên toàn bộ batch. Để xấp xỉ cài đặt của bài báo với RLOOTrainer, hãy sử dụng cấu hình này:

from trl import RLOOConfig

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

Tối ưu hóa ưu tiên theo tỷ lệ cược

Các bài báo liên quan đến experimental.orpo.ORPOTrainer

ORPO: Tối ưu hóa sở thích đơn khối không có mô hình tham chiếu

📜 Bài báo: https://huggingface.co/papers/2403.07691

Việc giới thiệu thuật toán tối ưu hóa tỷ lệ cược đơn khối không cần mô hình tham chiếu (ORPO) giúp tăng cường việc căn chỉnh sở thích trong quá trình tinh chỉnh có giám sát, vượt qua các mô hình lớn hơn trong các đánh giá chính. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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

Tối ưu hóa sở thích tương phản

Các bài báo liên quan đến experimental.cpo.CPOTrainer

Tối ưu hóa sở thích tương phản: Đẩy mạnh giới hạn hiệu suất của LLM trong dịch máy

📜 Bài báo: https://huggingface.co/papers/2401.08417

Giới thiệu Contrastive Preference Optimization (CPO), một phương pháp dựa trên sở thích cho dịch máy, huấn luyện mô hình để tránh các bản dịch chấp nhận được nhưng chưa hoàn hảo thay vì bắt chước bản tham chiếu như trong SFT. Bài báo phân tích các hạn chế của SFT trong MT (bao gồm cả vấn đề chất lượng bản tham chiếu) và cho thấy việc áp dụng CPO cho ALMA với chỉ 22K câu song song tạo ra ALMA-R, đạt hoặc vượt qua các nhà vô địch cuộc thi WMT và GPT-4 trên WMT’21–WMT’23. Được sử dụng trong TRL thông qua experimental.cpo.CPOTrainer. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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: Tối ưu hóa sở thích đơn giản với phần thưởng không tham chiếu

📜 Bài báo: https://huggingface.co/papers/2405.14734

SimPO là một phương pháp tối ưu hóa sở thích đơn giản hơn nhưng hiệu quả hơn, sử dụng xác suất log trung bình của một chuỗi làm phần thưởng ẩn, loại bỏ nhu cầu về một mô hình tham chiếu. Phương pháp này đưa vào một biên độ phần thưởng mục tiêu vào hàm mục tiêu Bradley-Terry để khuyến khích khoảng cách lớn hơn giữa các phản hồi thắng và thua. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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 — Hình dạng phần thưởng quan trọng trong việc căn chỉnh LLM

📜 Bài báo: https://huggingface.co/papers/2501.03884

AlphaPO là một phương pháp mới thuộc nhóm Direct Alignment Algorithms (DAAs), tận dụng tham số alpha để giúp thay đổi hình dạng của hàm phần thưởng vượt ra ngoài hàm phần thưởng log chuẩn. AlphaPO giúp duy trì khả năng kiểm soát chi tiết đối với sự dịch chuyển xác suất và tối ưu hóa quá mức. Để tái tạo lại cài đặt trong bài báo, hãy sử dụng cấu hình này:

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

Tối ưu hóa ba sở thích

Tối ưu hóa ba sở thích: Đạt được sự căn chỉnh tốt hơn bằng tối ưu hóa một bước

📜 Bài báo: https://huggingface.co/papers/2405.16681

Giới thiệu Triple Preference Optimization (TPO), một phương pháp học theo sở thích giúp điều chỉnh LLM với ba phản hồi cho mỗi prompt — một hoàn tất vàng (reference), một hoàn tất được ưu tiên (chosen) và một hoàn tất không được ưu tiên (rejected) — trong một bước tối ưu duy nhất. TPO kết hợp mục tiêu tương phản trên cặp (chosen, rejected) với một số hạng NLL giám sát trên phản hồi vàng, loại bỏ nhu cầu về một giai đoạn SFT riêng biệt và mô hình tham chiếu được sử dụng trong DPO. TRL đã phát hành một triển khai dưới dạng TPOTrainer cho đến v1.16; nó không còn là một phần của thư viện và vẫn có sẵn trong lịch sử git.

Học Nash từ Phản hồi của Con người

📜 Bài báo: https://huggingface.co/papers/2312.00886

Giới thiệu Nash-MD, một phương pháp thay thế cho RLHF tiêu chuẩn, trong đó mô hình ưu tiên được huấn luyện có điều kiện dựa trên hai đầu vào và tìm ra chính sách tại điểm cân bằng Nash. Thay vì tối ưu hóa đối với mô hình phần thưởng, Nash-MD tạo ra các chính sách luôn nhất quán sinh ra các phản hồi được ưu tiên hơn so với các phản hồi của bất kỳ chính sách cạnh tranh nào. Thuật toán này dựa trên các nguyên lý của mirror descent. TRL đã phát hành một bản triển khai dưới dạng NashMDTrainer cho đến v1.13; nó không còn là một phần của thư viện và vẫn có sẵn trong lịch sử git.

Mô hình hóa phần thưởng

Các bài báo liên quan đến RewardTrainer

Hỗ trợ hay Bầy đàn? Các tập hợp mô hình phần thưởng làm giảm nhưng không loại bỏ được việc khai thác phần thưởng

📜 Bài báo: https://huggingface.co/papers/2312.09244

Bài báo này đề xuất một hàm mất mát phụ được thiết kế để học trực tiếp một mô hình phần thưởng có tâm. Hàm mất mát phụ này tối thiểu hóa tổng bình phương của các phần thưởng, khuyến khích mô hình tự nhiên tạo ra các đầu ra có trung bình bằng không, từ đó giải quyết vấn đề xác định thiếu. $\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].$

Để sử dụng tổn thất phụ trợ này với RewardTrainer, bạn có thể sử dụng đối số center_rewards_coefficient trong RewardConfig như sau:

from trl import RewardConfig

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

Llama 2: Mô hình nền tảng mở và mô hình chat được tinh chỉnh

📜 Bài báo: https://huggingface.co/papers/2307.09288

Trong bài báo này, các tác giả đề xuất tận dụng việc đánh giá sở thích của họ được phân rã thành một thang điểm bốn mức (ví dụ, tốt hơn đáng kể) để cung cấp phản hồi có thông tin hơn cho mô hình phần thưởng. Điều này được thực hiện bằng cách thêm một biên độ (margin) vào hàm mất mát, khuyến khích mô hình phần thưởng gán khoảng cách điểm lớn hơn cho các cặp có mức đánh giá sở thích cao hơn. $\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].$

Bạn có thể thêm biên (margin) vào loss bằng cách thêm cột margin vào dataset. Ví dụ sau cho thấy cách thiết lập cấu hình “Margin Small” của bài báo.

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)

Tối ưu hóa trực tiếp sở thích trực tuyến

Các bài báo liên quan đến experimental.online_dpo.OnlineDPOTrainer

Căn chỉnh Mô hình Ngôn ngữ Trực tiếp từ Phản hồi AI Trực tuyến

📜 Bài báo: https://huggingface.co/papers/2402.04792

Online DPO cải thiện các phương pháp trực tiếp căn chỉnh từ sở thích bằng cách cung cấp phản hồi thời gian thực từ một mô hình, vượt trội hơn cả các phương pháp DPO và PPO.

Để sử dụng Online DPO, bạn có thể dùng experimental.online_dpo.OnlineDPOTrainer.

Tối ưu hóa sở thích khám phá: Khai thác xấp xỉ Q* ẩn cho RLHF hiệu quả về mẫu

📜 Bài báo: https://huggingface.co/papers/2405.21046

XPO bổ sung cho mục tiêu DPO một phần thưởng khám phá mới và có nguyên tắc, giúp thuật toán khám phá bên ngoài miền hỗ trợ của mô hình ban đầu và dữ liệu phản hồi của con người. Đây là một thay đổi chỉ một dòng so với online DPO, được chứng minh là hiệu quả về mẫu và hội tụ về chính sách mô hình ngôn ngữ gần tối ưu. TRL đã phát hành một cài đặt dưới dạng XPOTrainer cho đến v1.13; nó không còn là một phần của thư viện và vẫn có sẵn trong lịch sử git.

Chưng cất

Các bài báo liên quan đến việc huấn luyện một mô hình học sinh với sự hỗ trợ của một mô hình giáo viên.

On-Policy Distillation của các mô hình ngôn ngữ: Học từ những sai lầm do chính mình tạo ra

📜 Bài báo: https://huggingface.co/papers/2306.13649

Giới thiệu Generalized Knowledge Distillation (GKD), giải quyết vấn đề lệch phân phối trong KD cho các mô hình tự hồi quy bằng cách huấn luyện học sinh trên các đầu ra do chính nó tạo ra với phản hồi từ giáo viên, thay vì một tập hợp các chuỗi cố định. GKD hỗ trợ các hàm mất mát linh hoạt (ví dụ: ngoài KL khi học sinh không thể khớp với giáo viên) và tích hợp với tinh chỉnh RL (RLHF). Bài báo báo cáo kết quả trên các tác vụ tóm tắt, dịch thuật, suy luận số học và tinh chỉnh theo chỉ dẫn. Được sử dụng trong TRL thông qua experimental.gkd.GKDTrainer, trong đó phơi bày việc trộn on/off-policy (lmbda) của bài báo. DistillationTrainer triển khai cùng mục tiêu generalized-JSD cho trường hợp luôn on-policy. Để tái tạo cài đặt của bài báo, hãy sử dụng cấu hình này:

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: Chưng cất theo chính sách từ nhiều giáo viên cho việc tích hợp năng lực trong huấn luyện sau của LLM

📜 Bài báo: https://huggingface.co/papers/2606.30406

Tổ chức quá trình hậu huấn luyện thành ba giai đoạn: SFT tổng quát, huấn luyện RL độc lập theo từng miền với một chuyên gia cho mỗi miền (ví dụ: RL cho câu trả lời có thể kiểm chứng trong toán học, RL cho tác nhân trong môi trường sandbox trong kỹ thuật phần mềm), và giai đoạn MOPD cuối cùng để hợp nhất các chuyên gia miền đã đóng băng thành một học sinh thống nhất duy nhất. Trong giai đoạn cuối đó, học sinh tạo ra một quỹ đạo cho mỗi prompt, mỗi quỹ đạo được chuyển đến giáo viên miền tương ứng (không bao giờ được trung bình hóa hoặc kết hợp ensemble giữa các giáo viên), và học sinh được cập nhật bằng cách tối thiểu hóa KL ngược theo từng token so với phân phối của chính giáo viên đó dọc theo quỹ đạo. Được sử dụng trong TRL thông qua experimental.async_distillation.AsyncDistillationTrainer, thành phần này triển khai giai đoạn hợp nhất thứ ba: việc truyền nhiều hơn một mục vào teacher_server_urls sẽ kích hoạt MOPD, với cột teacher_id của mỗi hàng chọn giáo viên (đã được huấn luyện) nào sẽ chấm điểm cho nó. Sử dụng beta=1.0 để khớp với mục tiêu KL ngược trong bài báo.

Về Thiên vị Vị trí của Chưng cất Chính sách

📜 Bài báo: https://huggingface.co/papers/2606.22600

Giới thiệu Importance-Weighted On-Policy Distillation (IW-OPD), giải quyết vấn đề thiên vị vị trí trong OPD bằng cách gán lại trọng số cho các bản cập nhật chưng cất token được lấy mẫu dựa trên độ lệch tiền tố giáo viên-học sinh tích lũy. Các token đầu giữ trọng số lớn hơn, trong khi các token sau có độ trôi cao sẽ bị giảm trọng số. Được sử dụng trong TRL thông qua experimental.iw_opd.IWOPDTrainer với distillation_objective="iw_opd".

Bài báo tối ưu hóa IW-OPD với cấu hình policy-gradient có cắt (clipped) (verl) và các rollout của vLLM. IWOPDTrainer cung cấp các cài đặt distillation và rollout tương ứng bên dưới; các cài đặt tối ưu hóa policy từ bài báo như khoảng cắt 0.2, hằng số dual-clip 3.0, số epoch PPO nội, hệ số entropy, hình phạt KL reward, KL phụ trợ và hiệu chỉnh quan trọng rollout không phải là các tham số của 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
)

Chưng cất theo chính sách

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

On-Policy Distillation liên quan đến việc mô hình sinh viên tạo ra các rollout cho mỗi lô dữ liệu huấn luyện. Sau đó, chúng ta thu được các phân phối xác suất cho từng token của các rollout từ cả mô hình sinh viên và mô hình giáo viên. Mô hình sinh viên sau đó được tối ưu hóa để giảm thiểu độ phân kỳ Kullback-Leibler (KL) âm giữa phân phối token của chính nó và phân phối của mô hình giáo viên.

Phương pháp	Mẫu	Tín hiệu phần thưởng
Huấn luyện lại có giám sát	off-policy	dense
Học tăng cường	on-policy	sparse
Chưng cất theo chính sách	on-policy	dense

On-Policy Distillation đã được chứng minh là vượt trội hơn so với SFT, GRPO và có thể được sử dụng để khôi phục khả năng tổng quát hóa bị mất trong quá trình SFT.

Ngoài ra, việc chưng cất on-policy còn hiệu quả hơn về mặt tính toán và ít có xu hướng overfitting hơn khi được huấn luyện với dữ liệu hạn chế.

Để huấn luyện một mô hình với on-policy distillation bằng TRL, bạn có thể sử dụng cấu hình sau, với DistillationTrainer và 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
)

Ngoài ra, bạn có thể sử dụng experimental.gkd.GKDTrainer và 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
)

Bạn cũng có thể sử dụng experimental.gold.GOLDTrainer cho việc chưng cất on-policy; xem Unlocking On-Policy Distillation for Any Model Family.

Mở khóa kỹ thuật Chưng cất On-Policy cho bất kỳ họ mô hình nào

🌐 Dự án: https://huggingface.co/spaces/HuggingFaceH4/general-on-policy-logit-distillation

Giới thiệu General Online Logit Distillation (GOLD), mở rộng on-policy distillation cho các cặp student/teacher có tokenizer và họ model khác nhau. GOLD căn chỉnh các đoạn văn bản giữa các tokenizer và có thể áp dụng Universal Logit Distillation (ULD) để các token completion không bị loại bỏ. Được sử dụng trong TRL thông qua 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: Chưng cất kiến thức giữa các bộ mã hóa hóa dẫn hướng bởi phép chiếu

📜 Bài báo: https://huggingface.co/papers/2605.21699

X-Token mở rộng khung chưng cất GOLD cho các cặp học sinh - giáo viên không dùng chung bộ phân từ. Đây là một phương pháp ngoài chính sách (lmbda=0): tập dữ liệu cung cấp văn bản hoàn thành, cả học sinh và giáo viên đều thực hiện các bước truyền tiến trên văn bản đó, và tổn thất KD liên kết phân từ được tính toán giữa các logits của chúng. Không cần các lượt triển khai học sinh theo chính sách. Một ma trận chiếu thưa W ∈ ℝ^{V_s × V_t} được tính trước ánh xạ mỗi token của học sinh sang các token của giáo viên mà nó có khả năng tương ứng nhất, chiếu phân phối của học sinh vào không gian từ vựng của giáo viên để hai bên có thể so sánh trực tiếp. Được sử dụng trong TRL thông qua experimental.gold.GOLDTrainer với xtoken_loss_type="p_kl" hoặc "h_kl".

Hai công thức loss được cung cấp:

Biến thể	`xtoken_loss_type`	Mô tả
P-KL	`"p_kl"`	Chiếu phân phối sinh viên đầy đủ sang bảng từ vựng của giáo viên thông qua W và tính KL tiến bộ trên một tập con top-k toàn cục. Triển khai công thức (4) của bài báo.
H-KL	`"h_kl"`	Hybrid: KL tiến trên các phân phối được chuẩn hóa lại trên một tập chung được nới lỏng (trọng số chiếu top-1 ≥ 0.6) và L1 đã sắp xếp trên các token không phổ biến. Triển khai Phương trình (3) với ánh xạ từ Phương trình (5).

Tương tự như trong bản triển khai tham chiếu, H-KL cắt các log-probabilities của toàn bộ từ vựng xuống tập chung và P-KL lấy trung bình các log-probabilities của teacher trên mỗi span mà không chuẩn hóa lại, do đó số hạng KD có thể âm. CE và KD sử dụng các bộ đếm token và span đã căn chỉnh riêng biệt trên mỗi cửa sổ tích lũy. Cân bằng động CE/KD và chọn top-k của P-KL được tính trên mỗi microbatch.

Cài đặt này sử dụng một ma trận chiếu đóng băng. Bài báo cũng đồng thời học ma trận cho P-KL; biến thể đó không được cài đặt ở đây.

Trước tiên, hãy xây dựng ma trận chiếu bằng các script chuẩn bị trong examples/xtoken/. Bước 1 sẽ mã hóa lại (re-tokenize) từ vựng của student bằng tokenizer của teacher; cờ tùy chọn --runtime-top-k sau đó sẽ sắp xếp và cắt gọn ma trận trong một lần chạy (tương đương với việc chạy sort_and_cut_projection_matrix.py sau đó):

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

Sau đó, huấn luyện bằng script ví dụ (off-policy, không cần 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

hoặc truyền đường dẫn đến experimental.gold.GOLDConfig trực tiếp:

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

Chưng cất kiến thức của các Mô hình Ngôn ngữ Lớn

📜 Bài báo: https://huggingface.co/papers/2306.08543

MiniLLM là phương pháp chưng cất tri thức on-policy đầu tiên, trong đó nó tối thiểu hóa KLD ngược ở cấp độ chuỗi giữa mô hình teacher và mô hình student, và được tối ưu hóa bằng học tăng cường.

Đây là phiên bản tổng quát hóa của On-Policy Distillation của Think Machine Lab, với tùy chọn thêm các tín hiệu chưng cất một bước ở cấp độ phân phối (giống như GKD khi beta=1) và các tín hiệu KLD ngược cho ngữ cảnh dài.

TRL đã phát hành một bản triển khai dưới dạng MiniLLMTrainer cho đến v1.14; nó không còn là một phần của thư viện và vẫn có sẵn trong lịch sử git.

Học tăng cường thông qua tự phân phối

📜 Bài báo: https://huggingface.co/papers/2601.20802

Tối ưu hóa chính sách tự chưng cất (SDPO) tăng cường học tăng cường với phần thưởng có thể kiểm chứng bằng cách chuyển đổi phản hồi văn bản phong phú (ví dụ: lỗi thời gian chạy, đánh giá của trọng tài) thành tín hiệu học tập dày đặc mà không cần giáo viên bên ngoài hay mô hình phần thưởng tường minh. SDPO coi mô hình hiện tại có điều kiện theo phản hồi như một giáo viên tự thân và chưng cất các dự đoán token tiếp theo có thông tin phản hồi của nó trở lại chính sách. Đáng chú ý, SDPO cũng vượt trội hơn các phương pháp cơ sở trong các môi trường RLVR tiêu chuẩn chỉ trả về phản hồi vô hướng bằng cách sử dụng các lượt triển khai thành công như phản hồi ẩn cho các lần thử thất bại.

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

Các cột dữ liệu tập dữ liệu dự kiến:

prompt
privileged_context cho phản hồi môi trường tùy chọn

Để biết thêm chi tiết, hãy xem tài liệu SDPO Trainer.

Tự học từ chính mình cho phép học liên tục

📜 Bài báo: https://huggingface.co/papers/2601.19897

Fine-tuning tự chưng cất (SDFT) thực hiện tự chưng cất on-policy bằng cách tạo ra các phần hoàn thành trong quá trình huấn luyện, sau đó chưng cất một góc nhìn giáo viên có điều kiện tường minh của chính các phần hoàn thành đó ngược lại vào học sinh. Giáo viên được chọn bởi teacher_model_kind: "base" (học sinh ban đầu), "live" (học sinh hiện tại) hoặc "ema" (giáo viên trung bình mũ). Prompt giáo viên được tạo ra bên trong từ prompt của học sinh cộng với privileged_context của bộ dữ liệu.

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

Các cột dữ liệu tập dữ liệu dự kiến:

prompt
privileged_context chỉ chứa thông tin bổ sung dành riêng cho giáo viên

Để biết thêm chi tiết, hãy xem tài liệu SDFT Trainer.

Tự phân phối đơn giản đến mức ngượng ngùng cải thiện việc tạo mã

📜 Bài báo: https://huggingface.co/papers/2604.01193

Simple Self-Distillation (SSD) cải thiện việc tạo mã bằng cách lấy mẫu các phần hoàn thành từ mô hình với nhiệt độ và cấu hình cắt ngắn trong quá trình huấn luyện, sau đó tinh chỉnh trên các mẫu thô, chưa được xác minh đó bằng tổn thất entropy chéo chuẩn. Không cần mô hình phần thưởng, bộ xác minh, mô hình giáo viên hay học tăng cường. SSD định hình lại phân phối token theo cách phụ thuộc ngữ cảnh: ức chế các đuôi gây nhiễu ở các vị trí “lock” (nơi cú pháp để lại ít sự mơ hồ) trong khi duy trì tính đa dạng ở các vị trí “fork” (nơi tồn tại nhiều cách tiếp tục hợp lệ).

TRL đã phát hành một bản triển khai dưới dạng SSDTrainer cho đến v1.15; nó không còn là một phần của thư viện và vẫn có sẵn trong lịch sử git.

Một giải pháp cho Softmax và Cross-Entropy

📜 Bài báo: https://huggingface.co/papers/2610.31642

Nhận diện sự sụp đổ softmax ở các dự đoán có độ tin cậy cao và sự triệt tiêu khi logits của học sinh và giáo viên gần như trùng khớp. Đầu ra log-probability phân mảnh và đầu ra chưng cất của TRL sử dụng chuẩn hóa loại trừ mục tiêu và hiệu số xác suất trong không gian log để bảo toàn các gradient nhỏ. Các sửa đổi về mặt số học được áp dụng tự động, bao gồm cả KL tiến, KL ngược và JSD tổng quát trong DistillationTrainer.

Phụ lục B.4 của Entropy-preserving reinforcement learning trước đó đã xác định được sự thất bại của policy-gradient ở độ tin cậy cao và đề xuất tính lại có chọn lọc các gradient ở FP64. Các kernel của TRL bảo toàn các gradient này bằng cách sử dụng các công thức FP32 ổn định.

Vấn đề riêng biệt về việc ép kiểu đầu ra của FSDP2 được thảo luận trong Phụ lục B.1 đã được xử lý bởi Accelerate #4403. Các phiên bản Accelerate cũ hơn cần một chính sách độ chính xác hỗn hợp với output_dtype=None để giữ nguyên đầu ra của kernel FP32.

Ví dụ sau ánh xạ các siêu tham số được báo cáo trong Mục 7 sang hàm mục tiêu forward-KL của TRL, vốn chia sẻ gradient của học sinh với entropy chéo có mục tiêu mềm. Nó minh họa việc chưng cất mô hình ngôn ngữ chứ không tái hiện thí nghiệm số học mô-đun của bài báo. Bài báo khởi tạo học sinh bằng trọng số của giáo viên; điều này phải được xử lý khi xây dựng các mô hình, độc lập với cấu hình. Các giá trị mặc định khác của trainer vẫn không thay đổi.

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

Huấn luyện Phân tán

ZeRO: Tối ưu hóa bộ nhớ hướng tới huấn luyện các mô hình có hàng nghìn tỷ tham số

📜 Bài báo: https://huggingface.co/papers/1910.02054

ZeRO (Zero Redundancy Optimizer) loại bỏ sự dư thừa bộ nhớ trong huấn luyện song song theo dữ liệu và mô hình bằng cách phân chia trạng thái tối ưu hóa, gradient và tham số giữa các thiết bị, đồng thời duy trì lượng truyền thông thấp và độ hạt tính toán cao. Điều này cho phép huấn luyện hiệu quả các mô hình lớn vốn không thể chứa vừa trong bộ nhớ GPU.

TRL hỗ trợ ZeRO thông qua tích hợp DeepSpeed. Để sử dụng, hãy cung cấp một tệp cấu hình DeepSpeed với các cài đặt mong muốn của bạn,

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

và chạy script huấn luyện bằng accelerate launch --config_file config_file.

accelerate launch --config_file config.yaml train.py

Update on GitHub

←Định dạng Dataset Chưng cất→