TRL documentation

논문 인덱스

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

논문 인덱스

아래 각 논문은 해당 Hugging Face 논문 페이지로 연결됩니다. 또한 hf CLI를 통해 터미널에서 이 중 어떤 논문이든 읽을 수 있습니다. 예를 들어 hf papers read 2402.03300을 사용할 수 있으며, 코딩 에이전트와 함께 사용할 때 특히 유용합니다.

Group Relative Policy Optimization

GRPOTrainer와 관련된 논문.

DeepSeekMath: 오픈 언어 모델의 수학적 추론 한계 확장

📜 논문: https://huggingface.co/papers/2402.03300

Group Relative Policy Optimization(GRPO)를 소개하며, 수학 중심 사전 학습과 그룹 상대적 PPO 스타일 최적화를 결합했을 때 수학 추론 성능이 크게 향상됨을 보여줍니다. TRL에서 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: 강화 학습을 통한 LLM 추론 능력 강화

📜 논문: https://huggingface.co/papers/2501.12948

DeepSeek-R1은 순수 강화 학습(RL)에서 정제되고 인간과 정렬된 모델로 전환되는 다단계 파이프라인을 통해 OpenAI-o1과 동등한 추론 성능을 달성합니다. 기본 모델에 순수 RL을 적용한 이전 버전인 DeepSeek-R1-Zero와 달리, R1은 구조화된 4단계 진화를 따릅니다:

  1. Cold Start: 베이스 모델은 소규모의 고품질, 긴 Chain-of-Thought (CoT) 데이터셋으로 fine-tuning되어 안정적인 시작점을 제공합니다.
  2. Reasoning-Oriented RL: 수학, 코딩, 논리 성능 향상을 위해 대규모 RL을 적용하며, 규칙 기반 보상과 언어 일관성 보상을 사용하여 언어 혼합을 줄입니다.
  3. Rejection Sampling & SFT: RL 체크포인트는 rejection sampling을 통해 600k개의 추론(reasoning) 샘플을 생성하며, 이는 200k개의 비추론(일반) 샘플과 결합되어 두 번째 Supervised Fine-Tuning 라운드를 위한 새로운 데이터셋을 만듭니다.
  4. 모든 시나리오에 대한 RL: 최종 RL 단계에서는 추론 능력을 유지하면서 모든 도메인에서 모델이 인간 선호(유용성과 무해성)에 맞게 정렬되도록 합니다.

디스틸레이션: 소형 모델의 성능 강화

이 논문의 핵심 기여는 추론 패턴을 대규모 모델(DeepSeek-R1)에서 더 작은 dense 모델(예: Qwen 및 Llama 시리즈)로 증류할 수 있음을 입증한 것입니다. 순수 RL을 사용하여 처음부터 학습하는 것보다 증류가 작은 모델에 더 효과적인 것으로 나타났습니다.

GRPOTrainer를 사용하여 이 파이프라인의 추론 중심 단계를 재현할 수 있습니다.

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

Group Sequence Policy Optimization

📜 논문: https://huggingface.co/papers/2507.18071

GSPO는 토큰별이 아닌 시퀀스 수준에서 중요도 샘플링 가중치를 계산하는 GRPO 변형입니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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
)

이 메서드는 학습이 약간 오프-폴리시(off-policy)로 진행될 때만 효과를 발휘합니다. 예를 들어, steps_per_generation > gradient_accumulation_steps 또는 num_iterations > 1인 경우입니다. 그렇지 않으면 실질적으로 수정이 없는 것과 동일합니다.

TRL은 v1.13까지 실험적인 GSPO-token 구현을 제공했습니다. 더 이상 라이브러리의 일부가 아니지만 git history에서 여전히 사용할 수 있습니다. 이는 위의 시퀀스 수준 목적 함수와 t t , 의 이득(advantage)이 변할 때만 달랐으며, TRL은 현재 이를 생성하지 않습니다.

정책 비율: GRPO와 GSPO

GSPO에서는 정책 비율(policy ratio)이 시퀀스 수준에서 정의됩니다. 즉, 현재 정책이 특정 시퀀스를 생성할 확률과 이전 정책이 동일한 시퀀스를 생성할 확률의 비율을 의미합니다.

시퀀스 likelihood는 다음과 같이 정의됩니다: πθ(oi∣q)=∏t=1∣oi∣πθ(oi,t∣q,oi,<t), \pi_\theta (o_i | q) = \prod_{t=1}^{|o_i|} \pi_\theta (o_{i,t} | q, o_{i, < t} ),

여기서 πθ \pi_\theta 은 정책 π \pi 이고, 매개변수는 θ\theta, oi o_i 입니다. i i -번째 출력 시퀀스 o o 이고 oi,to_{i,t} 은 이 시퀀스의 t t -번째 토큰이며, q q 은 입력 쿼리입니다. 시퀀스 가능성 비율 si(θ) s_i (\theta) 은 다음과 같이 정의됩니다: si(θ)=(πθ(oi∣q)πθold(oi∣q))1∣oi∣ s_i (\theta) = \left(\frac{\pi_\theta (o_i | q)}{\pi_{\theta_{old}} (o_i | q)} \right)^{\frac{1}{|o_i|}}

지수 1∣oi∣ \frac{1}{|o_i|} 은 시퀀스 길이 정규화를 나타내며, 시퀀스 가능도에서 시퀀스 길이의 영향을 최소화합니다. 다른 표현으로, 토큰 확률의 기하 평균을 계산하여 다양한 길이의 시퀀스 간 공정한 비교를 보장합니다.

GSPO가 시퀀스 수준에서 정책 비율을 정의하는 반면, GRPO는 토큰 수준에서 작동합니다. 구체적으로, GRPO는 시퀀스의 각 토큰에 대해 중요도 비율을 계산합니다: wi,t(θ)=πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t) 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})}

이 토큰 수준의 비율은 공유된 이점 A^i \hat{A}_i , 과 결합되며, GRPO 목적 함수는 시퀀스 전체에서 각 토큰을 독립적으로 클리핑하고 최적화합니다.

Geometric-Mean Policy Optimization

📜 논문: https://huggingface.co/papers/2507.20673

Geometric-Mean Policy Optimization(GMPO)는 산술 평균 대신 토큰 수준의 중요도 비율의 기하 평균을 최대화하는 GRPO 변형입니다. 기하 평균은 이상치 비율에 훨씬 덜 민감하므로, 정책 업데이트가 더 안정적이고 훨씬 넓은 클리핑 범위를 허용합니다. 클리핑은 로그 공간에서 토큰별로 적용되며, 이점의 부호에 따라 한쪽 방향으로 적용됩니다(표준 PPO 신뢰 영역). 여기서 중요한 점은, 기하 평균을 취하기 전에 클리핑이 수행된다는 것입니다. 이것이 GMPO를 GSPO(importance_sampling_level="sequence")와 구별하는 요소로, GSPO는 평균화 이후에 시퀀스 수준의 비율을 클리핑합니다.

GMPO 목적함수는 GRPO의 토큰별 산술 평균을 (클립된) 토큰 비율의 기하 평균으로 대체합니다: JGMPO(θ)=Eq,{oi}[1G∑i=1G(∏t=1∣oi∣min⁡[wi,t(θ)sgn⁡(A^i), clip⁡(wi,t(θ)sgn⁡(A^i),ϵ1,ϵ2)]sgn⁡(A^i))1∣oi∣A^i] \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]

여기서 wi,t(θ) w_{i,t}(\theta) 토큰별 중요도 비율입니다. 실제로는 수치적 안정성을 위해 곱셈과 클리핑을 로그 공간에서 계산하며, 클립 범위 (ϵ1,ϵ2)=(e−0.4,e0.4) (\epsilon_1, \epsilon_2) = (e^{-0.4}, e^{0.4}) 은 탐색을 장려하기 위해 GRPO/DAPO보다 현저히 넓게 설정됩니다.

TRL에는 실험적 구현이 제공되며, 실험적 - 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: 대규모 오픈소스 LLM 강화 학습 시스템

📜 논문: https://huggingface.co/papers/2503.14476

DAPO 알고리즘에는 5가지 핵심 구성 요소가 포함되어 있습니다:

  • 너무 긴 필터링
  • Clip-Higher
  • Soft Overlong Punishment
  • 토큰 수준 손실
  • Dynamic Sampling (⚠️ TRL에서 지원되지 않음)

논문의 설정을 재현하려면 이 구성을 사용하세요:

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

LLM의 긴 사슬 추론(CoT)을 쉽게 이해하기

📜 논문: https://huggingface.co/papers/2502.03373

이 논문은 긴 체인 오브 스코트 RL을 연구하며 두 가지 상호 보완적인 규칙 기반 보상을 소개합니다:

  • 코사인 길이 스케일 보상(get_cosine_scaled_reward(), 부록 C.1)은 완성 길이에 따라 정확도 보상을 스케일링합니다. 즉, 정답인 완성은 짧을수록 더 높은 보상을, 오답인 완성은 길수록 더 적은 패널티를 부여하여 탐색을 유지합니다.
  • 길이 shaping 하에서 보상 해킹 전략으로 나타나는 퇴화적이고 반복적인 완성물을 억제하는 n-gram 반복 패널티(get_repetition_penalty_reward(), 부록 C.2).

두 가지가 함께 사용되도록 설계되었습니다:

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: 전역 분산 강화 학습을 통해 학습된 추론 모델

📜 논문: https://huggingface.co/papers/2505.07291

INTELLECT-2는 권한이 없는 컴퓨트 기여자로 구성된 동적이고 이질적인 스웜을 통해 완전히 비동기적인 RL을 사용하여 320억 파라미터 언어 모델의 전 세계 분산 강화 학습 훈련을 처음 수행한 것입니다. 저자들은 표준 GRPO 훈련 레시피에 대한 수정 사항을 제안하며, 여기에는 훈련 안정성을 높이기 위한 양방향 GRPO 클리핑이 포함됩니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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: 오픈 추론 모델

📜 논문: https://huggingface.co/papers/2505.22312

Skywork-OR1은 GRPO로 학습된 오픈 추론 모델 계열입니다. 해당 논문에서는 적응적 엔트로피 제어를 소개합니다. GRPO 목적 함수에 엔트로피 정규화 항 −α·H(π_θ)가 추가되며, 계수 α는 각 옵티마이저 단계마다 자동으로 조정됩니다. 모델의 토큰당 평균 엔트로피가 목표치 이하로 떨어지면 탐색을 장려하기 위해 α가 증가하고, 그렇지 않으면 감소합니다. 보너스는 엔트로피가 목표치 이하일 때만 적용됩니다. 이 적응적 엔트로피 제어를 재현하려면 다음 구성을 사용하세요:

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

