Índice de Artigos

Cada artigo abaixo faz link para sua página no Hugging Face. Você também pode ler qualquer um deles pelo terminal com o CLI hf, por exemplo, hf papers read 2402.03300 — especialmente útil para agentes de código.

Group Relative Policy Optimization

Artigos relacionados ao GRPOTrainer.

DeepSeekMath: Levantando os limites do raciocínio matemático em modelos de linguagem abertos

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

Introduz o Group Relative Policy Optimization (GRPO) e demonstra fortes ganhos em raciocínio matemático a partir de pré-treino centrado em matemática mais otimização estilo PPO relativa a grupos. Usado no TRL via 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: Incentivando a capacidade de raciocínio em LLMs por meio de aprendizado por reforço

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

O DeepSeek-R1 atinge um desempenho de raciocínio comparável ao do OpenAI-o1 por meio de um pipeline de múltiplas etapas que transita do aprendizado por reforço (RL) puro para um modelo refinado e alinhado com humanos. Diferentemente de seu antecessor, o DeepSeek-R1-Zero, que usava RL puro em um modelo base, o R1 segue uma evolução estruturada em quatro etapas:

1. Cold Start: o modelo base é ajustado em um pequeno conjunto de dados de alta qualidade e longos Chain-of-Thought (CoT) para fornecer um ponto de partida estável.
2. RL orientado a raciocínio: RL em larga escala é aplicado para aprimorar o desempenho em matemática, codificação e lógica, utilizando recompensas baseadas em regras e uma recompensa de consistência de linguagem para reduzir a mistura de idiomas.
3. Rejection Sampling & SFT: O checkpoint de RL gera 600k amostras de raciocínio por meio de rejection sampling, que são combinadas com 200k amostras não de raciocínio (gerais) para criar um novo conjunto de dados para uma segunda rodada de Supervised Fine-Tuning.
4. RL para todos os Cenários: Um estágio final de RL alinha o modelo às preferências humanas (utilidade e inofensividade) em todos os domínios, mantendo a força de raciocínio.

Destilação: Capacitando Modelos Pequenos

Uma contribuição fundamental do artigo é demonstrar que padrões de raciocínio podem ser destilados de um modelo grande (DeepSeek-R1) para modelos densos menores (por exemplo, as séries Qwen e Llama). A destilação foi encontrada como mais eficaz para modelos pequenos do que treiná-los com RL puro do zero.

Você pode usar o GRPOTrainer para replicar as etapas de raciocínio intensivo deste pipeline.

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

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

GSPO é uma variante do GRPO que calcula os pesos de amostragem de importância no nível da sequência, em vez de por token. Para reproduzir a configuração do artigo, use esta configuração:

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
)

Observe que este método só tem efeito quando o treinamento fica ligeiramente off-policy — por exemplo, quando steps_per_generation > gradient_accumulation_steps ou num_iterations > 1. Caso contrário, ele é efetivamente equivalente a nenhuma modificação.

O TRL lançou uma implementação experimental de GSPO-token até a v1.13; ela não faz mais parte da biblioteca e permanece disponível no histórico do git. Ela diferia do objetivo de nível de sequência acima apenas quando a vantagem varia com $t$, o que o TRL não produz atualmente.

Razão de política: GRPO vs. GSPO

No GSPO, a razão de política é definida no nível da sequência. Em outras palavras, é a razão entre a probabilidade da política atual gerar uma sequência e a probabilidade da política antiga gerar essa mesma sequência.

A verossimilhança da sequência é definida como: $$\pi_\theta (o_i | q) = \prod_{t=1}^{|o_i|} \pi_\theta (o_{i,t} | q, o_{i, < t} ),$$

onde $\pi_\theta$ é a política $\pi$ com parâmetros $\theta$, $o_i$ é a $i$-ésima sequência de saída $o$ e $o_{i,t}$ é o $t$-ésimo token nesta sequência, $q$ é a consulta de entrada. A razão de verossimilhança da sequência $s_i (\theta)$ é definida como: $$s_i (\theta) = \left(\frac{\pi_\theta (o_i | q)}{\pi_{\theta_{old}} (o_i | q)} \right)^{\frac{1}{|o_i|}}$$

O expoente $\frac{1}{|o_i|}$ representa uma normalização pelo comprimento da sequência, minimizando a influência do comprimento da sequência na verossimilhança da sequência. Em outras palavras, ele calcula a média geométrica das probabilidades dos tokens, garantindo uma comparação justa entre sequências de comprimentos variados.

Enquanto o GSPO define a razão de política no nível da sequência, o GRPO opera no nível do token. Especificamente, o GRPO calcula uma razão de importância para cada token na sequência: $$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})}$$

Esse nível de proporção por token é então combinado com uma vantagem compartilhada $\hat{A}_i$, e o objetivo do GRPO aplica clipping e otimiza cada token de forma independente ao longo da sequência.

Otimização de Política de Média Geométrica

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

A Otimização de Política pela Média Geométrica (GMPO) é uma variante do GRPO que maximiza a média geométrica das razões de importância no nível de tokens, em vez da média aritmética. A média geométrica é muito menos sensível a razões atípicas, o que torna a atualização da política mais estável e tolera uma faixa de clipping muito mais ampla. O clipping é aplicado por token, no espaço logarítmico, e é unilateral conforme o sinal da vantagem (a região de confiança padrão do PPO) — crucialmente, antes de a média geométrica ser calculada. É isso que distingue o GMPO do GSPO (importance_sampling_level="sequence"), que aplica o clipping à razão no nível de sequência após a média.

O objetivo do GMPO substitui a média aritmética por token do GRPO pela média geométrica das razões de tokens (com limite): $$\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]$$

onde $w_{i,t}(\theta)$ é a razão de importância por token. Na prática, o produto e o recorte são calculados no espaço logarítmico para estabilidade numérica, e o intervalo de recorte $(\epsilon_1, \epsilon_2) = (e^{-0.4}, e^{0.4})$ é significativamente mais amplo que o de GRPO/DAPO para incentivar a exploração.

O TRL fornece uma implementação experimental, consulte Experimental - 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: Um sistema de aprendizado por reforço para LLMs de código aberto em escala

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

O algoritmo DAPO inclui 5 componentes principais:

• Filtragem de textos longos
• Clip-Higher
• Punição Suave para Excesso de Comprimento
• Perda no nível de token
• Amostragem Dinâmica (⚠️ Não suportado no TRL)

Para reproduzir a configuração do artigo, use esta configuração:

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

Desmistificando o Raciocínio de Cadeia de Pensamento Longa em LLMs

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

Este artigo estuda o RL de cadeia de raciocínio longa e introduz duas recompensas complementares baseadas em regras:

• Uma recompensa de cosseno escalada por comprimento (get_cosine_scaled_reward(), Apêndice C.1) que escala a recompensa de correção pelo comprimento da conclusão: uma conclusão correta é recompensada mais quando é mais curta, enquanto uma conclusão incorreta é penalizada menos quando é mais longa (preservando a exploração).
• Uma penalidade de repetição de n-gramas (get_repetition_penalty_reward(), Apêndice C.2) que desencoraja as conclusões degeneradas e repetitivas que surgem como uma estratégia de burla da recompensa sob o ajuste de comprimento.

Os dois foram projetados para serem usados juntos:

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: Um modelo de raciocínio treinado por meio de aprendizado por reforço descentralizado globalmente

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

INTELLECT-2 é o primeiro treinamento de aprendizado por reforço distribuído globalmente de um modelo de linguagem com 32 bilhões de parâmetros, utilizando RL totalmente assíncrono em um enxame dinâmico e heterogêneo de contribuidores de computação sem permissão. Os autores propõem modificações na receita padrão de treinamento GRPO, incluindo o recorte de dois lados do GRPO para aumentar a estabilidade do treinamento. Para reproduzir a configuração do artigo, use esta configuração:

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: Modelos de Raciocínio Aberto

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

