DPO, KTO e SimPO: Alinhamento de LLMs sem Modelos de Recompensa

O alinhamento moderno de Large Language Models dispensa modelos de recompensa separados e loops instáveis de aprendizado por reforço online. Métodos diretos como DPO, KTO e SimPO reparametrizam a função de preferência diretamente sobre as probabilidades dos tokens, cortando custos de infraestrutura e acelerando o treinamento.

Durante anos, o pipeline canônico de RLHF com PPO exigiu quatro redes neurais simultâneas em VRAM. Essa arquitetura gerava instabilidade de convergência e incentivava respostas excessivamente prolixas (verbosity bias).

Por que o RLHF tradicional com PPO se tornou um gargalo

O RLHF tradicional com PPO tornou-se um gargalo operacional porque exige manter quatro redes neurais de escala total concorrendo por memória de GPU. Além disso, a amostragem on-policy token a token mantém aceleradores ociosos durante a maior parte do ciclo de treinamento.

No pipeline seminal consolidado pelo InstructGPT (Ouyang et al., 2022), o alinhamento pós-treinamento exige três fases rígidas. Primeiro realiza-se o Supervised Fine-Tuning (SFT), seguido pelo treinamento de um Reward Model escalar e pela otimização da política via PPO.

No loop do PPO, a infraestrutura precisa manter na VRAM quatro componentes ativos: o Actor (\pi_\theta), o Critic (V_\phi), o Reference Model congelado (\pi_{ref}) e o Reward Model (r_\psi).

Para um modelo de 70 bilhões de parâmetros em precisão FP16/BF16, o peso combinado de parâmetros e estados do otimizador AdamW supera 1,96 TB de VRAM estática antes de alocar memória para tensores de ativação e KV Cache.

+-----------------------------------------------------------------------------------+
|                         PIPELINE CLÁSSICO DE RLHF COM PPO                         |
|                                                                                   |
|  1. Supervised Fine-Tuning (SFT) ---> Obtém Política Base pi_ref                 |
|  2. Treino do Reward Model (RM)  ---> Ajusta r_psi(x, y) via Bradley-Terry       |
|  3. Otimização Online (PPO):                                                      |
|     Prompt x ---> [Actor pi_theta] ---> Gera Rollout y (Memory-bound)             |
|                        |                                                          |
|                        +---> [Reward Model r_psi]  ---> Recompensa escalar        |
|                        +---> [Ref Model pi_ref]   ---> Penalidade KL              |
|                        +---> [Critic V_phi]       ---> Estimativa de Vantagem     |
|                        |                                                          |
|                        v                                                          |
|     Atualização PPO nos pesos de pi_theta e V_phi (Alto risco de colapso)         |
+-----------------------------------------------------------------------------------+

A dinâmica Actor-Critic sofre com não-estacionariedade contínua. Enquanto a política muda a cada mini-batch, o Critic tenta rastrear valores em movimento rápido, gerando gradientes de alta variância que frequentemente provocam colapso de política (policy collapse).

Além da instabilidade matemática, a geração de respostas em tempo de execução (rollouts) é limitada por largura de banda de memória. As GPUs passam até 70% do tempo de treinamento esperando transferências de tensores autorregressivos.

O reward hacking agrava o cenário. Sob otimização irrestrita por PPO, o modelo aprende a explorar falhas do Reward Model, gerando respostas prolixas e bajuladoras sem ganho real de qualidade.

Como o DPO elimina o modelo de recompensa com cálculo exato

O Direct Preference Optimization (DPO) elimina o modelo de recompensa ao demonstrar matematicamente que a política de linguagem já atua como seu próprio modelo de recompensa implícito. Isso transforma o alinhamento em uma função de perda de entropia cruzada estática e offline.

Introduzido por Rafailov et al. (Stanford / NeurIPS 2023), o DPO parte do objetivo clássico de RL com restrição de divergência Kullback-Leibler:

\max_\pi \mathbb{E}_{x \sim \mathcal{D}} [ \mathbb{E}_{y \sim \pi} [r(x, y)] - \beta \mathbb{D}_{KL}(\pi(y|x) \parallel \pi_{ref}(y|x)) ]