80/20 규칙을 넘어: 고엔트로피 소수 토큰이 LLM 추론을 위한 효과적인 강화 학습을 주도합니다

📜 논문: https://huggingface.co/papers/2506.01939

고 엔트로피를 가진 소수의 토큰은 CoT 경로에서 추론의 “분기점” 역할을 하여 RLVR의 탐색과 성능 향상을 주도하는 반면, 저 엔트로피의 다수 토큰은 학습에 거의 기여하지 않거나 오히려 방해가 됩니다. RLVR는 주로 고 엔트로피 토큰을 조정하여 베이스 모델의 전체적인 엔트로피 패턴을 대부분 유지합니다. 따라서 80/20 법칙에 도달하게 되며, Qwen3 모델의 경우 엔트로피가 가장 높은 토큰의 20%만 사용하여 학습하는 것이 전체 그래디언트 업데이트와 동등하거나 이를 뛰어넘는 성능을 보입니다.

이 논문의 주요 결과는 vanilla DAPO를 사용합니다(⚠️ TRL에서는 Dynamic Sampling을 지원하지 않습니다). 주요 결과를 재현하려면 다음 구성을 사용하세요:

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: R1-Zero 유사 학습 이해하기: 비판적 관점

📜 논문: https://huggingface.co/papers/2503.20783

R1-Zero 학습에 대한 연구는 RL 성능에 대한 사전 학습의 영향을 분석하고, 토큰 효율성을 향상시키기 위해 Dr. GRPO를 제안하며, AIME 2024에서 우수한 정확도를 달성합니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

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
)

Part I: 트릭인가 함정인가? LLM 추론을 위한 RL 심층 분석 (Lite PPO)

📜 논문: https://huggingface.co/papers/2508.08221

이 논문의 저자들은 다음 조합이

  1. 전체 배치에서 계산된 표준 편차로 보상을 스케일링하고
  2. 토큰 총 개수에 걸쳐 손실을 집계

vanilla PPO 손실을 사용하여 critic-free 정책의 학습 능력을 활용할 수 있습니다. 그들의 결과는 이 단순한 조합이 일관되게 성능을 향상시켜 GRPO 및 DAPO와 같은 전략을 능가함을 보여줍니다.

TRL은 이러한 학습을 활용하여 GRPO 모델을 학습시키는 것을 지원합니다:

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

을 사용할 때, 손실은 배치 내의 총 토큰 수에 대해 집계되지만, 누적된 배치에 대해서는 집계되지 않는다는 점에 유의하세요. 자세한 내용은 GRPO Trainer - Loss types를 참조하세요.

Truncated Importance Sampling

📰 블로그: https://fengyao.notion.site/off-policy-rl

📜 논문: https://huggingface.co/papers/1606.02647

온라인 정책 학습 방법은 일반적으로 학습 백엔드와 분리된 최적화된 추론 프레임워크(예: vLLM)를 rollout 생성에 사용합니다. 이로 인해 rollout-학습 불일치가 발생하며, 다음 PPO 목적 함수에서 이를 확인할 수 있습니다: Ea∼πinference(θold)[min⁡(πtraining(a,θ)πtraining(a,θold) A^,  clip(πtraining(a,θ)πtraining(a,θold), 1−ϵ, 1+ϵ) A^)] \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] }

비록 πinference \textcolor{red}{\pi_{\text{inference}}} 과 πtraining \textcolor{blue}{\pi_{\text{training}}} 이 동일한 모델 매개변수를 공유하더라도 θ \theta , 매우 다른 토큰 확률을 생성할 수 있습니다. 이러한 예상치 못한 동작은 on-policy 가정을 암묵적으로 깨뜨리고, 학습을 조용히 off-policy로 전환시킵니다.

Truncated Importance Sampling(TIS)은 importance-sampling 보정을 통해 모델 업데이트를 조정하여 이 문제를 해결합니다. 앞서 언급한 PPO 목적 함수의 기울기 계산은 다음과 같이 됩니다. Ea∼πinference(θold)[clip(πtraining(a,θold)πinference(a,θold),Cmin⁡,Cmax⁡)⏟truncated importance ratio⋅∇θmin⁡(πtraining(a,θ)πtraining(a,θold) A^,  clip(πtraining(a,θ)πtraining(a,θold), 1−ϵ, 1+ϵ) A^)] \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] }

여기서 Cmin⁡ C_{\min} 그리고 Cmax⁡ C_{\max} 는 하이퍼파라미터입니다. TIS는 GRPO에 구현되어 있으며, vllm_importance_sampling_mode 항을 포함하는 truncate, 변형, 예를 들어 "sequence_truncate" 또는 "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
)

마스크 중요성 샘플링

📰 블로그: https://ringtech.notion.site/icepop

📜 논문: https://huggingface.co/papers/2510.18855

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

Masked Importance Sampling(MIS)은 Truncated Importance Sampling 과 동일한 문제를 해결하지만, 클리핑 대신 마스킹을 사용합니다. MIS는 불일치가 범위 [Cmin⁡,Cmax⁡] [C_{\min}, C_{\max}] [Cmin​,Cmax​]를 벗어나는 업데이트를 폐기함으로써 보다 단호한 입장을 취합니다. [Cmin⁡,Cmax⁡] [C_{\min}, C_{\max}] .

Ea∼πinference(θold)[1[Cmin⁡≤πtraining(a,θold)πinference(a,θold)≤Cmax⁡]⋅πtraining(a,θold)πinference(a,θold)⏟masked importance ratio⋅∇θmin⁡(πtraining(a,θ)πtraining(a,θold) A^,  clip(πtraining(a,θ)πtraining(a,θold), 1−ϵ, 1+ϵ) A^)] \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는 GRPO에 구현되어 있으며, "mask"라는 용어가 포함된 vllm_importance_sampling_mode 변형, 예를 들어 "sequence_mask" 또는 "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
)

에서 AsyncGRPOTrainer, 에서는 이전 log-probabilities가 샘플러의 것이므로, 비율은 학습된 정책과 샘플러 사이에 직접 계산되며, [Cmin⁡,Cmax⁡] [C_{\min}, C_{\max}] 범위 밖의 토큰은 손실 함수에서 제외됩니다. 기본적으로 활성화되어 있습니다:

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

시퀀스 수준 중요성 샘플링

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

학습-추론 분포 시프트를 보정하는 이론적으로 원리적인 방법은 위 두 논문 Truncated Importance Sampling과 Masked Importance Sampling에서 소개된 중요도 샘플링(importance sampling)입니다. 그러나 기울기가 편향되지 않도록 유지하고 안정적인 학습을 보장하기 위해서는 수식 형식의 선택이 매우 중요합니다.

이 연구는 시퀀스 수준 중요성 샘플링이 학습-추론 불일치를 해결하는 올바른 접근 방식임을 보여줍니다. 토큰 수준 중요성 샘플링은 시퀀스 수준 비율보다 분산이 낮지만 편향을 도입하므로, 자기회귀 모델에는 적합하지 않다고 주장됩니다. 토큰 수준 기울기 추정기는 Ex∼D, y∼πθinference(⋅∣x)[R(x,y) ⋅ ∑t=0∣y∣−1πθtraining(yt ∣ x,y<t)πθinference(yt ∣ x,y<t) ∇θlog⁡πθtraining(yt ∣ x,y<t)] \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] 올바르고 편향 없는 정책 기울기 추정기는 생성된 전체 시퀀스(트래젝토리)에 단일 중요성 비율을 적용합니다 y y , 시퀀스 수준 IS 추정기는 다음과 같습니다: Ex∼D, y∼πθinference(⋅∣x)[πθtraining(y∣x)πθinference(y∣x) R(x,y) ∇θlog⁡πθtraining(y∣x)] \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은 vllm_importance_sampling_mode 구성 매개변수를 통해 Importance Sampling의 세분화 수준을 노출하며, "sequence_*" 모드는 시퀀스 수준의 importance sampling 비율을, "token_*" 모드는 토큰별 비율을 구현합니다.

강화 학습 스케일링의 기술

📜 논문: https://huggingface.co/papers/2510.13786

대규모 언어 모델에서 강화 학습의 스케일링을 분석하고 예측하기 위한 프레임워크를 정의하는 체계적인 연구로, 컴퓨트 효율에 영향을 미치는 주요 설계 선택 사항을 식별하고 ScaleRL이라는 모범 사례 레시피를 제안합니다.

다음 구성을 사용하여 GRPOTrainer로 ScaleRL 레시피를 부분적으로 재현할 수 있습니다:

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
)

둘 다 필요: 당신의 GRPO는 비밀스럽게 DPO입니다

📜 논문: https://huggingface.co/papers/2510.00977

GRPO의 효과성이 큰 그룹 크기를 통한 정확한 이점 추정에서가 아니라 암시적 대조적 목적 함수에서 비롯됨을 보여줍니다. 이를 통해 GRPO와 DPO 사이의 형식적 연결을 확립하며, 여기서 그룹 크기는 대조적 목적 함수의 몬테카를로 추정치에만 영향을 미칩니다. 저자들은 2개의 롤아웃만 사용하여 16-GRPO와 동등한 성능을 훨씬 낮은 학습 비용으로 달성하는 2-GRPO를 소개합니다. GRPOTrainer에서 num_generations=2를 사용하여 TRL에서 활용됩니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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

Soft Adaptive Policy Optimization

📜 논문: https://huggingface.co/papers/2511.20347

Soft Adaptive Policy Optimization(SAPO)은 하드 클리핑을 부드러운 온도 제어 게이트로 대체하여 오프폴리시 업데이트를 적응적으로 감쇠하면서도 유용한 학습 신호를 보존합니다. GSPO와 GRPO와 비교할 때, SAPO는 시퀀스 일관성과 토큰 적응성을 모두 갖추고 있습니다. GSPO와 마찬가지로 SAPO는 시퀀스 수준의 일관성을 유지하지만, 그 부드러운 게이트는 GSPO에서 사용되는 취약한 하드 클리핑 밴드를 피하는 연속적인 신뢰 영역을 형성합니다.

논문의 설정을 재현하려면 이 구성을 사용하세요:

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: 오픈 대규모 언어 모델의 한계를 넓히다

📜 논문: https://huggingface.co/papers/2512.02556