Skywork-OR1 é uma família de modelos de raciocínio abertos treinados com GRPO. O artigo introduz o controle adaptativo de entropia: um termo de regularização de entropia −α·H(π_θ) é adicionado ao objetivo do GRPO, e o coeficiente α é ajustado automaticamente a cada passo do otimizador. Quando a entropia média por token do modelo cai para um valor igual ou inferior a um alvo, α é incrementado para incentivar mais exploração; caso contrário, é decrementado. O bônus é aplicado apenas enquanto a entropia estiver igual ou inferior ao alvo. Para replicar esse controle adaptativo de entropia, use a seguinte configuração:

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

Além da Regra 80/20: Tokens Minoritários de Alta Entropia Impulsionam o Aprendizado por Reforço Eficaz para o Raciocínio de LLMs

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

Uma minoria de tokens com alta entropia atua como “ramificações” de raciocínio no caminho do CoT, impulsionando a exploração e os ganhos de desempenho para o RLVR, enquanto a maioria dos tokens de baixa entropia contribui pouco ou até mesmo impede o aprendizado. O RLVR ajusta principalmente os tokens de alta entropia, preservando em grande parte os padrões gerais de entropia do modelo base. Assim, aplicando a regra 80/20, treinar apenas com 20% dos tokens de maior entropia é comparável ou supera as atualizações de gradiente completo para os modelos Qwen3.

Os principais resultados do artigo usam o DAPO vanilla (⚠️ Dynamic Sampling não é suportado no TRL). Para replicar os principais resultados, use a seguinte configuração:

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: Compreendendo o Treinamento do Tipo R1-Zero: Uma Perspectiva Crítica

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

Um estudo do treinamento do R1-Zero identifica os efeitos do pré-treinamento no desempenho do RL e propõe o Dr. GRPO para melhorar a eficiência de tokens, alcançando precisão superior no AIME 2024. Para reproduzir a configuração do artigo, use esta configuração:

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
)

Parte I: Truques ou Armadilhas? Uma Análise Aprofundada do RL para Raciocínio em LLMs (Lite PPO)

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

Os autores deste artigo constatam que a combinação de:

1. escalonando as recompensas pelo desvio padrão calculado em todo o lote e
2. agregando a perda sobre o número total de tokens

podem desbloquear a capacidade de aprendizado de políticas sem crítico usando a perda PPO padrão. Os resultados deles demonstram que essa combinação simples melhora consistentemente o desempenho, superando estratégias como GRPO e DAPO.

O TRL suporta o uso desses aprendizados para treinar um modelo GRPO por meio de:

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

Observe que, ao usar acúmulo de gradiente, a perda é agregada sobre o número total de tokens no lote, mas não sobre o lote acumulado. Para mais detalhes, consulte o GRPO Trainer - Loss types.

Amostragem de Importância Truncada

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

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

Os métodos de aprendizado de política online geralmente usam um framework de inferência otimizado para a geração de rollout (por exemplo, vLLM) que é separado do backend de treinamento. Isso introduz uma incompatibilidade entre rollout e treinamento, exemplificada no seguinte objetivo PPO: $$\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] }$$

Apesar de $\textcolor{red}{\pi_{\text{inference}}}$ e $\textcolor{blue}{\pi_{\text{training}}}$ compartilharem os mesmos parâmetros do modelo $\theta$, eles podem produzir probabilidades de tokens significativamente diferentes. Esse comportamento inesperado viola implicitamente a suposição de on-policy e transforma silenciosamente o treinamento em off-policy.

O Truncated Importance Sampling (TIS) aborda esse problema adaptando a atualização do modelo por meio de uma correção de amostragem por importância. O cálculo do gradiente do objetivo PPO mencionado acima se torna $$\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] }$$

em que $C_{\min}$ e $C_{\max}$ são hiperparâmetros. O TIS é implementado no GRPO e é ativado ao selecionar uma variante de vllm_importance_sampling_mode que inclui o termo truncate, como "sequence_truncate" ou "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
)

Amostragem de Importância com Máscara

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

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

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

A Amostragem de Importância com Máscara (Masked Importance Sampling, MIS) aborda o mesmo problema que a Amostragem de Importância Truncada , mas substitui o recorte (clipping) por mascaramento. A MIS adota uma postura mais decisiva ao descartar atualizações cuja discrepância fica fora da faixa $[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] }$$

O MIS é implementado para o GRPO e é ativado ao selecionar uma variante de vllm_importance_sampling_mode que inclua o termo "mask", como "sequence_mask" ou "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
)

No AsyncGRPOTrainer, as antigas log-probabilidades são as do sampler, portanto a razão é calculada diretamente entre a política treinada e o sampler, e os tokens fora de $[C_{\min}, C_{\max}]$ são descartados da perda. Essa opção está ativada por padrão:

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
)

Amostragem de Importância em Nível de Sequência

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

A maneira teoricamente fundamentada de corrigir o deslocamento de distribuição entre treinamento e inferência é a amostragem de importância, conforme introduzida nos dois artigos acima Truncated Importance Sampling e Masked Importance Sampling. No entanto, a escolha da formulação é crucial para manter o gradiente não enviesado e garantir um treinamento estável.

Este trabalho mostra que a amostragem de importância em nível de sequência é a abordagem adequada para lidar com a incompatibilidade entre treinamento e inferência. Embora a amostragem de importância em nível de token alcance uma variância menor do que uma razão em nível de sequência, ela introduz viés e, portanto, é considerada inadequada para modelos autoregressivos. O estimador de gradiente em nível de token é $$\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]$$ O estimador de gradiente de política correto e não viesado aplica uma única razão de importância sobre toda a sequência gerada (trajetória) $y$, O estimador de IS em nível de sequência é: $$\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]$$

O TRL expõe o nível de granularidade da Amostragem de Importância por meio do parâmetro de configuração vllm_importance_sampling_mode, em que os modos "sequence_*" implementam uma razão de amostragem de importância no nível da sequência e os modos "token_*" uma razão por token.

A Arte de Escalar o Aprendizado por Reforço

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

Um estudo sistemático que define um framework para analisar e prever o escalonamento do aprendizado por reforço em modelos de linguagem de grande escala, identifica escolhas de design-chave que afetam a eficiência de computação e propõe uma receita de melhores práticas chamada ScaleRL.

Você pode reproduzir parcialmente a receita do ScaleRL usando o GRPOTrainer com as seguintes configurações:

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
)

É preciso de dois: seu GRPO é secretamente DPO

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

Mostra que a eficácia do GRPO decorre de um objetivo contrastivo implícito, e não de uma estimativa precisa da vantagem por meio de tamanhos de grupo grandes. Isso estabelece uma conexão formal entre GRPO e DPO, na qual o tamanho do grupo afeta apenas os estimadores de Monte Carlo do objetivo contrastivo. Os autores introduzem o 2-GRPO — usando apenas dois rollouts — que atinge o desempenho do 16-GRPO com um custo de treinamento significativamente menor. Usado no TRL via GRPOTrainer com num_generations=2. Para reproduzir a configuração do artigo, use esta configuração:

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

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

Soft Adaptive Policy Optimization (SAPO) substitui o recorte rígido por um controle suave, regulado por temperatura, que atenua adaptativamente as atualizações fora da política, preservando os sinais de aprendizado úteis. Em comparação com GSPO e GRPO, o SAPO é coerente na sequência e adaptativo no token. Assim como o GSPO, o SAPO mantém a coerência no nível da sequência, mas seu controle suave forma uma região de confiança contínua que evita a faixa de recorte rígido e frágil utilizada no GSPO.

Para reproduzir a configuração do artigo, use esta configuração:

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: Expandindo a fronteira dos grandes modelos de linguagem abertos

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

O relatório técnico do DeepSeek-V3.2 introduz várias técnicas para aprimorar o desempenho do GRPO. No TRL, implementamos:

• O Unbiased KL Estimate, que corrige o estimador K3 (usado na implementação original do GRPO) para obter uma estimativa não viesada de KL usando a razão de amostragem de importância entre a política atual $\pi_\theta$ e a política de comportamento $\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).$$

Este recurso é ativado por padrão (use_bias_correction_kl=True no GRPOConfig), então você só precisa definir 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"
)

• O Mascaramento Off-Policy, que estabiliza o treinamento ignorando sequências em que a política tem desempenho ruim (vantagem negativa) e divergiu significativamente da política antiga (alta divergência de KL).

A máscara binária off-policy $\textcolor{red}{M_{i,t}}$ é definida como: $$\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}$$

Essa máscara é então aplicada à perda do GRPO da seguinte forma: $$\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]$$

Para habilitar esse recurso, use o off_policy_mask_threshold (correspondente a $\textcolor{blue}{\delta}$) no GRPOConfig:

from trl import GRPOConfig

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

Embora o artigo não especifique um $\textcolor{blue}{\delta}$ valor usado, um bom ponto de partida poderia ser $\textcolor{blue}{\delta} = 0.5$. Se o treinamento parecer conservador demais ou se muitas sequências forem mascaradas, você pode aumentar o valor. Para referência, $\textcolor{blue}{\delta} = 1.0$ corresponde a uma divergência média de log-ratio de 1 nat por token, ou seja, em sequências onde esse limite é excedido, a política antiga tinha em média $e^1 \approx 2.7$ vezes mais probabilidade de gerar esses tokens do que a política atual.

• A Keep Sampling Mask estratégia, que mantém a amostragem top-k/top-p sem viés. O amostrador extrai cada token de um suporte truncado $\textcolor{red}{\mathcal{S}_{i,t}}$, os tokens restantes após o truncamento, de modo que a log-probabilidade da política é renormalizada sobre esse mesmo suporte: $$\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}.$$

Sem ele, a razão de importância é enviesada para baixo e o gradiente continua empurrando a massa de probabilidade para tokens que o amostrador nunca sorteia, o que colapsa o treinamento. Isso é suportado no AsyncGRPOTrainer: com top_p < 1.0, top_k > 0 ou min_p > 0.0, o worker de rollout registra o suporte de cada token do vLLM (>= 0.28, iniciado com --return-sampling-mask --enable-scale-out) e o trainer renormaliza sobre ele:

from trl import AsyncGRPOConfig

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

Também é suportado no GRPOTrainer com vLLM em modo de colocação (>= 0.28): com top_k > 0 e a correção de amostragem de importância habilitada (o padrão), o vLLM retorna o suporte de cada token e o treinador renormaliza sobre ele:

from trl import GRPOConfig

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

GDPO: Group reward-Decoupled Normalization Policy Optimization para otimização RL multi-recompensa

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

GDPO é um método de otimização de aprendizado por reforço projetado para treinamento com múltiplas recompensas. Embora as abordagens existentes comumente apliquem Group Relative Policy Optimization (GRPO) em cenários de múltiplas recompensas, os autores mostram que isso leva ao colapso das vantagens de recompensa, reduzindo a resolução do sinal de treinamento e causando convergência instável ou falha. O GDPO resolve esse problema ao desacoplar a normalização de recompensas entre as recompensas individuais, preservando suas diferenças relativas e permitindo uma otimização de preferências mais fiel. Para habilitar o GDPO para treinamento de RL com múltiplas recompensas, basta definir:

Para um grupo de $N$ recompensas e $G$ amostras por grupo, o GDPO normaliza cada recompensa independentemente: $$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 vantagem de grupo normalizada é então agregada entre as recompensas: $$A^{(i,j)} = \sum_{n=1}^{N} w_n A_n^{(i,j)}$$

A normalização final por lote produz: $$\hat{A}^{(i,j)} = \frac{A^{(i,j)} - \text{mean}_{i',j'}\{A^{(i',j')}\}}{\text{std}_{i',j'}\{A^{(i',j')}\} + \epsilon}$$

Aqui, $\text{mean}_{i',j'}\{A^{(i',j')}\}$ e $\text{std}_{i',j'}\{A^{(i',j')}\}$ denotam estatísticas sobre todos os grupos no lote.

from trl import GRPOConfig


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

Observe que este método só tem efeito quando o treinamento envolve mais de uma função de recompensa.

Os autores fornecem um exemplo de treinamento de fácil uso, sem slurm, que permite à comunidade validar rapidamente a eficácia do GDPO em relação ao GRPO, veja Experimento – momento “Aha”.

Otimização de Política de Sequência Sem Viés de Comprimento: Revelando e Controlando a Variação do Comprimento da Resposta em RLVR

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

A Otimização de Política de Sequência Sem Viés de Comprimento (LUSPO) modifica o GSPO escalando a perda de cada sequência pelo seu comprimento. Isso corrige o viés de gradiente do GSPO que penaliza respostas mais longas. Para reproduzir a configuração do artigo, use esta configuração:

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: Otimização de Política Suave em Nível de Sequência Variacional para Treinamento Estável de LLMs Off-Policy

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

O VESPO aborda a instabilidade de treinamento em RL off-policy causada pela obsolescência da política, atualizações assíncronas e discrepâncias entre treinamento e inferência. Em vez de depender de recorte heurístico em nível de token (GRPO) ou normalização de comprimento de sequência (GSPO), o VESPO deriva um núcleo de remodelação fundamentado a partir de um framework variacional. Na prática, isso resulta em uma função de ponderação Gamma suave e assimétrica que suprime elegantemente pesos de importância extremos em nível de sequência sem introduzir viés de comprimento. $$\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]$$

com $W(\tau) = \frac{\pi_\theta(\tau)}{\mu(\tau)}$ a razão de importância no nível da sequência, e $\phi(W)$ é desconectado do grafo de computação para servir como coeficiente de escala do gradiente.

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
)

Centralização de Score Estabiliza o Aprendizado por Reforço Off-policy

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

Sob um descompasso entre treinamento e inferência, a score $\nabla_\theta \log \pi_\theta$ não tem média zero sob o amostrador $\mu$, portanto, cada atualização desvia a política em direção ao amostrador, por uma quantidade que cresce com a vantagem. O centralização da score subtrai essa expectativa em cada posição, de modo que uma vantagem constante não move mais a política: $$\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)},$$

com $f$ o peso de importância de Amostragem de Importância com Máscara: $f(r) = r$ dentro de $[C_{\min}, C_{\max}]$ e $0$ fora. A expectativa interna é calculada sobre os tokens mais prováveis do amostrador em cada posição, cujas log-probabilidades ele relata; no restante do vocabulário, o amostrador é considerado como a política treinada redimensionada para a massa restante.

É o objetivo padrão do AsyncGRPOTrainer, cujo worker de rollout solicita as principais log-probabilidades de cada token gerado do vLLM:

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
)

Regressão de Vantagem Ótima

Artigos relacionados ao experimental.a2po.A2POTrainer.

Acelerando RL para Raciocínio de LLMs com Regressão de Vantagem Ótima

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

A*-PO (Optimal Advantage Regression) é um método de RL em duas etapas para raciocínio de LLMs que evita tanto um crítico online quanto rollouts de grupo com múltiplas amostras. A Etapa 1 estima o valor ótimo V*(x) = β·log E_{y∼π_ref}[exp(r(x, y)/β)] offline a partir de amostras da política de referência; a Etapa 2 realiza atualizações on-policy com uma única geração por prompt, utilizando uma perda de regressão de erro quadrático (β·log(π(y|x)/π_ref(y|x)) − (r(x, y) − V*(x)))². Isso resulta em treinamento mais rápido e menor memória de pico em comparação com PPO/GRPO/REBEL. O método assume uma recompensa binária verificável e não pode exceder o Pass@K da política de referência. Veja A2PO. O código oficial pode ser encontrado em 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()

Otimização de Preferência Direta