A solução analítica exata para a política ótima \pi^*(y|x) sob esse objetivo satisfaz a forma fechada de Gibbs:

\pi^*(y|x) = (1 ÷ Z(x)) \times \pi_{ref}(y|x) \times \exp( (1 ÷ \beta) \times r(x, y) )

onde Z(x) é a função de partição normalizadora dependente apenas do prompt x.

+-----------------------------------------------------------------------------------+
|                     DIRECT PREFERENCE OPTIMIZATION (DPO)                          |
|                                                                                   |
|  Pares Estáticos: (x, y_w, y_l)                                                   |
|         |                                                                         |
|         +---> [Actor pi_theta]   ---> log pi_theta(y_w|x) e log pi_theta(y_l|x)   |
|         +---> [Ref pi_ref]       ---> log pi_ref(y_w|x) e log pi_ref(y_l|x)       |
|                                                                                   |
|  Recompensa Implícita: r_hat(x, y) = beta * log( pi_theta(y|x) / pi_ref(y|x) )    |
|  Margem Relativa: Delta r = r_hat(x, y_w) - r_hat(x, y_l)                         |
|  Loss DPO: L_DPO = - log sigma( Delta r )                                         |
+-----------------------------------------------------------------------------------+

Ao isolar a função de recompensa r(x, y) tomando o logaritmo em ambos os lados, obtemos a relação fundamental:

r(x, y) = \beta \log( \pi^*(y|x) ÷ \pi_{ref}(y|x) ) + \beta \log Z(x)

Sob o modelo de preferências pareadas de Bradley-Terry (1952), a probabilidade de uma resposta preferida y_w superar uma rejeitada y_l depende apenas da diferença entre suas recompensas.

Quando subtraímos r(x, y_w) - r(x, y_l), o termo desconhecido \beta \log Z(x) cancela-se perfeitamente:

r(x, y_w) - r(x, y_l) = \beta \log( \pi_\theta(y_w|x) ÷ \pi_{ref}(y_w|x) ) - \beta \log( \pi_\theta(y_l|x) ÷ \pi_{ref}(y_l|x) )

A função de perda do DPO (\mathcal{L}_{DPO}) é minimizada diretamente sobre o dataset estático de preferências \mathcal{D}:

\mathcal{L}_{DPO}(\theta) = - \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} [ \log \sigma( \beta \log( \pi_\theta(y_w|x) ÷ \pi_{ref}(y_w|x) ) - \beta \log( \pi_\theta(y_l|x) ÷ \pi_{ref}(y_l|x) ) ) ]

O gradiente do DPO aumenta a probabilidade dos tokens da resposta vencedora y_w enquanto suprime os tokens da resposta rejeitada y_l. O peso da atualização é modulado por um termo de erro implícito:

\nabla_\theta \mathcal{L}_{DPO}(\theta) = - \beta \mathbb{E} [ \sigma(\hat{r}_\theta(x, y_l) - \hat{r}_\theta(x, y_w)) \times ( \nabla_\theta \log \pi_\theta(y_w|x) - \nabla_\theta \log \pi_\theta(y_l|x) ) ]

Quando o modelo já atribui recompensa implícita mais alta a y_w, o fator \sigma(\hat{r}_\theta(x, y_l) - \hat{r}_\theta(x, y_w)) aproxima-se de zero, evitando atualizações redundantes.

KTO: Alinhando modelos com dados unários e Teoria da Perspectiva

O Kahneman-Tversky Optimization (KTO) permite alinhar LLMs diretamente a partir de dados unários não pareados (thumbs up ou thumbs down), sem exigir pares comparativos (x, y_w, y_l). O método baseia-se na Teoria da Perspectiva da economia comportamental.

Em ambientes de produção, dados pareados representam uma minoria custosa. Plataformas e assistentes coletam volumes massivos de sinais binários isolados: um clique de cópia de código, um cancelamento de mensagem ou uma avaliação de satisfação do usuário.

Desenvolvido por Ethayarajh et al. (Stanford / Contextual AI, ICML 2024), o KTO modela a utilidade humana com base nas descobertas de Kahneman e Tversky (1979). A tomada de decisão humana avalia perdas e ganhos em relação a um ponto neutro de referência.