DeepSeek-V3.2 기술 보고서는 GRPO의 성능을 향상시키기 위한 여러 기법을 소개합니다. TRL에서는 다음을 구현했습니다:

  • 무편향 KL 추정치 Unbiased KL Estimate, 는 중요도 샘플링 비율을 사용하여 K3 추정치(원본 GRPO 구현에서 사용됨)를 보정하여 현재 정책 πθ \pi_\theta 과 행동 정책 πold \pi_{\text{old}} . DKL ⁣(πθ(oi,t) ∥ πref(oi,t))=πθ(oi,t∣q,oi,<t)πold(oi,t∣q,oi,<t)(πref(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)−log⁡πref(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)−1). \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).

이 기능은 기본적으로 활성화되어 있습니다(GRPOConfig에서 use_bias_correction_kl=True), 따라서 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"
)
  • 정책이 성능이 낮은(부정적 이점) 그리고 이전 정책에서 크게 벗어난(높은 KL 발산) 시퀀스를 무시하여 학습을 안정화시키는 Off-Policy Masking

오프-폴리시 바이너리 마스크 Mi,t\textcolor{red}{M_{i,t}} 은 다음과 같이 정의됩니다: Mi,t={0if A^i,t<0and1∣oi∣∑t=1∣oi∣log⁡πθold(oi,t∣q,oi,<t)πθ(oi,t∣q,oi,<t)>δ1otherwise \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}

이 마스크는 다음과 같이 GRPO 손실에 적용됩니다: LGRPO(θ)=−1G∑i=1G1∣oi∣∑t=1∣oi∣[min⁡(πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t)A^i,t, clip(πθ(oi,t∣q,oi,<t)πθold(oi,t∣q,oi,<t),1−ϵ,1+ϵ)A^i,t)Mi,t−βDKL[πθ∥πref]] \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]

이 기능을 활성화하려면 off_policy_mask_threshold (에 해당하는 δ \textcolor{blue}{\delta} ) 을(를) GRPOConfig:

from trl import GRPOConfig

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

논문에서는 사용된 δ \textcolor{blue}{\delta} 값을 명시하지 않지만, 좋은 시작점은 δ=0.5 \textcolor{blue}{\delta} = 0.5 . 입니다. 학습이 너무 보수적이거나 너무 많은 시퀀스가 마스킹된 경우, 값을 높일 수 있습니다. 참고로, δ=1.0 \textcolor{blue}{\delta} = 1.0 은 토큰당 평균 로그 비율 발산이 1 nat에 해당하며, 즉 이 임계값을 초과하는 시퀀스에서 이전 정책이 현재 정책보다 평균적으로 e1≈2.7 e^1 \approx 2.7 배 더 높은 확률로 이러한 토큰을 생성했습니다.

  • top-k/top-p 샘플링의 편향을 유지하지 않는 Keep Sampling Mask 전략은, 샘플러가 잘림된 지지집합 Si,t \textcolor{red}{\mathcal{S}_{i,t}} , 에서 각 토큰을 추출하므로, 정책 로그-확률도 동일한 지지집합 위에서 재정규화됩니다: log⁡πθ(oi,t∣q,oi,<t)=zoi,t−log⁡∑v∈Si,tezv. \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}.

이를 무시하면 중요도 비율이 낮게 편향되고, 그라디언트가 샘플러가 절대 추출하지 않는 토큰에 확률 질량을 계속 밀어 넣어 학습이 붕괴됩니다. AsyncGRPOTrainer는 이를 지원합니다. top_p < 1.0, top_k > 0 또는 min_p > 0.0인 경우, 롤아웃 워커는 vLLM(>= 0.28, --return-sampling-mask --enable-scale-out으로 시작)에서 각 토큰의 서포트를 기록하고 트레이너는 이를 기준으로 재정규화합니다:

from trl import AsyncGRPOConfig

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

vLLM의 colocate 모드(>= 0.28)에서 GRPOTrainer도 이를 지원합니다. top_k > 0이고 중요도 샘플링 보정이 활성화된 상태(기본값)에서 vLLM은 각 토큰의 support를 반환하고, trainer는 이를 기준으로 재정규화합니다:

from trl import GRPOConfig

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

GDPO: 다중 보상 RL 최적화를 위한 그룹 보상 분리 정규화 정책 최적화

📜 논문: https://huggingface.co/papers/2601.05242

GDPO는 다중 보상 훈련을 위해 설계된 강화 학습 최적화 방법입니다. 기존 접근 방식은 다중 보상 환경에서 일반적으로 Group Relative Policy Optimization(GRPO)을 적용하지만, 저자들은 이것이 보상 이점의 붕괴를 초래하여 훈련 신호의 해상도를 낮추고 불안정하거나 실패한 수렴을 유발한다고 지적합니다. GDPO는 개별 보상에 대한 보상 정규화를 분리하여 이러한 문제를 해결하며, 상대적 차이를 보존하고 보다 충실한 선호 최적화를 가능하게 합니다. 다중 보상 RL 훈련에 GDPO를 사용하려면 단순히 다음을 설정하십시오:

개수 N N 의 보상과 그룹당 G G 개의 샘플에 대해, GDPO는 각 보상을 독립적으로 정규화합니다: An(i,j)=rn(i,j)−mean{rn(i,1),…,rn(i,G)}std{rn(i,1),…,rn(i,G)}+ϵ 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}

정규화된 그룹 이점은 보상을 기준으로 집계됩니다: A(i,j)=∑n=1NwnAn(i,j) A^{(i,j)} = \sum_{n=1}^{N} w_n A_n^{(i,j)}

최종 배치별 정규화는 다음을 생성합니다: A^(i,j)=A(i,j)−meani′,j′{A(i′,j′)}stdi′,j′{A(i′,j′)}+ϵ \hat{A}^{(i,j)} = \frac{A^{(i,j)} - \text{mean}_{i',j'}\{A^{(i',j')}\}}{\text{std}_{i',j'}\{A^{(i',j')}\} + \epsilon}

여기서 meani′,j′{A(i′,j′)} \text{mean}_{i',j'}\{A^{(i',j')}\} 그리고 stdi′,j′{A(i′,j′)} \text{std}_{i',j'}\{A^{(i',j')}\} 는 배치 내 모든 그룹에 대한 통계량을 나타냅니다.

from trl import GRPOConfig


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

이 메서드는 학습에 보상 함수가 하나 이상 포함될 때만 효과가 있습니다.

저자들은 실험-"Aha" 순간에서 확인할 수 있듯이, 커뮤니티가 GRPO 대비 GDPO의 효과성을 빠르게 검증할 수 있도록 slurm 없이 쉽게 사용할 수 있는 학습 예제를 제공합니다.

Length-Unbiased Sequence Policy Optimization: Revealing and Controlling Response Length Variation in RLVR

📜 논문: https://huggingface.co/papers/2602.05261

Length-Unbiased Sequence Policy Optimization(LUSPO)은 각 시퀀스의 손실을 그 길이에 따라 스케일링하여 GSPO를 수정합니다. 이를 통해 GSPO의 더 긴 응답을 불리하게 평가하는 기울기 편향을 교정합니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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: 안정적 오프폴리시 LLM 훈련을 위한 변분 시퀀스 레벨 소프트 정책 최적화

📜 논문: https://huggingface.co/papers/2602.10693

VESPO는 정책의 노후화, 비동기 업데이트, 학습-추론 불일치로 인한 오프-폴리시 RL의 학습 불안정성을 해결합니다. 휴리스틱 토큰 레벨 클리핑(GRPO)이나 시퀀스 길이 정규화(GSPO)에 의존하는 대신, VESPO는 변분 프레임워크에서 원리적으로 재형성 커널을 유도합니다. 실제로 이는 길이 편향을 도입하지 않으면서 극단적인 시퀀스 레벨 중요도 가중치를 부드럽게 억제하는 매끄럽고 비대칭적인 Gamma 가중 함수를 제공합니다. LVESPO(θ)=−Eτ∼μ[W(τ)k⋅exp⁡(λ(1−W(τ)))⏟ϕ(W) detached ⋅A(τ)⋅log⁡πθ(τ)] \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]

여기서 W(τ)=πθ(τ)μ(τ) W(\tau) = \frac{\pi_\theta(\tau)}{\mu(\tau)} 은 시퀀스 수준의 중요도 비율(importance ratio)이고, ϕ(W) \phi(W) 은 계산 그래프에서 분리(detach)되어 그라디언트 스케일링 계수로 사용됩니다.

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은 Off-policy 강화 학습을 안정화합니다

📜 논문: https://huggingface.co/papers/2609.20807

학습-추론 불일치 상황에서 점수 ∇θlog⁡πθ \nabla_\theta \log \pi_\theta 는 샘플러 μ \mu , 에 대해 평균이 0이 되지 않으므로, 모든 업데이트가 이득(advantage)에 비례하는 양만큼 정책을 샘플러 방향으로 이동시킵니다. Score centering은 모든 위치에서 해당 기댓값을 차감하여, 일정한 이득이 더 이상 정책을 이동시키지 않도록 합니다: ∇θL=−Eo∼μ[A^(f(rt)∇θlog⁡πθ(ot)−Ev∼μ[f(rv)∇θlog⁡πθ(v)])],rv=πθ(v)μ(v), \nabla_\theta \mathcal{L} = - \mathbb{E}_{o \sim \mu} \left[ \hat{A} \left( f(r_t) \nabla_\theta \log \pi_\theta(o_t) - \mathbb{E}_{v \sim \mu} \left[ f(r_v) \nabla_\theta \log \pi_\theta(v) \right] \right) \right], \quad r_v = \frac{\pi_\theta(v)}{\mu(v)},

가중치 f f 의 중요도 Masked Importance Sampling: f(r)=r f(r) = r 내부에서 [Cmin⁡,Cmax⁡] [C_{\min}, C_{\max}] 그리고 0 0 외부에서는 0입니다. 내부 기대값은 각 위치에서 샘플러가 보고하는 로그 확률을 가진 가장 가능성이 높은 토큰에 대해 계산됩니다. 나머지 어휘에 대해서는 샘플러를 나머지 질량으로 재조정된 학습된 정책으로 간주합니다.

AsyncGRPOTrainer의 기본 목적이며, 이 트레이너의 rollout worker는 vLLM에서 생성된 모든 토큰의 상위 log-probabilities를 요청합니다:

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

최적 이점 회귀

experimental.a2po.A2POTrainer와 관련된 논문.

Optimal Advantage Regression을 활용한 LLM 추론을 위한 RL 가속

📜 논문: https://huggingface.co/papers/2505.20686