Artigos relacionados ao DPOTrainer

Otimização de Preferência Direta: Seu Modelo de Linguagem é Secretamente um Modelo de Recompensa

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

A Otimização de Preferência Direta (DPO) ajusta modelos de linguagem de forma mais eficiente e com melhor desempenho em comparação ao aprendizado por reforço a partir de feedback humano (RLHF), otimizando diretamente o treinamento da política com base nas preferências humanas. Para reproduzir a configuração do artigo, use esta configuração:

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: Calibração de verossimilhança de sequência com feedback humano

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

A Calibração de Verossimilhança de Sequência (SLiC) é demonstrada como uma alternativa eficaz e mais simples ao Aprendizado por Reforço a partir de Feedback Humano (RLHF) para aprender com preferências humanas em modelos de linguagem. Para reproduzir a configuração do artigo, use esta configuração:

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
)

Esses parâmetros aparecem apenas na versão publicada

Amostragem de Rejeição Estatística Melhora a Otimização de Preferência

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

Propõe RSO, selecionar pares de preferências mais fortes por meio de amostragem de rejeição estatística para aprimorar a otimização de preferências offline; complementa DPO/SLiC. Eles também introduzem uma nova perda definida como: $$\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]$$

Para treinar com dados filtrados por RSO e a perda hinge-norm, você pode usar o seguinte código:

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

Além do KL reverso: Generalizando a Otimização de Preferência Direta com Restrições de Divergência Diversas

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

Propõe o f-DPO, estendendo o DPO ao substituir o regularizador reverse-KL usual por uma f-divergência geral, permitindo equilibrar o comportamento de busca de modo (mode-seeking) e de cobertura de massa (mass-covering) (por exemplo, KL direta, JS, f-divergências). A única mudança é substituir a margem da razão logarítmica do DPO por uma pontuação 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]$$

Onde $f'$ é a derivada da função convexa que define a divergência de f escolhida.

Para reproduzir:

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

Um paradigma teórico geral para entender o aprendizado a partir de preferências humanas

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

Aprendizado a partir de preferências humanas pode ser escrito como um único objetivo regularizado por KL sobre probabilidades de preferência em pares, $$\max_\pi ;\mathbb{E}\big[\Psi\left(p^*(y \succ y' \mid x)\right)\big] - \tau\mathrm{KL}(\pi||\pi_{\text{ref}}),$$

o que revela RLHF e DPO como casos especiais correspondentes à escolha de logit de $\Psi$. O artigo mostra que essa transformação de logit amplifica preferências quase determinísticas e enfraquece efetivamente a regularização KL, explicando o overfitting. Usando a transformação Identidade (IPO) evita essa patologia ao otimizar as preferências diretamente, sem assumir um modelo de recompensa Bradley–Terry. Para reproduzir a configuração do artigo, use esta configuração:

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
)

Esses parâmetros aparecem apenas na versão publicada

Em direção à otimização eficiente e exata do alinhamento de modelos de linguagem

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

O artigo mostra que métodos de preferência direta, como DPO, otimizam a direção errada do KL, levando a uma captura de preferências imprecisa, e propõe o EXO como uma maneira eficiente de otimizar exatamente o objetivo de alinhamento com preferências humanas, aproveitando o casamento de probabilidade do KL reverso em vez de aproximações do KL direto. Para reproduzir a configuração do artigo, use esta configuração:

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

Alinhamento Contrastivo de Ruído de Modelos de Linguagem com Recompensas Explícitas

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

O artigo reformula o alinhamento de modelos de linguagem como um problema de classificação contrastiva de ruído, propondo o InfoNCA para aprender uma política a partir de recompensas explícitas (ou preferências) ao corresponder a uma distribuição-alvo induzida pela recompensa sobre as respostas, e demonstrando que o DPO é um caso binário especial. Em seguida, introduz o NCA, que adiciona um termo de verossimilhança absoluta para evitar o colapso da verossimilhança observado em objetivos puramente relativos (contrastivos).

Com preferências em pares, trate o escolhido/rejeitado$K=2$, defina as pontuações$r=\beta(\log\pi_\theta-\log\pi_{\text{ref}})$, e aplique a perda de preferência NCA$-\log\sigma(r_w)-\tfrac12\log\sigma(-r_w)-\tfrac12\log\sigma(-r_l)$.

Para reproduzir a configuração do artigo, use esta configuração:

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 Robusto Provávelmente: Alinhando Modelos de Linguagem com Feedback Ruidoso

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

O DPO falha com preferências humanas ruidosas, pois a inversão de rótulos introduz viés no objetivo. O Robust DPO corrige isso desviando analiticamente a perda do DPO sob um modelo de ruído simples, com garantias comprováveis. $$\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}$$

Onde $\mathcal{L}_{\text{DPO}}$ é a perda DPO definida em Direct Preference Optimization: Your Language Model is Secretly a Reward Model e $\varepsilon$ é a probabilidade de inversão de rótulo.

Essa única correção transforma dados de preferência ruidosos em um estimador não enviesado do objetivo limpo do 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
)

Otimização de Classificador Binário para Alinhamento de Modelos de Linguagem de Grande Escala

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

Análise teórica e um novo algoritmo, Binary Classifier Optimization, explicam e aprimoram o alinhamento de grandes modelos de linguagem usando sinais de feedback binário. Para reproduzir a configuração do artigo, use esta configuração:

BCO reformula o alinhamento de modelos de linguagem como clonagem comportamental a partir de uma distribuição ótima ponderada por recompensa, resultando em objetivos supervisionados simples que evitam RL, mantendo-se teoricamente fundamentados. Ele suporta tanto dados de recompensa não pareados quanto dados de preferência em pares, com uma formulação invariante a deslocamentos de recompensa que se reduz a uma perda no estilo DPO no contexto de preferência.

Para a configuração de preferência por pares, a perda BCO é definida como: $$\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]$$

Para reproduzir o artigo neste cenário, use esta configuração:

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

Aprenda seu modelo de referência para um alinhamento de verdade

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

Trust Region DPO (TR-DPO) atualiza a política de referência durante o treinamento, demonstrando eficácia em relação ao DPO nos conjuntos de dados Anthropic HH e TLDR, superando o DPO em até 19% medido por avaliação automática com GPT-4, melhorando coerência, correção, nível de detalhe, utilidade e inofensividade. Para reproduzir a configuração do artigo, use esta configuração:

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

Otimização de Preferência de Raciocínio Iterativo

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

O RPO iterativo melhora o raciocínio gerando repetidamente candidatos de cadeia de pensamento, construindo pares de preferências a partir de respostas corretas versus incorretas e treinando com um objetivo DPO + NLL. O termo NLL extra é fundamental para aprender a gerar efetivamente os traços vencedores.

O TRL pode expressar o objetivo DPO + NLL misturando "sigmoid" (DPO) com "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,
)

Observe que o artigo utiliza um loop iterativo: cada iteração regenera os candidatos de CoT com o modelo atual e, em seguida, retreina com novos pares de preferências. O TRL não automatiza esse loop para você.

Otimização de Preferências por Auto-Jogo para Alinhamento de Modelos de Linguagem

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

Um método de autojogo chamado SPPO para alinhamento de modelos de linguagem atinge desempenho de estado da arte ao aproximar a política de equilíbrio de Nash em um cenário de jogo de soma constante, superando outras abordagens com dados limitados. Para reproduzir a configuração do artigo, use esta configuração:

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

Mitigação comprovada da sobreotimização em RLHF: sua perda de SFT é implicitamente um regularizador adversarial

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

A Regularized Preference Optimization (RPO) mitiga a sobreotimização no RLHF ao fundir a perda DPO com a perda SFT, prevenindo comprovadamente que a política escolha ações com recompensas de proxy falsamente altas. Para reproduzir a configuração do artigo, use esta configuração:

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
)

Alinhamento de Preferências Distribucionais de LLMs por Transporte Ótimo

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

