DPO — Direct Preference Optimization

Direct Preference Optimization (DPO) představuje revoluční přístup k trénování jazykových modelů, který využívá lidské preference pro zlepšení kvality generovaných odpovědí. Tato metoda nabízí efektivnější alternativu k tradičnímu RLHF a umožňuje přímou optimalizaci modelu na základě porovnání párů odpovědí.

Co je Direct Preference Optimization

Direct Preference Optimization (DPO) představuje revoluci v oblasti alignmentu jazykových modelů. Zatímco tradiční metody jako RLHF (Reinforcement Learning from Human Feedback) vyžadují složitý dvoustupňový proces s reward modelem, DPO umožňuje přímou optimalizaci preferencí bez nutnosti externího reward modelu.

Klíčová inovace DPO spočívá v matematické transformaci problému. Místo učení odděleného reward modelu a následné optimalizace pomocí PPO (Proximal Policy Optimization), DPO derivuje closed-form řešení, které umožňuje přímé fine-tuning na preference data.

Matematické základy DPO

DPO vychází z Bradley-Terry modelu preferencí. Pro dvojici odpovědí (y_w, y_l) na prompt x, kde y_w je preferovaná odpověď a y_l je méně preferovaná, definuje DPO loss funkci:

L_DPO = -E[(log σ(β log π_θ(y_w|x)/π_ref(y_w|x) - β log π_θ(y_l|x)/π_ref(y_l|x)))]

Kde π_θ je optimalizovaný model, π_ref je referenční model a β je hyperparametr kontrolující sílu regularizace. Tato formulace eliminuje potřebu explicitního reward modelu a zjednodušuje celý tréninkový pipeline.

Implementace DPO v praxi

Praktická implementace DPO vyžaduje několik klíčových komponent. Začneme přípravou dat ve formátu preference pairs:

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from trl import DPOTrainer, DPOConfig

# Příprava dat
preference_data = [
    {
        "prompt": "Vysvětli kvantové počítačství",
        "chosen": "Kvantové počítačství využívá kvantové jevy...",
        "rejected": "Kvantové počítače jsou rychlé počítače..."
    }
]

def format_dpo_data(examples):
    return {
        "prompt": examples["prompt"],
        "chosen": examples["chosen"], 
        "rejected": examples["rejected"]
    }

Následuje konfigurace a spuštění DPO trainingu:

# Načtení modelu a tokenizeru
model_name = "microsoft/DialoGPT-medium"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Konfigurace DPO
dpo_config = DPOConfig(
    beta=0.1,  # Síla KL regularizace
    learning_rate=5e-7,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    max_length=512,
    num_train_epochs=1
)

# Inicializace traineru
dpo_trainer = DPOTrainer(
    model=model,
    ref_model=None,  # Automaticky se vytvoří kopie
    tokenizer=tokenizer,
    args=dpo_config,
    train_dataset=formatted_dataset,
    processing_class=tokenizer
)

# Spuštění trainingu
dpo_trainer.train()

Praktické výhody oproti RLHF

DPO přináší několik významných výhod oproti tradičnímu RLHF přístupu. Především eliminuje nutnost trénovat separátní reward model, což výrazně snižuje výpočetní nároky a komplexitu pipeline.

Stabilita tréninku je dalším klíčovým benefitem. RLHF často trpí nestabilitou kvůli interakci mezi policy a reward modelem. DPO tento problém řeší přímou optimalizací, což vede k konzistentnějším výsledkům.

# Srovnání complexity
# RLHF pipeline:
# 1. Supervised fine-tuning
# 2. Reward model training  
# 3. PPO optimization (nestabilní)

# DPO pipeline:
# 1. Supervised fine-tuning
# 2. Direct preference optimization (stabilní)

Hyperparameter tuning a best practices

Klíčovým hyperparametrem v DPO je beta hodnota, která kontroluje trade-off mezi alignmentem a zachováním původních schopností modelu. Nižší beta (0.01-0.1) poskytuje jemnější změny, zatímco vyšší hodnoty (0.5-1.0) vedou k agresivnějšímu alignmentu.

# Experimentování s beta hodnotami
beta_values = [0.01, 0.1, 0.5, 1.0]
results = {}

for beta in beta_values:
    config = DPOConfig(beta=beta, learning_rate=1e-6)
    trainer = DPOTrainer(model=model, args=config, ...)
    
    # Vyhodnocení na validation setu
    metrics = trainer.evaluate()
    results[beta] = metrics["eval_loss"]
    
print(f"Optimální beta: {min(results, key=results.get)}")

Důležité je také monitorovat KL divergenci mezi původním a optimalizovaným modelem. Příliš vysoká divergence může indikovat "alignment tax" - ztrátu původních schopností modelu.

Monitoring a evaluace

Úspěšná implementace DPO vyžaduje pečlivé monitorování několika metrik. Kromě standardní loss funkce je důležité sledovat win-rate na held-out preference data a qualitativně hodnotit výstupy modelu:

def evaluate_preferences(model, eval_dataset):
    correct_predictions = 0
    total_pairs = len(eval_dataset)
    
    for example in eval_dataset:
        prompt = example["prompt"]
        chosen = example["chosen"]
        rejected = example["rejected"]
        
        # Spočítání log-likelihood pro obě odpovědi
        chosen_ll = compute_log_likelihood(model, prompt, chosen)
        rejected_ll = compute_log_likelihood(model, prompt, rejected)
        
        if chosen_ll > rejected_ll:
            correct_predictions += 1
    
    win_rate = correct_predictions / total_pairs
    return win_rate

Limitace a future directions

Ačkoli DPO představuje významný pokrok, má své limitace. Metoda předpokládá, že preference data jsou konzistentní a reprezentativní, což nemusí vždy platit v reálných scénářích. Také může trpět mode collapse při nesprávném nastavení hyperparametrů.

Současný výzkum se zaměřuje na rozšíření DPO pro multi-objective optimization a incorporaci uncertainty do preference modelování. Další směr představuje kombinace DPO s constitutional AI přístupy.