A*-PO(최적 이득 회귀)는 온라인 크리틱과 다중 샘플 그룹 롤아웃을 모두 피하는 LLM 추론을 위한 2단계 RL 방법입니다. 1단계에서는 참조 정책 샘플로부터 최적 가치 V*(x) = β·log E_{y∼π_ref}[exp(r(x, y)/β)]를 오프라인으로 추정합니다. 2단계에서는 제곱 오차 회귀 손실 (β·log(π(y|x)/π_ref(y|x)) − (r(x, y) − V*(x)))²을 사용하여 프롬프트당 단일 생성으로 온-정책 업데이트를 수행합니다. 이를 통해 PPO/GRPO/REBEL보다 더 빠른 학습과 더 낮은 피크 메모리를 달성합니다. 이 방법은 이진 검증 가능 보상을 가정하며 참조 정책의 Pass@K를 초과할 수 없습니다. A2PO를 참조하십시오. 공식 코드는 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()

Direct Preference Optimization

DPOTrainer와 관련된 논문

Direct Preference Optimization: 당신의 언어 모델은 비밀리에 보상 모델입니다

📜 논문: https://huggingface.co/papers/2305.18290

Direct Preference Optimization(DPO)은 인간의 선호도를 기반으로 정책 학습을 직접 최적화하여, 인간 피드백 기반 강화학습(RLHF)보다 더 효율적이고 성능이 좋게 언어 모델을 미세 조정합니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

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: 인간 피드백을 통한 시퀀스 가능성 보정

📜 논문: https://huggingface.co/papers/2305.10425

Sequence Likelihood Calibration (SLiC)은 언어 모델에서 인간 선호도를 학습하기 위해 Reinforcement Learning from Human Feedback (RLHF)보다 효과적이고 더 간단한 대안임이 입증되었습니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

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
)

이러한 매개변수는 게시된 버전에만 표시됩니다

통계적 거부 샘플링이 선호 최적화를 개선

📜 논문: https://huggingface.co/papers/2309.06657

제안 RSO, 통계적 거부 샘플링을 통해 더 강한 선호 쌍을 선택하여 오프라인 선호 최적화를 강화합니다. DPO/SLiC를 보완합니다. 또한 다음과 같이 정의된 새로운 손실을 도입합니다: Lhinge-norm(πθ)=E(x,yw,yl)∼D[max⁡(0,  1−[γlog⁡πθ(yw∣x)πref(yw∣x)−γlog⁡πθ(yl∣x)πref(yl∣x)])] \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]

RSO 필터링된 데이터와 hinge-norm 손실을 사용하여 학습하려면 다음 코드를 사용할 수 있습니다:

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

Reverse KL을 넘어: 다양한 발산 제약으로 Direct Preference Optimization 일반화

📜 논문: https://huggingface.co/papers/2309.16240

일반적인 f-발산으로 일반적인 역 KL 정규화자를 대체하여 DPO를 확장한 f-DPO를 제안합니다. 이를 통해 모드 탐색과 질량 커버링 동작 사이의 트레이드오프를 조절할 수 있습니다(예: 포워드 KL, JS, α-발산). 유일한 변경 사항은 DPO의 로그 비율 마진을 다음으로 대체하는 것입니다. f′ 점수: Lf-DPO(πθ)=E(x,yw,yl)∼D[−log⁡σ(βf′(πθ(yw∣x)πref(yw∣x))−βf′(πθ(yl∣x)πref(yl∣x)))] \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]

여기서 f′ f' 은 선택된 (( f \)-발산을 정의하는 볼록 함수의 미분입니다.

재현 방법:

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

인간 선호도에서 학습을 이해하기 위한 일반적인 이론적 패러다임

📜 논문: https://huggingface.co/papers/2310.12036

인간 선호도에서 학습하는 것은 쌍별 선호도 확률에 대한 단일 KL-정규화 목적 함수로 표현할 수 있습니다. max⁡π;E[Ψ(p∗(y≻y′∣x))]−τKL(π∣∣πref), \max_\pi ;\mathbb{E}\big[\Psi\left(p^*(y \succ y' \mid x)\right)\big] - \tau\mathrm{KL}(\pi||\pi_{\text{ref}}),

이는 RLHF와 DPO가 다음 logit 선택에 해당하는 특수한 경우임을 보여줍니다. Ψ \Psi . 이 논문은 해당 logit 변환이 거의 결정론적인 선호도를 증폭시키고 KL 정규화를 효과적으로 약화시켜 과적합을 유발한다고 설명합니다. Identity 변환(IPO) 을 사용하면 Bradley–Terry 보상 모델을 가정하지 않고 선호도를 직접 최적화함으로써 이러한 문제를 피할 수 있습니다. 논문의 설정을 재현하려면 다음 구성을 사용하세요:

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
)

이러한 매개변수는 게시된 버전에만 표시됩니다

언어 모델 정렬의 효율적이고 정확한 최적화를 향해

📜 논문: https://huggingface.co/papers/2402.00856

이 논문은 DPO와 같은 직접 선호도 방법이 잘못된 KL 방향으로 최적화되어 선호도 포착이 흐려진다는 점을 보여주며, forward KL 근사 대신 reverse KL 확률 매칭을 활용하여 인간 선호도 정렬 목적 함수를 정확히 최적화하는 효율적인 방법으로 EXO를 제안합니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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

명시적 보상을 활용한 언어 모델의 노이즈 대비 정렬

📜 논문: https://huggingface.co/papers/2402.05369

이 논문은 언어 모델 정렬을 노이즈-컨트라스트 분류 문제로 재정의하고, 응답에 대한 보상 유도 목표 분포를 일치시켜 명시적인 보상(또는 선호도)으로부터 정책을 학습하는 InfoNCA를 제안하며, DPO가 이에 대한 특별한 이진 사례임을 보여줍니다. 이후, 순수하게 상대적(컨트라스트) 목적 함수에서 관찰되는 가능성 붕괴를 방지하기 위해 절대 가능성 항을 추가하는 NCA를 소개합니다.

쌍별 선호도(pairwise preferences)의 경우, 선택/거절(chosen/rejected)을K=2 K=2 , 점수를 정의하고r=β(log⁡πθ−log⁡πref) r=\beta(\log\pi_\theta-\log\pi_{\text{ref}}) , NCA 선호도 손실을 적용합니다−log⁡σ(rw)−12log⁡σ(−rw)−12log⁡σ(−rl) -\log\sigma(r_w)-\tfrac12\log\sigma(-r_w)-\tfrac12\log\sigma(-r_l) .

논문의 설정을 재현하려면 이 구성을 사용하세요:

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: 노이즈 피드백으로 언어 모델 정렬

📜 논문: https://huggingface.co/papers/2403.00409

DPO는 노이즈가 있는 인간 선호도에서 레이블 플립이 목적 함수에 편향을 일으켜 성능이 저하됩니다. Robust DPO는 단순한 노이즈 모델 하에서 DPO 손실을 해석적으로 디바이스하여 이 문제를 해결하며, 증명 가능한 보장을 제공합니다. Lrobust(πθ)=(1−ε)LDPO(yw,yl)−εLDPO(yl,yw)1−2ε \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}

Where LDPO \mathcal{L}_{\text{DPO}} is the DPO loss defined in Direct Preference Optimization: Your Language Model is Secretly a Reward Model and ε \varepsilon is the probability of a label flip.

이 단일 보정은 노이즈가 있는 선호 데이터를 깨끗한 DPO 목적함수의 편향 없는 추정자로 변환합니다.

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
)

대형 언어 모델 정렬을 위한 바이너리 분류기 최적화

📜 논문: https://huggingface.co/papers/2404.04656

이론적 분석과 새로운 알고리즘인 Binary Classifier Optimization을 통해 바이너리 피드백 신호를 사용하여 대규모 언어 모델의 정렬을 설명하고 향상시킵니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

BCO는 언어 모델 정렬을 최적의 보상 가중 분포에 대한 행동 클로닝으로 재정의하여, 이론적 근거를 유지하면서 RL을 피하는 단순한 지도 학습 목표를 제공합니다. 보상 데이터가 쌍이 아닌 경우와 쌍별 선호 데이터 모두를 지원하며, 보상 이동 불변 공식화를 통해 선호 설정에서는 DPO 스타일의 손실로 축소됩니다.

쌍별 선호도 설정에서 BCO 손실은 다음과 같이 정의됩니다: Lbco_pair(πθ)=E(x,yw,yl)∼D[−log⁡σ(β[(log⁡πθ−log⁡πref)(yw)−(log⁡πθ−log⁡πref)(yl)])] \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]

이 설정에서 해당 논문을 재현하려면 이 구성을 사용하세요:

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

Learn Your Reference Model for Real Good Alignment

📜 논문: https://huggingface.co/papers/2404.09656

Trust Region DPO(TR-DPO)는 학습 중에 reference policy를 업데이트하며, Anthropic HH 및 TLDR 데이터셋에서 DPO 대비 효과성을 입증했습니다. GPT-4를 이용한 자동 평가 기준으로 최대 19%까지 DPO를 능가하며, 일관성, 정확성, 세부 수준, 유용성, 무해성을 향상시켰습니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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

반복적 추론 선호 최적화

📜 논문: https://huggingface.co/papers/2404.19733

Iterative RPO는 체인 오브 스캔드 후보를 반복적으로 생성하고, 정답과 오답을 기반으로 선호 쌍을 구성한 뒤, DPO + NLL 목적 함수로 학습함으로써 추론 능력을 향상시킵니다. 추가된 NLL 항은 승리하는 추론 과정을 실제로 생성하는 것을 학습하는 데 핵심적인 역할을 합니다.

TRL은 "sigmoid"(DPO)와 "sft"(NLL)을 혼합하여 DPO + 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,
)

해당 논문은 반복 루프를 사용합니다. 각 반복에서 현재 모델로 CoT 후보를 재생성하고, 새로 생성된 선호 쌍으로 재학습을 수행합니다. TRL은 이 루프를 자동으로 처리하지 않습니다.

언어 모델 정렬을 위한 셀프-플레이 선호 최적화

📜 논문: https://huggingface.co/papers/2405.00675

언어 모델 정렬을 위한 자기 대국(self-play) 방법인 SPPO는 상수 합 게임 설정에서 내시 균형 정책을 근사하여 제한된 데이터로 다른 접근법을 능가하는 최첨단 성능을 달성합니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

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

RLHF에서 과최적화를 증명 가능하게 완화하기: SFT 손실이 암묵적으로 적대적 정규화자