Alignment via Optimal Transport (AOT) alinha modelos de linguagem grandes de forma distribucional, penalizando violações da dominância estocástica entre as distribuições de amostras positivas e negativas, alcançando desempenho de estado da arte em benchmarks de alinhamento. Para reproduzir a configuração do artigo, use esta configuração:

from trl import DPOConfig

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

ou, para a versão não pareada:

from trl import DPOConfig

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

Não há nenhum hiperparâmetro adicional no artigo.

Descobrindo Algoritmos de Otimização de Preferências com e para Modelos de Linguagem de Grande Escala

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

Um método orientado por LLM descobre automaticamente algoritmos de otimização de preferências com alto desempenho, resultando em um novo algoritmo chamado DiscoPOP que combina perdas logísticas e exponenciais. Para reproduzir a configuração do artigo, use esta configuração:

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: Aprimorando o RLHF com Otimização de Preferência Ponderada

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

O WPO repondera pares de preferências por suas probabilidades de política para reduzir o gap off-policy no treinamento no estilo DPO. A perda é: $$\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]$$

onde o peso $w(x, y)$ é definido como: $$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)$$

Para reproduzir a configuração do artigo, use esta configuração:

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

Otimização de Preferências Ancoradas e Revisões Contrastivas: Abordando a Subespecificação no Alinhamento

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

CLAIR e APO aprimoram o alinhamento de LLMs por meio de mais pares de preferências contrastivas e objetivos de alinhamento controlados, melhorando o desempenho do modelo para níveis próximos ao do GPT4-turbo. Para reproduzir a configuração do artigo, use esta configuração:

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

Esses parâmetros aparecem apenas na versão publicada

Desensibilização ao comprimento na Otimização de Preferência Direta

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

Mostra que o DPO padrão é inerentemente sensível ao comprimento, o que frequentemente leva os modelos a gerações excessivamente longas ou verbosas. O artigo propõe o LD-DPO, que modifica a agregação do log-prob da sequência dividindo a resposta mais longa em um prefixo compartilhado (até o comprimento da resposta mais curta) e uma cauda excedente, e depois reduz o peso da cauda com um fator $\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|).$$

Configuração $\alpha=1$ recupera o DPO padrão; valores menores de $\alpha$ reduzem a verbosidade mantendo a qualidade da preferência. O valor ideal de $\alpha$ depende da família do modelo e se você está treinando um modelo base ou instruct, mas o artigo sugere $\alpha=0.5$ como um ponto de partida padrão forte.

from trl import DPOConfig

training_args = DPOConfig(
    ld_alpha=0.5,
)

Melhorando a capacidade de raciocínio de modelos de linguagem grandes multimodais por meio de otimização de preferências mistas

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

Introduz a Otimização de Preferência Mista (MPO) para melhorar o raciocínio multimodal em MLLMs, abordando o deslocamento de distribuição e a fraqueza do Chain-of-Thought (CoT) após o pré-treino padrão e o SFT. O artigo contribui com (1) MMPR, um pipeline automatizado para dados de preferência multimodal de alta qualidade, e (2) MPO, um objetivo de preferência combinado (par a par + estilo BCO + SFT) que impulsiona o CoT. O InternVL2-8B-MPO atinge 67,0 no MathVista (+8,7 em relação ao InternVL2-8B), comparável ao InternVL2-76B, que é 10× maior. Usado no TRL via DPOConfig com perda composta. Para reproduzir a configuração do artigo, use esta configuração:

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: Avançando as fronteiras no pós-treino de modelos de linguagem abertos

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

A perda sigmoid normalizada pelo comprimento aborda o viés de comprimento no DPO dividindo as pontuações de log-ratio das respostas escolhidas e rejeitadas pelos respectivos comprimentos de conclusão antes de calcular a perda de Bradley-Terry. Essa normalização por token foi introduzida em SimPO (Anexo I “DPO w/ LN” ablation) como uma recompensa de log-probabilidade média para um cenário sem referência e foi posteriormente adotada para o DPO padrão baseado em modelo de referência em receitas de pós-treino, como Tülu 3 (Seção 4.3). A perda é: $$\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),$$ que pode ser configurada com:

from trl import DPOConfig

training_args = DPOConfig(
    loss_type="sigmoid_norm",
)

Alinhamento sem viés para modelos de linguagem de grande escala com preferências ruidosas

📜 Artigo: https://huggingface.co/papers/2607.03248

Este artigo modela o ruído de preferência como rótulos invertidos com probabilidade $\varepsilon$ e inverte essa transição, de modo que a política treinada com preferências ruidosas tenha o mesmo ótimo que com preferências limpas. O TRL implementa a forma normalizada da perda Unbiased DPO (UDPO) resultante, chamada de α-UDPO no artigo: $$\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}},$$

que é a perda DPO para $a = 0$. A constante $\alpha$ mantém a magnitude máxima do gradiente em 1, como no DPO. Diferente de Robust DPO, o artigo mostra que o ótimo permanece sem viés quando a probabilidade real de inversão é menor que a assumida $\varepsilon$ (Corolário 4.7), então $\varepsilon$ não precisa ser estimado exatamente. No TRL, $\varepsilon$ é definido com label_smoothing. Para usar $a = 0.8$, o valor que o artigo recomenda para praticantes:

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
)

Otimização Kahneman–Tversky

Artigos relacionados ao KTOTrainer

KTO: Alinhamento de modelos como otimização prospectiva

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

O KTO deriva um objetivo de alinhamento da teoria das perspectivas e aprende diretamente de feedback humano binário (curtiu/não curtiu), igualando ou superando métodos no estilo DPO, ao mesmo tempo em que lida bem com sinais desequilibrados/ruidosos. Para reproduzir a configuração do artigo, você pode usar a configuração padrão do 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()

Ajuste Fino Supervisionado

Artigos relacionados ao SFTTrainer

TailSFT: Fine-Tuning filtrado melhora o desempenho do pós-treinamento

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

TailSFT preserva a cobertura de respostas para o aprendizado por reforço subsequente ao filtrar as sequências cuja perda normalizada pelo comprimento apresentou a maior melhora em relação à política inicial. O exemplo tail_sft_gsm8k implementa o filtragem distribuída de lotes de seleção do artigo por meio da subclassificação de SFTTrainer. Ele registra a perda da política inicial de cada sequência antes do treinamento e filtra os exemplos de forma independente em cada lote de seleção.

python examples/tail_sft_gsm8k/tail_sft.py

EMA sem o Atraso: Esquemas de Média de Iterações Corrigidos por Viés

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

A Média Móvel Exponencial Corrigida por Viés (Bias-Corrected Exponential Moving Average, BEMA) melhora a estabilidade e a eficiência do ajuste fino de modelos de linguagem ao reduzir a estocasticidade e eliminar o viés. Para usar o BEMA com SFT, conforme descrito no artigo, você pode usar o BEMACallback:

from trl import BEMACallback, SFTTrainer

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

Sobre a Generalização do SFT: Uma Perspectiva de Aprendizado por Reforço com Retificação de Recompensa

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

O Dynamic Fine-Tuning (DFT) melhora a generalização dos Large Language Models (LLMs) ao reescalar dinamicamente os gradientes, superando o Supervised Fine-Tuning (SFT) padrão e mostrando resultados competitivos no aprendizado por reforço offline. $$\mathcal{L}_{\text{DFT}}(\theta) = \mathbb{E}_{(x,y) \sim \mathcal{D}} \left[ - \sum_{t=1}^{|y|} \textcolor{red}{\text{sg}\big(\pi_\theta(y_t \mid y_{<t}, x)\big)} \; \log \pi_\theta(y_t \mid y_{<t}, x) \right]$$

onde $\text{sg}(\cdot)$ é o operador stop-gradient. Para usar o DFT com SFT, conforme descrito no artigo, você pode usar o argumento loss_type="dft" :

from trl import SFTConfig

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