O algoritmo define um ponto de referência móvel z_{ref}, calculado pela média das recompensas implícitas das respostas do modelo:

z_{ref} = \mathbb{E}_{x', y' \sim \mathcal{D}} [ \beta \log( \pi_\theta(y'|x') ÷ \pi_{ref}(y'|x') ) ]

A função de valor v_{KTO} é calculada assimetricamente para saídas desejáveis e indesejáveis:

• Para respostas desejáveis ((x, y) \in \mathcal{D}_{desirable}):
  v_{KTO}(x, y) = \sigma( \beta \log( \pi_\theta(y|x) ÷ \pi_{ref}(y|x) ) - z_{ref} )

• Para respostas indesejáveis ((x, y) \in \mathcal{D}_{undesirable}):
  v_{KTO}(x, y) = \sigma( z_{ref} - \beta \log( \pi_\theta(y|x) ÷ \pi_{ref}(y|x) ) )

A perda global do KTO pondera as duas categorias com pesos distintos:

\mathcal{L}_{KTO}(\theta) = \lambda_D \mathbb{E}_{\mathcal{D}_{desirable}} [ 1 - v_{KTO}(x, y) ] + \lambda_U \mathbb{E}_{\mathcal{D}_{undesirable}} [ 1 - v_{KTO}(x, y) ]

Ao configurar \lambda_U > \lambda_D (tipicamente com razão entre 1,33 e 2,0), o KTO replica a aversão à perda humana. Respostas ruins sofrem penalidade mais agressiva do que o ganho concedido a respostas medianas.

SimPO: Eficiência sem Reference Model e combate ao viés de prolixidade

O Simple Preference Optimization (SimPO) elimina completamente o Reference Model da memória de treinamento e resolve o viés de prolixidade ao normalizar as probabilidades pelo tamanho da sequência. Isso reduz pela metade o uso de VRAM versus o DPO tradicional.

Pesquisadores de Princeton (Meng, Xia & Chen, NeurIPS 2024) identificaram que o DPO sofre de uma discrepância entre o treino e a inferência. Durante o treino, o DPO otimiza a razão com \pi_{ref}, mas durante a geração em produção o modelo decodifica apenas pela probabilidade média dos tokens da política ativa.

Além disso, sem normalização por comprimento, respostas longas acumulam probabilidades brutas maiores, forçando modelos alinhados com DPO a inflar o tamanho das saídas.

+-----------------------------------------------------------------------------------+
|                        ARQUITETURA REFERENCE-FREE DO SIMPO                        |
|                                                                                   |
|  Par de Preferência: (x, y_w, y_l)                                                |
|            |                                                                      |
|            v                                                                      |
|    [Actor Model pi_theta]  <--- ÚNICO MODELO EM VRAM (Economia de 50%)            |
|       |             |                                                             |
|       v             v                                                             |
|   log pi(y_w|x)  log pi(y_l|x)                                                    |
|       |             |                                                             |
|       v ÷ |y_w|     v ÷ |y_l|  <--- Normalização de Comprimento (Zero Verbosity)  |
|       |             |                                                             |
|   r_SimPO(y_w)   r_SimPO(y_l)                                                     |
|       \             /                                                             |
|        v           v                                                              |
|   Delta r = r_SimPO(y_w) - r_SimPO(y_l) - gamma   <--- Margem Alvo Obrigatória    |
|   Loss: L_SimPO = - log sigma( Delta r )                                          |
+-----------------------------------------------------------------------------------+

O SimPO introduz uma recompensa intrínseca normalizada pelo número de tokens |y|:

r_{SimPO}(x, y) = (\beta ÷ |y|) \sum_{i=1}^{|y|} \log \pi_\theta(y_i | x, y_{<i})

Para dispensar o modelo de referência sem perder a separação entre saídas boas e ruins, o SimPO aplica uma margem alvo de recompensa fixa \gamma > 0:

\mathcal{L}_{SimPO}(\theta) = - \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} [ \log \sigma( r_{SimPO}(x, y_w) - r_{SimPO}(x, y_l) - \gamma ) ]