📜 논문: https://huggingface.co/papers/2405.16436

Regularized Preference Optimization(RPO)은 DPO 손실을 SFT 손실과 결합하여 RLHF의 과최적화 문제를 완화하며, 정책이 부자연스럽게 높은 프록시 보상을 가진 행동을 선택하는 것을 증명 가능하게 방지합니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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
)

Optimal Transport를 통한 LLM의 분포적 선호 정렬

📜 논문: https://huggingface.co/papers/2406.05882

Optimal Transport를 통한 정렬(AOT)은 양의 샘플 분포와 음의 샘플 분포 간의 확률적 우위(stochastic dominance) 위반을 패널티로 부과하여 대규모 언어 모델을 분포적으로 정렬하며, 정렬 벤치마크에서 최첨단 성능을 달성합니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

from trl import DPOConfig

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

또는, 페어링되지 않은 버전의 경우:

from trl import DPOConfig

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

논문에는 추가적인 하이퍼파라미터가 없습니다.

대형 언어 모델을 활용하여 최적화 알고리즘을 발견하고, 이를 대형 언어 모델에 적용하기

📜 논문: https://huggingface.co/papers/2406.08414

LLM 기반 방법은 성능이 우수한 선호도 최적화 알고리즘을 자동으로 발견하며, 이를 통해 로지스틱 손실과 지수 손실을 결합한 새로운 알고리즘인 DiscoPOP이 도출되었습니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

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: 가중치 선호 최적화로 RLHF 강화

📜 논문: https://huggingface.co/papers/2406.11827

WPO는 정책 확률에 따라 선호 쌍을 가중하여 DPO 스타일 학습의 오프-폴리시 갭을 줄입니다. 손실 함수는 다음과 같습니다: LWPO=−E(x,yw,yl)∼D[w(x,yw)w(x,yl)log⁡p(yw≻yl∣x)] \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]

여기서 가중치 w(x,y) w(x, y) 은 다음과 같이 정의됩니다: w(x,y)=exp⁡(1∣y∣∑t=1∣y∣log⁡πθ(yt∣x,y<t)∑v∈Vπθ(v∣x,y<t)2) 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)

논문의 설정을 재현하려면 이 구성을 사용하세요:

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

Anchored Preference Optimization and Contrastive Revisions: 정렬의 불완전 명세 문제 해결

📜 논문: https://huggingface.co/papers/2408.06266

CLAIR와 APO는 더 많은 대비 선호 쌍과 제어된 정렬 목표를 통해 LLM 정렬을 강화하여 GPT4-turbo에 근접한 모델 성능을 달성합니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

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

이러한 매개변수는 게시된 버전에만 표시됩니다

Direct Preference Optimization의 길이 민감도 완화

📜 논문: https://huggingface.co/papers/2409.06411

표준 DPO가 본질적으로 길이에 민감하여 모델이 지나치게 길거나 장황한 생성물을 생성하도록 유도하는 경향이 있음을 보여줍니다. 이 논문은 LD-DPO를 제안하며, 이는 더 긴 응답을 짧은 응답 길이까지의 공유 접두사와 초과 꼬리로 나누어 시퀀스 로그-확률 집계 방식을 수정하고, 꼬리 부분에 가중치 계수를 적용하여 가중치를 낮추는 방법입니다. α∈[0,1] \alpha \in [0,1] : log⁡πθ(ylong∣x)=log⁡πθ(y1:lp∣x)+α⋅log⁡πθ(ylp+1:l∣x,y1:lp),lp=min⁡(∣yw∣,∣yl∣). \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|).

설정 α=1 \alpha=1 이면 표준 DPO를 복원하며, 더 작은 α \alpha 값은 선호 품질을 유지하면서 다변성을 줄입니다. 최적의 α \alpha 값은 모델 패밀리와 base 모델인지 instruct 모델인지에 따라 달라지지만, 논문에서는 α=0.5 \alpha=0.5 을 강력한 기본 시작점으로 제안합니다.

from trl import DPOConfig

training_args = DPOConfig(
    ld_alpha=0.5,
)

혼합 선호 최적화를 통한 멀티모달 대규모 언어 모델의 추론 능력 향상

📜 논문: https://huggingface.co/papers/2411.10442

Mixed Preference Optimization(MPO)를 도입하여 MLLM의 멀티모달 추론을 개선합니다. 이는 표준 사전 학습 및 SFT 이후 발생하는 분포 이동과 약한 Chain-of-Thought(CoT) 문제를 해결합니다. 이 논문은 (1) 고품질 멀티모달 선호 데이터를 위한 자동화 파이프라인인 MMPR과 (2) CoT를 강화하는 결합된 선호 목적 함수(쌍별 + BCO 스타일 + SFT)인 MPO를 기여합니다. InternVL2-8B-MPO는 MathVista에서 67.0을 달성하여 InternVL2-8B보다 8.7 높았으며, 10배 더 큰 InternVL2-76B와 유사한 성능을 보였습니다. TRL에서 복합 손실을 사용하여 DPOConfig를 통해 사용됩니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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: 오픈 언어 모델 후학습의 한계를 넓히다

📜 논문: https://huggingface.co/papers/2411.15124

길이 정규화 시그모이드 손실은 Bradley-Terry 손실을 계산하기 전에 선택된(chosen) 및 거부된(rejected) 로그 비율 점수를 각자의 완성 길이(completion length)로 나누어 DPO의 길이 편향을 해결합니다. 이 토큰별 정규화는 SimPO (부록 I “DPO w/ LN” 아블레이션)에서 참조 모델이 없는(reference-free) 설정을 위한 평균 로그 확률 보상으로 도입되었으며, 이후 Tülu 3 (섹션 4.3)와 같은 후학습(post-training) 레시피에서 표준 참조 모델 기반 DPO에 채택되었습니다. 손식은 다음과 같습니다: Lsigmoid_norm=−log⁡σ ⁣(β(1∣yw∣log⁡πθ(yw∣x)πref(yw∣x)−1∣yl∣log⁡πθ(yl∣x)πref(yl∣x))), \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), 다음과 같이 설정할 수 있습니다:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid_norm",
)

노이즈 선호도를 가진 대규모 언어 모델의 편향 없는 정렬

📜 논문: https://huggingface.co/papers/2607.03248

이 논문은 선호 노이즈를 확률 ε \varepsilon 로 라벨이 뒤집히는 것으로 모델링하고, 이 전이를 역전시켜 노이즈 있는 선호로 학습된 정책이 깨끗한 선호와 동일한 최적점을 가지도록 합니다. TRL은 이 논문에서 α-UDPO라고 불리는, 결과적으로 도출된 Unbiased DPO(UDPO) 손실의 정규화 형태를 구현합니다: LUDPO=−αlog⁡ez+aez+1,z=β(log⁡πθ(yw∣x)πref(yw∣x)−log⁡πθ(yl∣x)πref(yl∣x)),a=ε1−ε,α=1+a1−a, \mathcal{L}_{\text{UDPO}} = -\alpha \log \frac{e^{z} + a}{e^{z} + 1}, \quad z = \beta \left( \log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)} \right), \quad a = \frac{\varepsilon}{1 - \varepsilon}, \quad \alpha = \frac{1 + \sqrt{a}}{1 - \sqrt{a}},

이는 a=0 a = 0 . 상수 α \alpha 는 DPO와 마찬가지로 최대 기울기 크기를 1로 유지합니다. Robust DPO, 와 달리, 이 논문은 실제 플립 확률이 가정된 ε \varepsilon ((Corollary 4.7)보다 낮을 때 최적값이 편향되지 않음을 보여줍니다. 따라서 ε \varepsilon 을 정확히 추정할 필요가 없습니다. TRL에서 ε \varepsilon 은 label_smoothing. 을 사용하려면 a=0.8 a = 0.8 , 논문에서 실무자에게 권장하는 값입니다:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="udpo",
    label_smoothing=4 / 9,  # flip probability ε, for a = ε / (1 - ε) = 0.8 as recommended in Appendix B.1 of the paper
    beta=0.1,  # 0.1 for HH and UltraFeedback, 0.5 for TL;DR (Appendix B.1 of the paper)
    learning_rate=5e-6,  # 5e-6 for Llama-3.2-3B and Qwen3-1.7B, 1e-6 for 8B models (Appendix B.1 of the paper)
    num_train_epochs=3,  # Appendix B.1 of the paper
    per_device_train_batch_size=16,  # total batch size of 128 on 8 GPUs (Appendix B.1 of the paper)
    max_grad_norm=10.0,  # Appendix B.1 of the paper
    warmup_ratio=0.1,  # Appendix B.1 of the paper
)

Kahneman–Tversky 최적화

KTOTrainer와 관련된 논문

KTO: Prospect Theoretic Optimization을 통한 모델 정렬

📜 논문: https://huggingface.co/papers/2402.01306

KTO는 prospect theory에서 정렬 목적 함수를 유도하며, binary 인간 피드백(좋아요/싫어요)에서 직접 학습합니다. DPO 스타일 방법과 동등하거나 그 이상의 성능을 내면서 불균형하거나 노이즈가 있는 신호를 잘 처리합니다. 논문의 설정을 재현하려면 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()

Supervised Fine-Tuning

SFTTrainer와 관련된 논문

TailSFT: 필터링된 Fine-Tuning이 Post-Training 성능을 향상시킵니다

📜 논문: https://huggingface.co/papers/2608.25756

TailSFT는 초기 정책 대비 길이 정규화 손실이 가장 많이 개선된 시퀀스를 필터링하여 후속 강화 학습에서의 응답 커버리지를 유지합니다. tail_sft_gsm8k 예제는 SFTTrainer를 서브클래스로 만들어 논문의 분산 선택 배치 필터링을 구현합니다. 학습 전에 각 시퀀스의 초기 정책 손실을 기록하고, 모든 선택 배치에서 예제를 독립적으로 필터링합니다.

python examples/tail_sft_gsm8k/tail_sft.py

지연 없는 EMA: 편향 보정 반복 평균화 기법

📜 논문: https://huggingface.co/papers/2508.00180

Bias-Corrected Exponential Moving Average(BEMA)는 확률적 요소를 줄이고 편향을 제거하여 언어 모델의 fine-tuning 안정성과 효율성을 향상시킵니다. 논문에서 설명한 대로 SFT와 함께 BEMA를 사용하려면 BEMACallback을 사용할 수 있습니다:

from trl import BEMACallback, SFTTrainer

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

SFT의 일반화에 관하여: 보상 교정을 통한 강화 학습 관점