Para corresponder de perto à configuração do artigo, você pode usar a seguinte configuração (veja a Seção 4.1). Os autores também mencionam que os hiperparâmetros não são muito sensíveis (Seção 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,
)

Menos Truncamentos Melhoram a Modelagem de Linguagem

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

O artigo mostra que o pré-processamento padrão de concatenação e divisão (packing_strategy="wrapped") usado para treinamento de LLMs faz com que muitos documentos sejam truncados arbitrariamente, o que prejudica a aprendizagem. Ele propõe empacotar trechos de documentos em janelas de contexto usando um algoritmo de empacotamento em caixas Best-Fit Decreasing, reduzindo drasticamente o truncamento, mantendo um alto aproveitamento de tokens e melhorando o desempenho do modelo. O TRL implementa isso como a estratégia de empacotamento "bfd_split" em SFTConfig. Para mais detalhes sobre empacotamento, consulte a documentação do SFT.

from trl import SFTConfig

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

Explorando os Limites do Transfer Learning com um Transformer Unificado de Texto para Texto

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

O artigo do T5 propõe um framework unificado de texto-para-texto para aprendizado por transferência e introduz empacotamento de sequências (Seção 3.5.2): agrupar múltiplas sequências curtas em blocos de comprimento fixo para reduzir o preenchimento e melhorar a eficiência do treinamento. O empacotamento é suportado no TRL por meio de SFTConfig com o SFTTrainer. Para habilitar o empacotamento com o TRL, use esta configuração:

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

Reparametrizando Modelos de Difusão Uniformes: o Denoiser Leave-One-Out

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

Para modelos de difusão discreta uniforme, a entropia cruzada plug-in usual não aprende o desruidor simples$\mathbb{E}[X_0 \mid X_t]$ mas a posterior leave-one-out (LOO), que prevê cada token sem usar seu próprio valor corrompido. O artigo deriva conversões exatas entre o desruidor, a posterior LOO e o score, permitindo que uma rede seja treinada como qualquer uma das parametrizações com a mesma entropia cruzada. Dadas as logits$f_\theta$ cujo softmax parametriza a posterior LOO, o desruidor usado na perda é $$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),$$

ou seja, uma correção aditiva no logit do token observado, onde$K$ é o tamanho do vocabulário e$\alpha_t$ a probabilidade de que o forward uniforme mantenha o token limpo. O artigo relata que a parametrização LOO melhora consistentemente a geração. O exemplo de SFT com block-diffusion examples/sft_diffusion_gemma/sft_diffusion_gemma.py expõe ambas as parametrizações via --model_prediction_type (mean para o denoiser simples, correspondendo ao checkpoint liberado, ou mean_loo para a posteriori 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

Reduzindo a Recomputação de Ativações em Grandes Modelos Transformer

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

O checkpointing completo de ativações recalcula cada operação em uma região checkpointed durante o backward, incluindo a atenção, mesmo que apenas algumas operações (a atenção entre elas) representem a maior parte do custo de recomputação em relação à memória que custaria para mantê-las. A recomputação seletiva de ativações do paper checkpointa apenas essas operações caras, em vez da região inteira. O TRL implementa isso como checkpointing seletivo de ativações (SAC) para SFTTrainer, salvando a saída da atenção durante o forward para que o backward não precise recalculá-la:

from trl import SFTConfig

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

Ajuste Fino Eficiente em Parâmetros (PEFT)

Para detalhes gerais sobre o uso de PEFT com TRL, consulte o guia de Integração PEFT.

LoRA: Adaptação de Baixo Rango de Modelos de Linguagem de Grande Escala

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

A Low-Rank Adaptation (LoRA) reduz o número de parâmetros treináveis e o uso de memória de GPU em modelos pré-treinados de grande escala, mantendo ou melhorando o desempenho em tarefas downstream. O TRL integra a LoRA por meio da biblioteca PEFT e pode ser facilmente habilitado em qualquer treinador do TRL passando um LoraConfig para o argumento peft_config. Aqui está um exemplo de uso da LoRA com o SFTTrainer:

from trl import SFTTrainer
from peft import LoraConfig

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

DoRA: Adaptação de Baixo Rango com Decomposição de Pesos

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

A Weight-Decomposed Low-Rank Adaptation (DoRA) pode melhorar o desempenho do LoRA, especialmente em ranks baixos. A DoRA decompõe o peso pré-treinado em dois componentes: magnitude e direção. A direção é tratada pelo LoRA normal, e a magnitude é um parâmetro aprendível. O TRL integra a DoRA por meio da biblioteca PEFT e pode ser facilmente habilitada ao definir use_dora=True no LoraConfig.

from peft import LoraConfig

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

Reinforce Leave-One-Out

Artigos relacionados ao RLOOTrainer

Voltando ao básico: Revisitando a otimização no estilo REINFORCE para aprendizado com feedback humano em LLMs

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

RLOO é uma variante do REINFORCE que reduz a variância usando baselines leave-one-out. Ele calcula as recompensas comparando cada amostra com a média de todas as outras amostras no lote, fornecendo gradientes mais estáveis do que o REINFORCE padrão. Para reproduzir a configuração do artigo, use esta configuração:

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++: Uma abordagem simples e eficiente para alinhar grandes modelos de linguagem

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

REINFORCE++ é uma variante aprimorada do algoritmo clássico REINFORCE que incorpora técnicas de otimização essenciais do PPO, eliminando a necessidade de uma rede crítica. Ele alcança simplicidade, estabilidade aprimorada do treinamento e menor sobrecarga computacional por meio da normalização global da vantagem em todo o lote. Para aproximar a configuração do artigo com o RLOOTrainer, use esta configuração:

from trl import RLOOConfig

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

Odds Ratio Preference Optimization

Artigos relacionados ao experimental.orpo.ORPOTrainer

ORPO: Otimização de Preferência Monolítica sem Modelo de Referência

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

A introdução de um algoritmo monolítico de otimização de preferência baseado em razão de chances, sem modelo de referência (ORPO), aprimora o alinhamento de preferências durante o ajuste fino supervisionado, superando modelos maiores em avaliações-chave. Para reproduzir a configuração do artigo, use esta configuração:

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

Otimização de Preferência Contrastiva

Artigos relacionados ao experimental.cpo.CPOTrainer

Contrastive Preference Optimization: Expandindo os limites do desempenho de LLMs na tradução automática

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

Introduz o Contrastive Preference Optimization (CPO), um método baseado em preferências para tradução automática que treina modelos a evitar traduções adequadas, porém imperfeitas, em vez de imitar referências, como no SFT. O artigo analisa as limitações do SFT em MT (incluindo problemas de qualidade das referências) e mostra que a aplicação do CPO ao ALMA com apenas 22K frases paralelas resulta no ALMA-R, que iguala ou supera os vencedores da competição WMT e o GPT-4 no WMT’21–WMT’23. Utilizado no TRL via experimental.cpo.CPOTrainer. Para reproduzir a configuração do artigo, use esta configuração:

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: Otimização de Preferência Simples com Recompensa Sem Referência

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

SimPO é uma abordagem de otimização de preferências mais simples, porém mais eficaz, que utiliza a probabilidade log média de uma sequência como recompensa implícita, eliminando a necessidade de um modelo de referência. Ele introduz uma margem de recompensa alvo no objetivo de Bradley-Terry para incentivar uma margem maior entre respostas vencedoras e perdedoras. Para reproduzir a configuração do artigo, use esta configuração:

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 — A forma da recompensa importa para o alinhamento de LLM

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

AlphaPO é um novo método de Algoritmos de Alinhamento Direto (DAAs) que utiliza um parâmetro alpha para ajudar a alterar a forma da função de recompensa além da recompensa log padrão. O AlphaPO ajuda a manter um controle fino sobre o deslocamento de verossimilhança e a sobreotimização. Para reproduzir a configuração do artigo, use esta configuração:

from trl.experimental.cpo import CPOConfig

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

Triple Preference Optimization

Triple Preference Optimization: Alcançando um alinhamento melhor usando uma otimização de etapa única

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

Introduz o Triple Preference Optimization (TPO), um método de aprendizado por preferências que alinha um LLM com três respostas por prompt — uma conclusão de referência (reference), uma conclusão preferida (chosen) e uma conclusão não preferida (rejected) — em uma única etapa de otimização. O TPO combina um objetivo contrastivo no par (chosen, rejected) com um termo de NLL supervisionado na resposta de referência, eliminando a necessidade de uma etapa separada de SFT e do modelo de referência usado no DPO. O TRL disponibilizou uma implementação como TPOTrainer até a v1.16; ela não faz mais parte da biblioteca e permanece disponível no histórico do git.

Aprendizado de Nash a partir de Feedback Humano

Aprendizado de Nash a partir de Feedback Humano

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

Introduz o Nash-MD, uma alternativa ao RLHF padrão que aprende um modelo de preferências condicionado a duas entradas e encontra uma política no equilíbrio de Nash. Em vez de otimizar em relação a um modelo de recompensa, o Nash-MD produz políticas que consistentemente geram respostas preferidas em relação às de qualquer política concorrente. O algoritmo é baseado nos princípios de descida espelhada. O TRL disponibilizou uma implementação como NashMDTrainer até a v1.13; ela não faz mais parte da biblioteca e permanece disponível no histórico do git.

Modelagem de Recompensa

Artigos relacionados ao RewardTrainer

Ajudar ou seguir o rebanho? Ensambles de modelos de recompensa mitigam, mas não eliminam, o hacking de recompensa

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

Este artigo propôs uma função de perda auxiliar projetada para aprender diretamente um modelo de recompensa centralizado. Essa perda auxiliar minimiza a soma dos quadrados das recompensas, incentivando o modelo a produzir naturalmente saídas com média zero e, assim, resolvendo o problema de subdeterminação. $$\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].$$