Essa formulação exige que a recompensa da resposta vencedora supere a rejeitada por pelo menos a margem \gamma. Se a diferença for menor que \gamma, o modelo continua recebendo gradientes de ajuste.

ORPO e IPO: Alternativas para dados ruidosos e treino unificado

O ORPO unifica fine-tuning supervisionado e alinhamento em um único estágio de treinamento, enquanto o IPO aplica regularização quadrática para evitar overfitting em conjuntos de dados com anotações ruidosas.

Desenvolvido por Hong et al. (KAIST / EMNLP 2024), o Odds Ratio Preference Optimization (ORPO) adiciona uma penalidade de razão de chances (odds ratio) diretamente à perda supervisionada \mathcal{L}_{SFT}. O método dispensa tanto o modelo de referência quanto uma fase preliminar de SFT separado.

A probabilidade relativa sob o ORPO é calculada pela razão de chances:

odds_\theta(y|x) = \pi_\theta(y|x) ÷ (1 - \pi_\theta(y|x))

A perda conjunta do ORPO pondera a verossimilhança da resposta preferida e a razão de chances:

\mathcal{L}_{ORPO}(\theta) = \mathcal{L}_{SFT}(\theta) + \lambda_{OR} \times \mathcal{L}_{OR}(\theta)

\mathcal{L}_{OR}(\theta) = - \mathbb{E}_{(x, y_w, y_l)} [ \log \sigma( \log( odds_\theta(y_w|x) ÷ odds_\theta(y_l|x) ) ) ]

Por outro lado, o Identity Preference Optimization (IPO), proposto por Azar et al. (Google DeepMind / AISTATS 2024), endereça a vulnerabilidade do DPO a preferências determinísticas espúrias.

Quando o dataset contém amostras onde o anotador errou ou discordou da maioria, o DPO tende a empurrar as probabilidades para zero ou infinito. O IPO substitui a função sigmoide por uma perda quadrática regularizada:

\mathcal{L}_{IPO}(\theta) = \mathbb{E}_{(x, y_w, y_l)} [ ( \log( \pi_\theta(y_w|x) ÷ \pi_{ref}(y_w|x) ) - \log( \pi_\theta(y_l|x) ÷ \pi_{ref}(y_l|x) ) - (1 ÷ (2 \tau)) )^2 ]

Essa formulação impede que o modelo superajuste em outliers, preservando a calibração de probabilidades e a entropia de saída.

Implementação prática: Pipeline de alinhamento com Hugging Face TRL

A implementação de alinhamento com DPO e SimPO na biblioteca Hugging Face TRL (Transformer Reinforcement Learning) exige poucas linhas de código e integra-se diretamente com LoRA e DeepSpeed ZeRO.

O exemplo abaixo demonstra a configuração do DPOTrainer e do CPOTrainer (adaptável para SimPO com loss_type="simpo") utilizando PyTorch e Transformers:

import torch
from datasets import load_dataset
from peft import LoraConfig
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from trl import DPOTrainer, DPOConfig

# 1. Carregamento do modelo base e do tokenizador
model_id = "meta-llama/Meta-Llama-3-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",
    device_map="auto",
)

# 2. Configuração de LoRA para eficiência de parâmetros
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    bias="none",
    task_type="CAUSAL_LM",
)

# 3. Hiperparâmetros de treinamento e alinhamento
training_args = DPOConfig(
    output_dir="./results-dpo-simpo",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    learning_rate=5e-7,
    lr_scheduler_type="cosine",
    warmup_ratio=0.1,
    bf16=True,
    logging_steps=10,
    beta=0.05,            # Coeficiente KL / escala de recompensa
    loss_type="simpo",     # Seleciona perda SimPO reference-free
    simpo_gamma=1.4,      # Margem alvo de recompensa gamma
    max_length=2048,
    max_prompt_length=1024,
    gradient_checkpointing=True,
)

# 4. Instanciação do Trainer com dataset pareado
dataset = load_dataset("argilla/ultrafeedback-binarized-preferences-cleaned", split="train")

trainer = DPOTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer,
    peft_config=peft_config,
)

trainer.train()
trainer.save_model("./modelo-alinhado-simpo")

Recomendações de Hiperparâmetros em Produção