📜 논문: https://huggingface.co/papers/2508.05629

Dynamic Fine-Tuning(DFT)은 그래디언트를 동적으로 재스케일링하여 Large Language Models(LLM)의 일반화 성능을 향상시키며, 표준 Supervised Fine-Tuning(SFT)보다 우수한 성능을 보이고 오프라인 강화 학습에서 경쟁력 있는 결과를 보여줍니다. LDFT(θ)=E(x,y)∼D[−∑t=1∣y∣sg(πθ(yt∣y<t,x))  log⁡πθ(yt∣y<t,x)] \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]

여기서 sg(⋅) \text{sg}(\cdot) 는 stop-gradient 연산자입니다. 논문에서 설명한 대로 SFT와 함께 DFT를 사용하려면 loss_type="dft" 인수를 사용할 수 있습니다:

from trl import SFTConfig

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

논문의 설정을 정확히 따르려면 다음 구성을 사용할 수 있습니다(4.1절 참고). 저자들은 하이퍼파라미터가 매우 민감하지 않다고도 언급합니다(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,
)

트렁케이션을 줄이면 언어 모델링이 개선됩니다

📜 논문: https://huggingface.co/papers/2404.10830

이 논문은 LLM 학습에 사용되는 표준 concatenate-then-split 전처리(packing_strategy="wrapped")가 많은 문서를 임의로 잘라내어 학습에 해를 끼친다는 것을 보여줍니다. Best-Fit Decreasing bin-packing 알고리즘을 사용하여 문서 청크를 컨텍스트 윈도우에 패킹함으로써 잘림을 크게 줄이면서 높은 토큰 활용도를 유지하고 모델 성능을 향상시키는 방법을 제안합니다. TRL은 이를 SFTConfig의 "bfd_split" 패킹 전략으로 구현했습니다. 패킹에 대한 자세한 내용은 SFT 문서를 참고하세요.

from trl import SFTConfig

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

통합 텍스트-텍스트 Transformer를 활용한 전이 학습의 한계 탐구

📜 논문: https://huggingface.co/papers/1910.10683

T5 논문은 전이 학습을 위한 통합 텍스트-텍스트 프레임워크를 제안하고 시퀀스 패킹(3.5.2절)을 소개합니다. 여러 짧은 시퀀스를 고정 길이의 블록으로 묶어 패딩을 줄이고 학습 효율을 높이는 기법입니다. TRL에서는 SFTConfig와 SFTTrainer를 통해 패킹을 지원합니다. TRL에서 패킹을 사용하려면 다음 구성을 사용하세요:

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

Uniform Diffusion Models의 재매개변수화: Leave-One-Out Denoiser

📜 논문: https://huggingface.co/papers/2605.22765

일정한 이산 확산 모델의 경우, 일반적인 플러그인 교차 엔트로피는 단순한 디노이저를 학습하지 않습니다E[X0∣Xt] \mathbb{E}[X_0 \mid X_t] 대신 각 토큰을 예측할 때 해당 토큰 자체의 손상된 값을 사용하지 않는 leave-one-out(LOO) 후验 분포를 사용합니다. 이 논문은 디노이저, LOO 후验 분포, 스코어 사이의 정확한 변환을 유도하므로, 동일한 교차 엔트로피로 네트워크를 두 가지 매개변수화 방식 중 하나로 학습할 수 있습니다. logitsfθ f_\theta 의 softmax가 LOO 후验 분포를 매개변수화할 때, 손실에 사용되는 디노이저는 다음과 같습니다 dθ(xt,t)ℓ=softmax ⁣(fθ(xt,t)ℓ+log⁡ ⁣(1+K αt1−αt xtℓ)), 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),

즉, 관찰된 토큰의 logit에 가산 보정을 적용하는 방식이며K K 은 어휘 크기이고αt \alpha_t 은 균일한(forward) 노이즈가 깨끗한 토큰을 유지할 확률입니다. 해당 논문에서는 LOO 매개변수화가 생성 품질을 일관되게 향상시킨다고 보고합니다. 블록 확산(block-diffusion) SFT 예시 examples/sft_diffusion_gemma/sft_diffusion_gemma.py 은 다음을 통해 두 매개변수화를 모두 제공합니다. --model_prediction_type (mean 은 일반 디노이저를 의미하며 공개된 체크포인트와 일치하고, 또는 mean_loo 은 LOO 사후 분포를 의미합니다):

torchrun --nproc_per_node 8 examples/sft_diffusion_gemma/sft_diffusion_gemma.py \
    --deepspeed examples/deepspeed_configs/zero3.json \
    --use_peft \
    --gradient_checkpointing \
    --model_prediction_type mean_loo \
    --output_dir diffusiongemma-26B-A4B-it-gsm8k-lora

대형 Transformer 모델에서 활성화 재계산 감소

📜 논문: https://huggingface.co/papers/2205.05198

Full activation checkpointing은 backward 단계에서 checkpoint된 영역의 모든 op를 attention을 포함하여 다시 계산합니다. 이는 메모리를 유지하는 데 드는 비용에 비해 재계산 비용의 대부분을 차지하는 op가 소수(그중 하나가 attention)뿐인 상황에서도 마찬가지입니다. 해당 논문에서 제안한 selective activation recomputation은 전체 영역 대신 이러한 비용이 높은 op만 checkpoint합니다. TRL은 이를 SFTTrainer의 selective activation checkpointing(SAC)으로 구현하며, forward pass 동안 attention 출력을 저장하여 backward에서 이를 다시 계산하지 않도록 합니다:

from trl import SFTConfig

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

매개변수 효율적 미세 조정(PEFT)

PEFT를 TRL과 함께 사용하는 일반적인 세부 사항은 PEFT Integration 가이드를 참고하세요.

LoRA: 대규모 언어 모델의 저순위 적응

📜 논문: https://huggingface.co/papers/2106.09685

Low-Rank Adaptation(LoRA)은 대규모 사전 학습 모델에서 성능을 유지하거나 개선하면서 학습 가능한 매개변수 수와 GPU 메모리 사용량을 줄입니다. TRL은 PEFT library를 통해 LoRA를 통합하며, peft_config 인자에 LoraConfig를 전달하여 모든 TRL trainer에서 쉽게 활성화할 수 있습니다. SFTTrainer와 함께 LoRA를 사용하는 예시는 다음과 같습니다:

from trl import SFTTrainer
from peft import LoraConfig

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

DoRA: 가중치 분해 저순위 적응

📜 논문: https://huggingface.co/papers/2402.09353

Weight-Decomposed Low-Rank Adaptation(DoRA)은 LoRA의 성능을 향상시킬 수 있으며, 특히 낮은 랭크에서 그 효과가 큽니다. DoRA는 사전 학습된 가중치를 크기(magnitude)와 방향(direction)이라는 두 구성 요소로 분해합니다. 방향은 일반적인 LoRA로 처리되고, 크기는 학습 가능한 매개변수입니다. TRL은 PEFT library를 통해 DoRA를 통합하며, LoraConfig에 use_dora=True를 설정하여 쉽게 활성화할 수 있습니다.

from peft import LoraConfig

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

Reinforce Leave-One-Out

RLOOTrainer와 관련된 논문

기본으로 돌아가기: LLM에서 인간 피드백을 통한 학습을 위한 REINFORCE 스타일 최적화 재조명

📜 논문: https://huggingface.co/papers/2402.14740

RLOO는 leave-one-out 베이스라인을 사용하여 분산을 줄이는 REINFORCE의 변형입니다. 배치 내의 모든 다른 샘플의 평균과 각 샘플을 비교하여 보상을 계산하며, 표준 REINFORCE보다 더 안정적인 기울기를 제공합니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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++: 대규모 언어 모델 정렬을 위한 단순하고 효율적인 접근법

📜 논문: https://huggingface.co/papers/2501.03262

REINFORCE++는 고전적인 REINFORCE 알고리즘의 강화된 변형으로, PPO의 핵심 최적화 기법을 채택하되 critic 네트워크의 필요성을 제거합니다. 이는 배치 전체에 걸친 전역 이점 정규화를 통해 단순성, 향상된 학습 안정성 및 계산 오버헤드 절감을 달성합니다. 해당 논문의 설정을 RLOOTrainer로 근사하려면 다음 구성을 사용하세요:

from trl import RLOOConfig

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

Odds Ratio Preference Optimization

experimental.orpo.ORPOTrainer와 관련된 논문

ORPO: 참조 모델 없이 수행하는 일체형 선호 최적화

📜 논문: https://huggingface.co/papers/2403.07691

참조 모델이 없는 단일 블록 odds ratio preference optimization 알고리즘(ORPO)의 도입은 supervised fine-tuning 과정에서의 preference alignment를 향상시켜, 주요 평가에서 더 큰 모델을 능가합니다. 해당 논문의 설정을 재현하려면 이 구성을 사용하세요:

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

Contrastive Preference Optimization

experimental.cpo.CPOTrainer와 관련된 논문

Contrastive Preference Optimization: 기계 번역에서 LLM 성능의 한계를 확장하기

📜 논문: https://huggingface.co/papers/2401.08417

기계 번역을 위한 선호 기반 방법인 Contrastive Preference Optimization(CPO)를 소개합니다. CPO는 SFT에서처럼 참조 문장을 모방하는 대신, 적절하지만 완벽하지 않은 번역을 피하도록 모델을 학습시킵니다. 이 논문은 MT에서 SFT의 한계(참조 문장 품질 문제 포함)를 분석하고, 22K개의 병렬 문장만으로 ALMA에 CPO를 적용하면 WMT’21–WMT’23에서 WMT 대회 우승자 및 GPT-4와 동등하거나 그 이상의 성능을 보이는 ALMA-R를 얻을 수 있음을 보여줍니다. TRL에서 experimental.cpo.CPOTrainer를 통해 사용됩니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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: 기준 없는 보상과 함께한 단순 선호 최적화

📜 논문: https://huggingface.co/papers/2405.14734

SimPO는 시퀀스의 평균 로그 확률을 암묵적 보상(reward)으로 사용하여 참조 모델이 필요 없도록 하는, 더 단순하면서도 효과적인 선호도 최적화 방법론입니다. Bradley-Terry 목적 함수에 목표 보상 마진을 도입하여 승리 응답과 패배 응답 사이의 마진이 더 커지도록 유도합니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

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 — LLM 정렬에서 보상 형태가 중요합니다

📜 논문: https://huggingface.co/papers/2501.03884

