Ottimizzazione delle preferenze dirette: una guida completa

import torch
import torch.nn.functional as F

class DPOTrainer:
    def __init__(self, model, ref_model, beta=0.1, lr=1e-5):
        self.model = model
        self.ref_model = ref_model
        self.beta = beta
        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)
    
    def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
        """
        pi_logps: policy logprobs, shape (B,)
        ref_logps: reference model logprobs, shape (B,)
        yw_idxs: preferred completion indices in [0, B-1], shape (T,)
        yl_idxs: dispreferred completion indices in [0, B-1], shape (T,)
        beta: temperature controlling strength of KL penalty

        Each pair of (yw_idxs[i], yl_idxs[i]) represents the indices of a single preference pair.
        """

        # Extract log probabilities for the preferred and dispreferred completions
        pi_yw_logps, pi_yl_logps = pi_logps[yw_idxs], pi_logps[yl_idxs]
        ref_yw_logps, ref_yl_logps = ref_logps[yw_idxs], ref_logps[yl_idxs]

        # Calculate log-ratios
        pi_logratios = pi_yw_logps - pi_yl_logps
        ref_logratios = ref_yw_logps - ref_yl_logps

        # Compute DPO loss
        losses = -F.logsigmoid(self.beta * (pi_logratios - ref_logratios))
        rewards = self.beta * (pi_logps - ref_logps).detach()

        return losses.mean(), rewards

    def train_step(self, batch):
        x, yw_idxs, yl_idxs = batch
        self.optimizer.zero_grad()

        # Compute log probabilities for the model and the reference model
        pi_logps = self.model(x).log_softmax(-1)
        ref_logps = self.ref_model(x).log_softmax(-1)

        # Compute the loss
        loss, _ = self.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
        loss.backward()
        self.optimizer.step()

        return loss.item()

# Usage
model = YourLanguageModel()  # Initialize your model
ref_model = YourLanguageModel()  # Load pre-trained reference model
trainer = DPOTrainer(model, ref_model)

for batch in dataloader:
    loss = trainer.train_step(batch)
    print(f"Loss: {loss}")

Sfide e direzioni future

Sebbene il DPO offra vantaggi significativi rispetto agli approcci RLHF tradizionali, ci sono ancora sfide e aree per ulteriori ricerche:

a) Scalabilità a modelli più grandi:

Poiché i modelli linguistici continuano a crescere di dimensioni, applicare in modo efficiente il DPO a modelli con centinaia di miliardi di parametri rimane una sfida aperta. I ricercatori stanno esplorando tecniche come:

• Metodi di ottimizzazione efficienti (ad esempio, LoRA, ottimizzazione del prefisso)
• Ottimizzazioni della formazione distribuita
• Checkpoint del gradiente e training a precisione mista

Esempio di utilizzo di LoRA con DPO:

from peft import LoraConfig, get_peft_model

class DPOTrainerWithLoRA(DPOTrainer):
    def __init__(self, model, ref_model, beta=0.1, lr=1e-5, lora_rank=8):
        lora_config = LoraConfig(
            r=lora_rank,
            lora_alpha=32,
            target_modules=["q_proj", "v_proj"],
            lora_dropout=0.05,
            bias="none",
            task_type="CAUSAL_LM"
        )
        self.model = get_peft_model(model, lora_config)
        self.ref_model = ref_model
        self.beta = beta
        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)

# Usage
base_model = YourLargeLanguageModel()
dpo_trainer = DPOTrainerWithLoRA(base_model, ref_model)

b) Adattamento multi-task e pochi scatti:

Lo sviluppo di tecniche DPO in grado di adattarsi in modo efficiente a nuovi compiti o domini con dati sulle preferenze limitati è un’area di ricerca attiva. Gli approcci esplorati includono:

• Strutture di meta-apprendimento per un rapido adattamento
• Ottimizzazione basata su prompt per DPO
• Trasferire l'apprendimento dai modelli di preferenza generale a domini specifici

c) Gestione delle preferenze ambigue o contrastanti:

I dati sulle preferenze del mondo reale spesso contengono ambiguità o conflitti. Migliorare la robustezza del DPO rispetto a tali dati è fondamentale. Le potenziali soluzioni includono:

• Modellizzazione delle preferenze probabilistiche
• Apprendimento attivo per risolvere ambiguità
• Aggregazione delle preferenze multi-agente

Esempio di modellazione delle preferenze probabilistiche:

class ProbabilisticDPOTrainer(DPOTrainer):
    def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob):
        # Compute log ratios
        pi_yw_logps, pi_yl_logps = pi_logps[yw_idxs], pi_logps[yl_idxs]
        ref_yw_logps, ref_yl_logps = ref_logps[yw_idxs], ref_logps[yl_idxs]
        
        log_ratio_diff = pi_yw_logps.sum(-1) - pi_yl_logps.sum(-1)
        loss = -(preference_prob * F.logsigmoid(self.beta * log_ratio_diff) +
                 (1 - preference_prob) * F.logsigmoid(-self.beta * log_ratio_diff))
        return loss.mean()

# Usage
trainer = ProbabilisticDPOTrainer(model, ref_model)
loss = trainer.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob=0.8)  # 80% confidence in preference

d) Combinazione del DPO con altre tecniche di allineamento:

L’integrazione del DPO con altri approcci di allineamento potrebbe portare a sistemi più robusti e capaci:

• Principi costituzionali dell'intelligenza artificiale per la soddisfazione esplicita dei vincoli
• Modellizzazione del dibattito e della ricompensa ricorsiva per l'elicitazione di preferenze complesse
• Apprendimento per rinforzo inverso per dedurre le funzioni di ricompensa sottostanti

Esempio di combinazione del DPO con l’IA costituzionale:

class ConstitutionalDPOTrainer(DPOTrainer):
    def __init__(self, model, ref_model, beta=0.1, lr=1e-5, constraints=None):
        super().__init__(model, ref_model, beta, lr)
        self.constraints = constraints or []

    def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
        base_loss = super().compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
        
        constraint_loss = 0
        for constraint in self.constraints:
            constraint_loss += constraint(self.model, pi_logps, ref_logps, yw_idxs, yl_idxs)
        
        return base_loss + constraint_loss

# Usage
def safety_constraint(model, pi_logps, ref_logps, yw_idxs, yl_idxs):
    # Implement safety checking logic
    unsafe_score = compute_unsafe_score(model, pi_logps, ref_logps)
    return torch.relu(unsafe_score - 0.5)  # Penalize if unsafe score > 0.5

constraints = [safety_constraint]
trainer = ConstitutionalDPOTrainer(model, ref_model, constraints=constraints)

Considerazioni pratiche e migliori pratiche

Quando implementi DPO per applicazioni reali, considera i seguenti suggerimenti:

a) Qualità dei dati: La qualità dei tuoi dati sulle preferenze è fondamentale. Assicurati che il tuo set di dati:

• Copre una vasta gamma di input e comportamenti desiderati
• Presenta annotazioni sulle preferenze coerenti e affidabili
• Bilancia diversi tipi di preferenze (ad esempio, fattualità, sicurezza, stile)

b) Sintonia iperparametro: Sebbene DPO abbia meno iperparametri di RLHF, l'ottimizzazione è comunque importante:

• β (beta): controlla il compromesso tra soddisfazione delle preferenze e divergenza dal modello di riferimento. Inizia con i valori in giro 0.1-0.5.
• Tasso di apprendimento: utilizzare un tasso di apprendimento inferiore rispetto alla regolazione fine standard, in genere nell'intervallo di Da 1e-6 a 1e-5.
• Dimensione del lotto: dimensioni del lotto più grandi (32-128) spesso funzionano bene per l'apprendimento delle preferenze.

c) Perfezionamento iterativo: DPO può essere applicato in modo iterativo:

1. Addestrare un modello iniziale utilizzando DPO
2. Genera nuove risposte utilizzando il modello addestrato
3. Raccogli nuovi dati sulle preferenze su queste risposte
4. Riqualificare utilizzando il set di dati espanso

 

Prestazioni di ottimizzazione delle preferenze dirette

Questa immagine mostra le prestazioni di LLM come GPT-4 rispetto ai giudizi umani in varie tecniche di formazione, tra cui Direct Preference Optimization (DPO), Supervised Fine-Tuning (SFT) e Proximal Policy Optimization (PPO). La tabella rivela che gli output di GPT-4 sono sempre più allineati con le preferenze umane, specialmente nelle attività di riepilogo. Il livello di accordo tra GPT-4 e i revisori umani dimostra la capacità del modello di generare contenuti che risuonano con i valutatori umani, quasi quanto i contenuti generati dagli umani.

Casi di studio e applicazioni

Per illustrare l'efficacia del DPO, diamo un'occhiata ad alcune applicazioni del mondo reale e ad alcune delle sue varianti:

• DPO iterativo: sviluppata da Snorkel (2023), questa variante combina il campionamento del rifiuto con DPO, consentendo un processo di selezione più raffinato per i dati di addestramento. Iterando su più cicli di campionamento delle preferenze, il modello è in grado di generalizzare meglio ed evitare un adattamento eccessivo a preferenze rumorose o distorte.
• IPO (Ottimizzazione iterativa delle preferenze): Introdotto da Azar et al. (2023), l’IPO aggiunge un termine di regolarizzazione per prevenire l’overfitting, che è un problema comune nell’ottimizzazione basata sulle preferenze. Questa estensione consente ai modelli di mantenere un equilibrio tra l’adesione alle preferenze e il mantenimento delle capacità di generalizzazione.
• KTO (Ottimizzazione del trasferimento della conoscenza): Una variante più recente di Ethayarajh et al. (2023), KTO rinuncia del tutto alle preferenze binarie. Si concentra invece sul trasferimento della conoscenza da un modello di riferimento al modello politico, ottimizzando un allineamento più fluido e coerente con i valori umani.
• DPO multimodale per l'apprendimento interdominio di Xu et al. (2024): un approccio in cui il DPO viene applicato in diverse modalità (testo, immagine e audio) dimostrando la sua versatilità nell'allineare i modelli alle preferenze umane attraverso diversi tipi di dati. Questa ricerca evidenzia il potenziale del DPO nella creazione di sistemi di intelligenza artificiale più completi in grado di gestire compiti complessi e multimodali.

Conclusione

L'ottimizzazione delle preferenze dirette rappresenta un progresso significativo nell'allineamento dei modelli linguistici con le preferenze umane. La sua semplicità, efficienza ed efficacia lo rendono uno strumento potente sia per ricercatori che per professionisti.

Sfruttando la potenza dell'ottimizzazione delle preferenze dirette e tenendo presenti questi principi, puoi creare modelli linguistici che non solo mostrano capacità impressionanti, ma si allineano anche strettamente con i valori e le intenzioni umane.