Para usar essa perda auxiliar com RewardTrainer, você pode usar o argumento center_rewards_coefficient em RewardConfig da seguinte forma:

from trl import RewardConfig

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

Llama 2: Modelos de fundação abertos e modelos de chat ajustados

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

Neste artigo, os autores propõem aproveitar o fato de suas avaliações de preferência serem decompostas em uma escala de quatro pontos (por exemplo, significativamente melhor) para fornecer um feedback mais informativo ao modelo de recompensa. Isso é feito adicionando uma margem à função de perda, o que incentiva o modelo de recompensa a atribuir diferenças maiores nas pontuações para pares com avaliações de preferência mais altas. $$\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].$$

Você pode adicionar uma margem à perda ao incluir uma coluna margin no conjunto de dados. O exemplo a seguir mostra como configurar a configuração “Margin Small” do artigo.

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)

Otimização Direta de Preferência Online

Artigos relacionados ao experimental.online_dpo.OnlineDPOTrainer

Alinhamento direto de modelos de linguagem a partir de feedback de IA online

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

O Online DPO melhora os métodos de alinhamento direto a partir de preferências ao fornecer feedback em tempo real de um modelo, superando tanto os métodos DPO quanto PPO.

Para usar o Online DPO, você pode usar o experimental.online_dpo.OnlineDPOTrainer.

Otimização de Preferência Exploratória: Aproveitando a Aproximação Implícita de Q* para RLHF Eficiente em Amostragem

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

O XPO amplia o objetivo do DPO com um bônus de exploração novo e fundamentado, permitindo que o algoritmo explore fora do suporte do modelo inicial e dos dados de feedback humano. Trata-se de uma alteração de uma linha no DPO online que é comprovadamente eficiente em amostras e converge para uma política de modelo de linguagem quase ótima. O TRL disponibilizou uma implementação como XPOTrainer até a v1.13; ela não faz mais parte da biblioteca e permanece disponível no histórico do git.

Destilação

Artigos relacionados ao treinamento de um modelo aluno com a ajuda de um modelo professor.

Destilação de modelos de linguagem on-policy: aprendendo com erros auto-gerados

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

Introduz o Generalized Knowledge Distillation (GKD), que aborda o desalinhamento de distribuição no KD para modelos auto-regressivos treinando o aluno em seus próprios gerados com feedback do professor, em vez de um conjunto fixo de sequências. O GKD suporta funções de perda flexíveis (por exemplo, além da KL quando o aluno não consegue corresponder ao professor) e se integra ao ajuste fino com RL (RLHF). O artigo relata resultados em sumarização, tradução, raciocínio aritmético e ajuste fino por instruções. Usado no TRL via experimental.gkd.GKDTrainer, que expõe a mistura on/off-policy do artigo (lmbda). DistillationTrainer implementa o mesmo objetivo generalized-JSD para o caso sempre on-policy. Para reproduzir a configuração do artigo, use esta configuração:

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: Destilação On-Policy com Múltiplos Professores para Integração de Capacidades no Pós-Treinamento de LLMs

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

Estrutura o pós-treino em três etapas: SFT geral, treinamento RL independente por domínio de um especialista por domínio (por exemplo, RL de respostas verificáveis para matemática, RL de agente em sandbox para engenharia de software) e uma etapa final de MOPD que funde os especialistas de domínio congelados em um único aluno unificado. Nessa etapa final, o aluno gera uma trajetória por prompt, cada trajetória é despachada para seu respectivo professor de domínio (nunca é média ou ensemble entre professores) e o aluno é atualizado minimizando o KL reverso por token em relação à distribuição daquele único professor ao longo da trajetória. Usado no TRL via experimental.async_distillation.AsyncDistillationTrainer, que implementa essa terceira etapa de fusão: passar mais de uma entrada em teacher_server_urls habilita o MOPD, com a coluna teacher_id de cada linha selecionando qual professor (já treinado) pontua-a. Use beta=1.0 para corresponder ao objetivo de KL reverso do paper.

Sobre o viés de posição no destilamento on-policy

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

Introduz a Destilação On-Policy Ponderada por Importância (IW-OPD), que aborda o viés de posição na OPD reponderando as atualizações de destilação de tokens amostrados de acordo com a discrepância acumulada do prefixo entre o professor e o aluno. Os tokens iniciais mantêm pesos maiores, enquanto os tokens posteriores, após um alto desvio, têm seus pesos reduzidos. Utilizado no TRL por meio de experimental.iw_opd.IWOPDTrainer com distillation_objective="iw_opd".

O artigo otimiza o IW-OPD com uma configuração de gradiente de política com corte (clipped policy-gradient) (verl) e rollouts do vLLM. IWOPDTrainer expõe as configurações correspondentes de destilação e rollout abaixo; configurações de otimização de política do artigo, como o intervalo de corte 0.2, a constante de corte duplo 3.0, épocas internas de PPO, coeficiente de entropia, penalidade de recompensa KL, KL auxiliar e correção de importância do rollout, não são parâmetros de 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
)

Destilação On-Policy

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

O On-Policy Distillation envolve um modelo aluno gerando rollouts para cada lote de dados de treinamento. Em seguida, obtemos as distribuições de probabilidade para cada token dos rollouts a partir dos modelos aluno e professor. O modelo aluno é então otimizado para minimizar a divergência de Kullback-Leibler (KL) negativa entre suas próprias distribuições de tokens e as do modelo professor.

O On-Policy Distillation demonstrou superar o SFT e o GRPO e pode ser usado para restaurar as capacidades de generalização perdidas durante o SFT.

Além disso, a destilação on-policy é mais eficiente em termos de computação e tem menor tendência a sofrer overfitting quando treinada com dados limitados.

Para treinar um modelo com destilação on-policy usando o TRL, você pode usar a seguinte configuração, com o DistillationTrainer e o 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
)

Alternativamente, você pode usar o experimental.gkd.GKDTrainer e o 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
)

Você também pode usar experimental.gold.GOLDTrainer para destilação on-policy; consulte Unlocking On-Policy Distillation for Any Model Family.