AlphaPO는 표준 log reward를 넘어선 보상 함수의 형태를 변경하는 데 alpha 매개변수를 활용하는 새로운 Direct Alignment Algorithms(DAAs) 방법입니다. AlphaPO는 likelihood displacement와 over-optimization에 대한 세밀한 제어를 유지하는 데 도움이 됩니다. 논문의 설정을 재현하려면 이 구성을 사용하세요:

from trl.experimental.cpo import CPOConfig

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

삼중 선호 최적화

Triple Preference Optimization: 단일 단계 최적화로 더 나은 정렬 달성

📜 논문: https://huggingface.co/papers/2405.16681

Triple Preference Optimization(TPO)를 소개합니다. TPO는 프롬프트당 세 가지 응답, 즉 골드(reference) 완료, 선호(chosen) 완료, 비선호(rejected) 완료와 LLM을 정렬하는 선호 학습 방법론으로, 단일 최적화 단계에서 이를 수행합니다. TPO는 (chosen, rejected) 쌍에 대한 대비적 목적 함수와 골드 응답에 대한 감독형 NLL 항을 결합하여, 별도의 SFT 단계와 DPO에서 사용되는 참조 모델의 필요성을 제거합니다. TRL은 v1.16까지 TPOTrainer로 구현을 제공했으며, 현재는 라이브러리에 포함되지 않고 git 히스토리에서만 사용할 수 있습니다.

Nash Learning from Human Feedback

Nash Learning from Human Feedback

📜 논문: https://huggingface.co/papers/2312.00886

Nash-MD를 소개합니다. Nash-MD는 표준 RLHF의 대안으로, 두 입력에 조건부화된 선호 모델을 학습하고 Nash 균형에서 정책을 찾습니다. 보상 모델을 대상으로 최적화하는 대신, Nash-MD는 경쟁 정책의 응답보다 일관되게 선호되는 응답을 생성하는 정책을 산출합니다. 이 알고리즘은 mirror descent 원리에 기반합니다. TRL은 v1.13까지 NashMDTrainer로 구현을 제공했으며, 현재는 라이브러리에 포함되지 않고 git history에서만 사용할 수 있습니다.

보상 모델링

RewardTrainer와 관련된 논문

도움이 되나요, 아니면 무리 짓기인가요? 보상 모델 앙상블은 보상 해킹을 완화하지만 제거하지는 않습니다

📜 논문: https://huggingface.co/papers/2312.09244

이 논문은 중심화된 보상 모델을 직접 학습하도록 설계된 보조 손실 함수를 제안했습니다. 이 보조 손실은 보상들의 제곱 합을 최소화하여 모델이 자연스럽게 평균이 0인 출력을 생성하도록 유도하고, 이를 통해 결정 부족 문제를 해결합니다. L(θ)=−E(x,y+,y−)∼D[log⁡σ(rθ(x,y+)−rθ(x,y−))−η⋅(rθ(x,y+)+rθ(x,y−))2]. \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].

이 보조 손실을 RewardTrainer와 함께 사용하려면 RewardConfig에서 center_rewards_coefficient 인수를 다음과 같이 사용할 수 있습니다:

from trl import RewardConfig

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

Llama 2: 오픈 파운데이션 및 파인튜닝된 챗 모델

📜 논문: https://huggingface.co/papers/2307.09288

이 논문에서 저자들은 선호도 등급을 4점 척도로 분해하여(e.g., 훨씬 더 좋음) ) 보상 모델에 더 유용한 피드백을 제공하도록 제안합니다. 이는 손실 함수에 마진을 추가하여, 선호도 등급이 높은 쌍에 대해 보상 모델이 점수 차이를 더 크게 부여하도록 유도하는 방식으로 이루어집니다. L(θ)=−E(x,y+,y−,m)∼D[log⁡σ(rθ(x,y+)−rθ(x,y−)−m)]. \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].

margin 컬럼을 데이터셋에 추가하여 손실에 마진을 추가할 수 있습니다. 다음 예제는 해당 논문에서 “Margin Small” 설정을 구성하는 방법을 보여줍니다.

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)

온라인 직접 선호 최적화

experimental.online_dpo.OnlineDPOTrainer와 관련된 논문

온라인 AI 피드백을 통한 직접적인 언어 모델 정렬

📜 논문: https://huggingface.co/papers/2402.04792

Online DPO는 모델로부터 실시간 피드백을 제공하여 선호 기반 직접 정렬 방법을 개선하며, DPO와 PPO 방법 모두보다 우수한 성능을 보입니다.

Online DPO를 사용하려면 experimental.online_dpo.OnlineDPOTrainer를 사용할 수 있습니다.

탐색적 선호 최적화: 샘플 효율적 RLHF를 위한 암시적 Q* 근사 활용

📜 논문: https://huggingface.co/papers/2405.21046

XPO는 새로운 원리 기반 탐색 보상을 DPO 목적 함수에 추가하여, 알고리즘이 초기 모델과 인간 피드백 데이터의 지원 범위 밖을 탐색할 수 있도록 합니다. 이는 온라인 DPO에 대한 한 줄의 변경 사항이며, 샘플 효율성이 증명되고 근최적 언어 모델 정책으로 수렴합니다. TRL은 v1.13까지 XPOTrainer로 구현을 제공했으며, 현재는 라이브러리에 포함되지 않고 git 히스토리에서만 사용할 수 있습니다.

디스틸레이션

교사 모델의 도움을 받아 학생 모델을 학습하는 것과 관련된 논문.

언어 모델의 온-폴리시 증류: 자체 생성된 실수로부터 학습

📜 논문: https://huggingface.co/papers/2306.13649

Generalized Knowledge Distillation(GKD)을 소개합니다. GKD는 고정된 시퀀스 집합 대신, 학생 모델이 스스로 생성한 출력에 대해 교사의 피드백을 받아 학습함으로써 오토레그레시브 모델의 KD에서 발생하는 분포 불일치 문제를 해결합니다. GKD는 유연한 손실 함수(예: 학생이 교사를 완전히 일치시킬 수 없는 경우 KL를 넘어가는 함수)를 지원하며, RL 파인튜닝(RLHF)과 통합됩니다. 해당 논문에서는 요약, 번역, 산술 추론, 인스트럭션 튜닝에 대한 결과를 보고합니다. experimental.gkd.GKDTrainer를 통해 TRL에서 사용되며, 이 트레이너는 논문의 온/오프 폴리시 혼합(lmbda)을 노출합니다. DistillationTrainer는 항상 온-폴리시인 경우에 동일한 일반화된 JSD 목적 함수를 구현합니다. 논문의 설정을 재현하려면 다음 구성을 사용하세요:

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: LLM 후학습에서 기능 통합을 위한 다중 교사 온-폴리시 증류

📜 논문: https://huggingface.co/papers/2606.30406

학습 후 과정을 세 단계로 구성합니다: 일반 SFT, 도메인별 독립적인 RL 훈련(도메인당 하나의 전문가, 예: 수학은 검증 가능한 답변 RL, 소프트웨어 엔지니어링은 샌드박스 에이전트 RL), 그리고 동결된 도메인 전문가들을 단일 통합 학생으로 융합하는 최종 MOPD 단계입니다. 이 최종 단계에서 학생은 프롬프트마다 하나의 궤적을 생성하며, 각 궤적은 해당 도메인의 교사에게만 전달됩니다(교사 간 평균화나 앙상블은 수행되지 않습니다). 학생은 해당 궤적에 걸쳐 해당 단일 교사의 분포에 대한 토큰별 역 KL을 최소화하도록 업데이트됩니다. TRL에서는 이 세 번째, 즉 융합 단계를 구현한 experimental.async_distillation.AsyncDistillationTrainer를 통해 사용됩니다. teacher_server_urls에 두 개 이상의 항목을 전달하면 MOPD가 활성화되며, 각 행의 teacher_id 컬럼이 해당 행을 점수화할 (이미 훈련된) 교사를 선택합니다. 논문의 역 KL 목적 함수와 일치하도록 beta=1.0을 사용하세요.

온-폴리시 증류의 위치 편향

📜 논문: https://huggingface.co/papers/2606.22600

OPD의 위치 편향을 해결하기 위해 Importance-Weighted On-Policy Distillation(IW-OPD)을 소개합니다. IW-OPD는 누적된 teacher-student prefix 불일치에 따라 샘플링된 토큰의 distillation 업데이트를 재가중합니다. 초기 토큰은 더 큰 가중치를 유지하고, 높은 drift 이후의 후기 토큰은 가중치가 낮아집니다. distillation_objective="iw_opd"와 함께 TRL의 experimental.iw_opd.IWOPDTrainer에서 사용됩니다.

이 논문은 IW-OPD를 클립된 정책 그라디언트 설정(verl)과 vLLM 롤아웃으로 최적화합니다. IWOPDTrainer는 아래에 나열된 매칭되는 증류 및 롤아웃 설정을 노출합니다. 클리핑 범위 0.2, 듀얼 클립 상수 3.0, 내부 PPO 에포크, 엔트로피 계수, KL 보상 패널티, 보조 KL, 롤아웃 중요도 보정 등 논문 내 정책 최적화 설정은 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
)

온-폴리시 증류

📰 블로그: https://thinkingmachines.ai/blog/on-policy-distillation/

On-Policy Distillation은 학습 데이터의 각 배치에 대해 학생 모델이 롤아웃을 생성하는 과정입니다. 이후 학생 모델과 교사 모델 모두로부터 해당 롤아웃의 각 토큰에 대한 확률 분포를 얻습니다. 그런 다음 학생 모델은 자신의 토큰 분포와 교사 모델의 토큰 분포 사이의 음의 Kullback-Leibler(KL) 발산을 최소화하도록 최적화됩니다.

메서드샘플링보상 신호
Supervised finetuningoff-policydense
강화 학습on-policy희소
온-폴리시 증류on-policydense

On-Policy Distillation은 SFT와 GRPO보다 우수한 성능을 보이며, SFT 과정에서 손실된 일반화 능력을 회복하는 데 사용할 수 있습니다.

또한 on-policy distillation은 더 높은 계산 효율성을 가지며, 제한된 데이터로 학습할 때 과적합에 덜 취약합니다.

TRL을 사용하여 온-폴리시 디스틸레이션으로 모델을 학습하려면 DistillationTrainer와 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
)

대신 experimental.gkd.GKDTrainer와 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
)

온-폴리시 디스틸레이션에는 experimental.gold.GOLDTrainer도 사용할 수 있습니다. Unlocking On-Policy Distillation for Any Model Family를 참고하세요.