1. Taxa de Aprendizado (learning_rate): O alinhamento de preferência exige taxas significativamente menores que o SFT. Para LoRA, utilize 5e-7 a 2e-6. Para fine-tuning completo (Full FT), configure entre 1e-7 e 5e-7.
2. Constante de Regularização (\beta): No DPO clássico, valores de \beta \in [0,01, 0,05] evitam o colapso de entropia. No SimPO, recomenda-se \beta \in [2,0, 2,5] devido à normalização pelo comprimento da resposta.
3. Margem de Recompensa (\gamma no SimPO): O intervalo ótimo varia entre 0,5 e 1,5. Valores muito baixos causam sub-ajuste, enquanto valores acima de 2,0 tornam a convergência instável.

Casos reais e evolução nos modelos de fronteira

Os principais laboratórios de inteligência artificial adotaram algoritmos de preferência direta na produção de modelos de fronteira open-weights e comerciais.

No desenvolvimento da família Llama 3 (Meta AI, 2024), os engenheiros da Meta utilizaram rodadas iterativas de DPO intercaladas com amostragem de rejeição (Rejection Sampling). A equipe observou que aplicar DPO sobre pares gerados pelo próprio checkpoint em evolução superou o uso de datasets estáticos congelados.

Modelos da série Qwen (Alibaba) e Mistral Large também incorporaram variações de DPO e SimPO no pipeline final de instrução e raciocínio. A eliminação do PPO reduziu o tempo total de pós-treinamento de semanas para dias.

+-----------------------------------------------------------------------------------+
|               FLUXO ITERATIVO CONTEMPORÂNEO DE ALINHAMENTO (2026)                |
|                                                                                   |
|   Modelo Base                                                                     |
|       |                                                                           |
|       v                                                                           |
|   [Supervised Fine-Tuning - SFT]                                                  |
|       |                                                                           |
|       v                                                                           |
|  +-> [Geração de Amostras On-Policy] ---> Compara saídas com LLM-as-a-Judge       |
|  |    |                                                                           |
|  |    v                                                                           |
|  |   [Dataset de Preferências Iterativo]                                          |
|  |    |                                                                           |
|  |    v                                                                           |
|  |   [Otimização Direta: SimPO / DPO / KTO]                                       |
|  |    |                                                                           |
|  +----+ (Repete por 2 a 4 rodadas iterativas)                                     |
|       |                                                                           |
|       v                                                                           |
|   Checkpoint Alinhado para Produção                                               |
+-----------------------------------------------------------------------------------+

A tendência técnica aponta para pipelines híbridos iterativos. Em vez de escolher entre RL online puro e DPO estático, equipes combinam amostragem de dados recentes com otimizadores reference-free eficientes.

Perguntas frequentes sobre alinhamento sem Reward Model

O DPO substitui completamente o Supervised Fine-Tuning (SFT)?

Não. O DPO precisa partir de um modelo previamente adaptado ao formato de diálogo e tarefas via SFT (\pi_{SFT}). Apenas abordagens monolíticas como o ORPO tentam fundir SFT e alinhamento em um passo único.

Por que o SimPO dispensa o Reference Model enquanto o DPO exige?

O DPO usa o Reference Model para cancelar o termo de partição Z(x) e ancorar a política. O SimPO substitui essa âncora por uma margem alvo explícita \gamma e normaliza a recompensa pelo comprimento da saída.

Quando devo escolher o KTO em vez do SimPO ou DPO?

O KTO é indicado quando você possui dados unários isolados (logs com likes/dislikes de telemetria) sem custo ou viabilidade para gerar pares comparativos entre duas respostas.

O DPO sofre com o problema de respostas prolixas (verbosity bias)?

Sim. Como a recompensa implícita do DPO soma log-probabilidades brutas, respostas mais longas tendem a acumular pontuações artificiais maiores. O SimPO corrige essa falha dividindo a probabilidade pelo número de tokens gerados.

É possível combinar DPO e SimPO com treinamento LoRA/QLoRA?

Sim. Ambas as técnicas operam perfeitamente com adaptadores LoRA e QLoRA de 4 bits, permitindo alinhar modelos de até 70 bilhões de parâmetros em estações de trabalho com poucas GPUs.