Desbloqueando a destilação on-policy para qualquer família de modelos

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

Introduz o General Online Logit Distillation (GOLD), que estende a destilação on-policy para pares de aluno/professor com tokenizers e famílias de modelos diferentes. O GOLD alinha trechos de texto entre tokenizers e pode aplicar o Universal Logit Distillation (ULD) para que os tokens de conclusão não sejam descartados. Usado no TRL via 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: Destilação de Conhecimento entre Tokenizadores Guiada por Projeção

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

X-Token estende o framework de destilação GOLD para pares aluno-professor que não compartilham um tokenizador. É um método off-policy (lmbda=0): o conjunto de dados fornece o texto de conclusão, tanto o aluno quanto o professor executam passes forward nesse texto, e a perda de KD entre tokenizadores é calculada entre seus logits. Não são necessários rollouts do aluno on-policy. Uma matriz de projeção esparsa pré-computada W ∈ ℝ^{V_s × V_t} mapeia cada token do aluno para os tokens do professor aos quais ele mais plausivelmente corresponde, projetando a distribuição do aluno no espaço de vocabulário do professor para que ambos possam ser comparados diretamente. Usado no TRL via experimental.gold.GOLDTrainer com xtoken_loss_type="p_kl" ou "h_kl".

Duas formulações de perda são fornecidas:

Conforme a implementação de referência, o H-KL recorta as log-probabilidades do vocabulário completo para o conjunto comum e o P-KL calcula a média das log-probabilidades do professor em cada trecho sem renormalizar, de modo que o termo de KD pode ser negativo. CE e KD usam contagens separadas de tokens e de trechos alinhados em cada janela de acúmulo. O balanceamento dinâmico de CE/KD e a seleção top-k do P-KL são calculados por microbatch.

Esta implementação usa uma matriz de projeção congelada. O artigo também aprende conjuntamente a matriz para P-KL; essa variante não está implementada aqui.

Primeiro, construa a matriz de projeção com os scripts de preparação em examples/xtoken/. A Etapa 1 re-tokeniza o vocabulário do aluno com o tokenizador do professor; a flag opcional --runtime-top-k em seguida ordena e reduz a matriz de uma só vez (equivalente a executar sort_and_cut_projection_matrix.py depois):

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

Depois, treine com o script de exemplo (off-policy, sem necessidade de 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

ou passe o caminho para experimental.gold.GOLDConfig diretamente:

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

Destilação de Conhecimento de Modelos de Linguagem de Grande Escala

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

MiniLLM é o primeiro método de destilação de conhecimento on-policy, que minimiza o KLD reverso em nível de sequência entre o modelo professor e o modelo aluno e é otimizado por aprendizado por reforço.

É uma versão generalizada do On-Policy Distillation do Think Machine Lab, com a opção de adicionar sinais de destilação de passo único em nível de distribuição (como GKD quando beta=1) e sinais de KLD reversa para contexto longo.

O TRL lançou uma implementação como MiniLLMTrainer até a v1.14; ela não faz mais parte da biblioteca e permanece disponível no histórico do git.

Aprendizado por Reforço por Auto-Destilação

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

A Otimização de Política por Auto-Destilação (SDPO) aprimora o aprendizado por reforço com recompensas verificáveis ao converter feedback textual rico (por exemplo, erros de tempo de execução, avaliações de juízes) em um sinal de aprendizado denso, sem a necessidade de um professor externo ou de um modelo de recompensa explícito. O SDPO trata o modelo atual, condicionado ao feedback, como um auto-professor e destila suas previsões de próximo token informadas pelo feedback de volta para a política. Notavelmente, o SDPO também supera as linhas de base em ambientes padrão de RLVR que retornam apenas feedback escalar, ao usar rolagens bem-sucedidas como feedback implícito para tentativas malsucedidas.

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

Colunas esperadas do conjunto de dados:

• prompt
• privileged_context para feedback opcional do ambiente

Para mais detalhes, consulte a documentação do SDPO Trainer.

Auto-Destilação Permite Aprendizado Contínuo

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

O Fine-Tuning Auto-Destilado (SDFT) executa auto-destilação on-policy gerando conclusões durante o treinamento e, em seguida, destilando uma visão explícita do professor condicionada a essas mesmas conclusões de volta para o aluno. O professor é selecionado por teacher_model_kind: "base" (o aluno inicial), "live" (o aluno atual) ou "ema" (um professor com média exponencial). O prompt do professor é composto internamente a partir do prompt do aluno mais o privileged_context do conjunto de dados.

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

Colunas esperadas do conjunto de dados:

• prompt
• privileged_context contendo apenas as informações extras exclusivas do professor

Para mais detalhes, consulte a documentação do SDFT Trainer.

Auto-destilação Simples e Desconfortável Melhora a Geração de Código

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

O Simple Self-Distillation (SSD) melhora a geração de código ao amostrar conclusões do modelo com uma configuração de temperatura e truncamento definida no momento do treinamento e, em seguida, realizar o ajuste fino nesses amostras brutas e não verificadas usando a perda de entropia cruzada padrão. Não é necessário um modelo de recompensa, um verificador, um modelo professor ou aprendizado por reforço. O SSD remodela as distribuições de tokens de uma forma dependente do contexto: suprime as caudas de distratores em posições de “lock” (onde a sintaxe deixa pouca ambiguidade) e preserva a diversidade em posições de “fork” (onde existem múltiplas continuações válidas).

O TRL disponibilizou uma implementação como SSDTrainer até a v1.15; ela não faz mais parte da biblioteca e permanece disponível no histórico do git.

Uma correção para Softmax e Entropia Cruzada

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

Identifica o colapso do softmax em previsões de alta confiança e a cancelamento quando os logits do aluno e do professor quase coincidem. As cabeças de log-probabilidade em blocos e de destilação do TRL usam normalização que exclui o alvo e diferenças de probabilidade no espaço log para preservar gradientes pequenos. As correções numéricas são aplicadas automaticamente, incluindo para KL direta, KL reversa e JSD generalizada em DistillationTrainer.

O Apêndice B.4 de Entropy-preserving reinforcement learning identificou anteriormente a falha de policy-gradient de alta confiança e propôs a recomputação seletiva de gradientes em FP64. Os kernels do TRL preservam esses gradientes usando fórmulas estáveis em FP32.

O problema separado de conversão de saída do FSDP2 discutido no Apêndice B.1 é tratado por Accelerate #4403. Versões mais antigas do Accelerate precisam de uma política de precisão mista com output_dtype=None para reter as saídas dos kernels em FP32.

O exemplo a seguir mapeia os hiperparâmetros relatados na Seção 7 para o objetivo de KL direta do TRL, que compartilha o gradiente do aluno da entropia cruzada de alvo suave. Ele ilustra a destilação de modelos de linguagem, em vez de reproduzir o experimento de aritmética modular do artigo. O artigo inicializa o aluno com os pesos do professor; isso deve ser tratado ao construir os modelos, independentemente da configuração. Os outros padrões do treinador permanecem inalterados.

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

Treinamento Distribuído

ZeRO: Otimizações de memória para o treinamento de modelos com trilhões de parâmetros

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

ZeRO (Zero Redundancy Optimizer) elimina redundâncias de memória no treinamento paralelo de dados e de modelo, particionando os estados do otimizador, os gradientes e os parâmetros entre os dispositivos, mantendo baixo volume de comunicação e alta granularidade computacional. Isso permite o treinamento eficiente de modelos grandes que, de outra forma, não caberiam na memória da GPU.

O TRL oferece suporte ao ZeRO por meio da integração com o DeepSpeed. Para usá-lo, forneça um arquivo de configuração do DeepSpeed com as configurações desejadas,

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

Defina deepspeed="zero3.json" na configuração de treinamento e execute o script de treinamento com torchrun.

torchrun --nproc_per_node 2 train.py