모든 모델 패밀리에서 온-폴리시 디스틸레이션 활용

🌐 프로젝트: https://huggingface.co/spaces/HuggingFaceH4/general-on-policy-logit-distillation

General Online Logit Distillation(GOLD)을 소개합니다. GOLD는 서로 다른 토크나이저와 모델 패밀리로 구성된 학생/교사 쌍으로 온-폴리시 디스틸레이션을 확장합니다. GOLD는 토크나이저 간 텍스트 스팬을 정렬하고 Universal Logit Distillation(ULD)을 적용하여 완성 토큰이 누락되지 않도록 할 수 있습니다. experimental.gold.GOLDTrainer를 통해 TRL에서 사용됩니다.

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: 투영 기반 크로스 토크나이저 지식 증류

📜 논문: https://huggingface.co/papers/2605.21699

X-Token은 GOLD 증류 프레임워크를 토크나이저를 공유하지 않는 학생-교사 쌍으로 확장합니다. 이는 오프-폴리시 방법(lmbda=0)입니다: 데이터셋이 완성 텍스트를 제공하고, 학생과 교사 모두 해당 텍스트에 대해 포워드 패스를 실행하며, 두 로짓 간의 크로스-토크나이저 KD 손실이 계산됩니다. 온-폴리시 학생 롤아웃은 필요하지 않습니다. 사전 계산된 희소 투영 행렬 W ∈ ℝ^{V_s × V_t}는 각 학생 토큰을 가장 그럴듯하게 대응하는 교사 토큰으로 매핑하여, 학생 분포를 교사 어휘 공간으로 투영함으로써 두 분포를 직접 비교할 수 있게 합니다. TRL에서 experimental.gold.GOLDTrainer와 함께 xtoken_loss_type="p_kl" 또는 "h_kl"로 사용됩니다.

두 가지 손실 함수가 제공됩니다:

변형xtoken_loss_type설명
P-KL"p_kl"W를 통해 전체 학생 분포를 교사 어휘로 투영하고, 전역 top-k 부분집합에서 forward KL을 계산합니다. 해당 논문의 식 (4)를 구현합니다.
H-KL"h_kl"Hybrid: 이완된 공통 집합(top-1 투영 가중치 ≥ 0.6)에 대한 정규화된 분포에 대해 forward KL을, 드문 토큰에 대해 sorted-L1을 적용합니다. Eq. (3)을 Eq. (5)의 매핑을 사용하여 구현합니다.

참조 구현과 마찬가지로, H-KL은 전체 어휘의 로그 확률을 공통 집합으로 슬라이스하고, P-KL은 재정규화 없이 각 스팬에 대해 교사의 로그 확률을 평균화하므로 KD 항은 음수가 될 수 있습니다. CE와 KD는 각 누적 윈도우에 대해 개별적인 토큰 및 정렬된 스팬 카운트를 사용합니다. 동적 CE/KD 밸런싱과 P-KL top-k 선택은 마이크로배치별로 계산됩니다.

이 구현은 고정된 투영 행렬을 사용합니다. 해당 논문에서는 P-KL을 위해 행렬을 함께 학습하지만, 이 변형은 여기에서 구현되어 있지 않습니다.

examples/xtoken/의 준비 스크립트로 먼저 투영 행렬을 구축합니다. 1단계에서는 teacher tokenizer를 사용하여 student vocab을 다시 토큰화하며, 선택 사항인 --runtime-top-k 플래그를 사용하면 행렬을 한 번에 정렬하고 잘라냅니다(이후 sort_and_cut_projection_matrix.py를 실행하는 것과 동일합니다):

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

그런 다음 예제 스크립트(오프-폴리시, 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

또는 experimental.gold.GOLDConfig의 경로를 직접 전달합니다:

from trl.experimental.gold import GOLDConfig

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

대형 언어 모델의 지식 증류

📜 논문: https://huggingface.co/papers/2306.08543

MiniLLM은 on-policy 지식 증류 방법 중 최초이며, teacher 모델과 student 모델 간의 시퀀스 수준 reverse KLD를 최소화하고 강화 학습을 통해 최적화됩니다.

Think Machine Lab의 On-Policy Distillation의 일반화된 버전으로, 분포 수준의 단일 단계 증류 신호(beta=1인 경우의 GKD와 유사)와 긴 컨텍스트 역방향 KLD 신호를 추가할 수 있는 옵션을 제공합니다.

TRL은 v1.14까지 MiniLLMTrainer라는 이름으로 구현을 제공했으며, 현재는 라이브러리에 더 이상 포함되지 않고 git 히스토리에서만 확인할 수 있습니다.

자기 증류(Self-Distillation)를 통한 강화 학습

📜 논문: https://huggingface.co/papers/2601.20802

Self-Distillation Policy Optimization(SDPO)는 검증 가능한 보상을 활용한 강화 학습을 향상시킵니다. 외부 교사 모델이나 명시적인 보상 모델 없이 풍부한 텍스트 피드백(예: 런타임 오류, 평가자 평가)을 밀도 높은 학습 신호로 변환합니다. SDPO는 피드백 조건이 적용된 현재 모델을 자기 자신으로 간주하고, 피드백에 기반한 다음 토큰 예측을 정책으로 증류합니다. 주목할 점은, SDPO가 스칼라 피드백만 반환하는 표준 RLVR 환경에서도 성공적인 롤아웃을 실패한 시도의 암묵적 피드백으로 활용하여 베이스라인보다 우수한 성능을 보인다는 것입니다.

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

기대되는 데이터셋 열:

  • prompt
  • 선택적 환경 피드백을 위한 privileged_context

자세한 내용은 SDPO Trainer 문서를 참조하세요.

자기 증류(Self-Distillation)는 지속 학습을 가능하게 합니다

📜 논문: https://huggingface.co/papers/2601.19897

Self-Distilled Fine-Tuning (SDFT)은 학습 중에 completions을 생성한 후, 해당 completions의 명시적인 teacher-conditioned view를 student로 역방향으로 distill하여 on-policy self-distillation을 수행합니다. teacher는 teacher_model_kind에 의해 선택되며, "base"(초기 student), "live"(현재 student), 또는 "ema"(지수 평균화된 teacher) 중 하나입니다. teacher prompt는 내부적으로 student의 prompt와 데이터셋의 privileged_context를 조합하여 구성됩니다.

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

기대되는 데이터셋 열:

  • prompt
  • privileged_context에는 추가적인 teacher 전용 정보만 포함

자세한 내용은 SDFT Trainer 문서를 참조하세요.

부끄러울 정도로 단순한 자기 증류가 코드 생성을 개선합니다

📜 논문: https://huggingface.co/papers/2604.01193

Simple Self-Distillation(SSD)은 학습 시점의 temperature와 truncation 설정을 사용하여 모델에서 completions을 샘플링한 후, 검증되지 않은 이러한 원본 샘플에 대해 표준 cross-entropy loss로 fine-tuning을 수행하여 코드 생성을 개선합니다. reward model, verifier, teacher model 또는 reinforcement learning이 필요하지 않습니다. SSD는 컨텍스트에 의존하는 방식으로 토큰 분포를 재구성합니다. 구문상 모호성이 거의 없는 “lock” 위치에서는 방해 요소가 되는 꼬리를 억제하고, 여러 가지 유효한 연속이 가능한 “fork” 위치에서는 다양성을 유지합니다.

TRL은 v1.15까지 SSDTrainer라는 이름으로 구현을 제공했습니다. 현재는 라이브러리에 더 이상 포함되지 않으며, git 히스토리에서만 확인할 수 있습니다.

Softmax과 Cross-Entropy에 대한 수정

📜 논문: https://huggingface.co/papers/2610.31642

고신뢰도 예측에서의 softmax 붕괴와 학생 및 교사의 logits가 거의 일치할 때 발생하는 상쇄를 식별합니다. TRL의 chunked log-probability 및 distillation heads는 target-excluding normalization과 log-space probability differences를 사용하여 작은 gradient를 보존합니다. 이러한 수치적 수정은 DistillationTrainer의 forward KL, reverse KL, generalized JSD에도 자동으로 적용됩니다.

Entropy-preserving reinforcement learning 부록 B.4에서 이전에 고신뢰도 정책 기울기 실패를 식별하고 FP64에서 기울기를 선택적으로 재계산하는 것을 제안했습니다. TRL의 커널은 안정적인 FP32 수식을 사용하여 이러한 기울기를 보존합니다.

부록 B.1에서 논의된 FSDP2의 별도 출력 캐스팅 문제는 Accelerate #4403에서 해결되었습니다. 이전 버전의 Accelerate에서는 FP32 커널 출력을 유지하려면 output_dtype=None을 사용하는 혼합 정밀도 정책이 필요합니다.

다음 예제는 Section 7에서 보고된 하이퍼파라미터를 TRL의 forward-KL 목적 함수에 매핑합니다. 이 목적 함수는 soft-target 교차 엔트로피의 student gradient를 공유합니다. 이는 언어 모델 증류를 보여주는 예시이며, 논문의 모듈러 산술 실험을 재현하는 것이 아닙니다. 논문에서는 student를 teacher의 가중치로 초기화합니다. 이는 config와 독립적으로 모델을 구성할 때 처리해야 합니다. 기타 trainer 기본값은 변경되지 않습니다.

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

분산 학습

ZeRO: 조(Trillion) 파라미터 모델 훈련을 위한 메모리 최적화

📜 논문: https://huggingface.co/papers/1910.02054

ZeRO(Zero Redundancy Optimizer)는 데이터 병렬 및 모델 병렬 학습에서 옵티마이저 상태, 그래디언트, 매개변수를 여러 장치에 걸쳐 분할하여 메모리 중복을 제거합니다. 이 과정에서 낮은 통신량과 높은 계산 세밀도를 유지하므로, GPU 메모리에 맞지 않아 효율적으로 학습할 수 없었던 대규모 모델을 효율적으로 학습할 수 있습니다.

TRL은 DeepSpeed 통합을 통해 ZeRO를 지원합니다. 이를 사용하려면 원하는 설정이 포함된 DeepSpeed 구성 파일을 제공하세요.

{
  "zero_optimization": {"stage": 3},
  "bf16": {"enabled": "auto"},
  "train_batch_size": "auto",
  "train_micro_batch_size_per_gpu": "auto"
}

학습 설정에 deepspeed="zero3.json"을 설정하고, torchrun으로 학습 스크립트를 실행합니다.

torchrun --nproc_per_node 2 train.py
Update on GitHub