AI-modeller og platforme
Direkte Præferenceoptimering: En Komplet Guide
Føj Unite.AI til dine foretrukne kilder på Google
At tilpasse store sprogmodeller (LLM’er) til menneskelige værdier og præferencer er en udfordring. Traditionelle metoder, såsom Reinforcement Learning fra Menneskeligt Feedback (RLHF), har banet vejen ved at integrere menneskeligt input for at raffinere modeloutput. However, RLHF kan være kompleks og ressourcekrævende, og kræver betydelig beregningskraft og dataprocessing. Direkte Præferenceoptimering (DPO) opstår som en ny og mere strømlinet tilgang, der tilbyder en effektiv alternativ til disse traditionelle metoder. Ved at forenkle optimeringsprocessen reducerer DPO ikke kun den beregningsmæssige byrde, men forbedrer også modellens evne til at tilpasse sig hurtigt til menneskelige præferencer
I denne guide dykker vi dybt ind i DPO, hvor vi udforsker dets grundlag, implementering og praktiske anvendelser.
Behovet for Præferencealignering
For at forstå DPO er det afgørende at forstå, hvorfor det er så vigtigt at tilpasse LLM’er til menneskelige præferencer. Trods deres imponerende evner kan LLM’er, der er trænet på store datasæt, nogle gange producere output, der er inkonsistent, fordomsfuldt eller ikke er i overensstemmelse med menneskelige værdier. Denne misalignering kan manifestere sig på forskellige måder:
- Genererer usikre eller skadelige indhold
- Forsyner ukorrekte eller misvisende oplysninger
- Viser fordomme, der er til stede i træningsdata
For at løse disse problemer har forskere udviklet teknikker til at finjustere LLM’er ved hjælp af menneskeligt feedback. Den mest fremtrædende af disse tilgange har været RLHF.
Forståelse af RLHF: Førleden til DPO
Reinforcement Learning fra Menneskeligt Feedback (RLHF) har været den foretrukne metode til at tilpasse LLM’er til menneskelige præferencer. Lad os bryde ned RLHF-processen for at forstå dens kompleksitet:
a) Overvåget Finjustering (SFT): Processen begynder med at finjustere en fortrænet LLM på en datasæt med højkvalitetsrespons. Dette skridt hjælper modellen med at generere mere relevante og sammenhængende output for målopgaven.
b) Belønningsmodellering: En separat belønningsmodel trænes for at forudsige menneskelige præferencer. Dette involverer:
- Genererer responspar for givne prompts
- Mennesker vurderer, hvilken respons de foretrækker
- Træner en model til at forudsige disse præferencer
c) Reinforcement Learning: Den finjusterede LLM optimeres herefter yderligere ved hjælp af reinforcement learning. Belønningsmodellen giver feedback, der vejleder LLM’en til at generere respons, der er i overensstemmelse med menneskelige præferencer.
Her er et forenklet Python-pseudokode til at illustrere RLHF-processen:
Selvom det er effektivt, har RLHF flere ulemper:
- Det kræver træning og vedligeholdelse af flere modeller (SFT, belønningsmodel og RL-optimeret model)
- RL-processen kan være ustabil og følsom over for hyperparametre
- Det er beregningskrævende og kræver mange fremad- og bagadgående gennemløb af modellerne
Disse begrænsninger har motiveret søgningen efter enklere og mere effektive alternativer, hvilket har ført til udviklingen af DPO.
Direkte Præferenceoptimering: Kernebegreber
Direkte Præferenceoptimering https://arxiv.org/abs/2305.18290
Dette billede kontrasterer to forskellige tilgange til at tilpasse LLM-output til menneskelige præferencer: Reinforcement Learning fra Menneskeligt Feedback (RLHF) og Direkte Præferenceoptimering (DPO). RLHF afhænger af en belønningsmodel til at vejlede sprogmodellens politik gennem iterative feedback-løkker, mens DPO direkte optimerer modeloutput til at matche menneskeligt foretrukne respons ved hjælp af præferencedata. Denne sammenligning fremhæver styrkerne og potentielle anvendelser af hver metode og giver indsigt i, hvordan fremtidige LLM’er kan trænes til bedre at tilpasse sig menneskelige forventninger.
Nøgleideer bag DPO:
a) Implicit Belønningsmodellering: DPO eliminerer behovet for en separat belønningsmodel ved at behandle sprogmodellen selv som en implicit belønningsskala.
b) Policy-baseret Formulering: I stedet for at optimere en belønningsskala optimerer DPO direkte politikken (sprogmodellen) for at maksimere sandsynligheden for foretrukne respons.
c) Lukket Formulering: DPO udnytter en matematisk indsigt, der tillader en lukket formulering af den optimale politik, og undgår dermed behovet for iterative RL-opdateringer.
Implementering af DPO: En Praktisk Kodegennemgang
Det nedenstående billede viser en kodeeksempel, der implementerer DPO-tab-funktionen ved hjælp af PyTorch. Denne funktion spiller en afgørende rolle i at raffinere, hvordan sprogmodeller prioriterer output baseret på menneskelige præferencer. Her er en gennemgang af de vigtigste komponenter:
- Funktionsignatur: DPO-tab-funktionen tager flere parametre, herunder politik log-sandsynligheder (
pi_logps), reference model log-sandsynligheder (ref_logps) og indekser, der repræsenterer foretrukne og ikke-foretrukne kompletioner (yw_idxs,yl_idxs). Derudover kontrollererbeta-parametren styrken af KL-straffet. - Log-sandsynlighedsudtrækning: Koden udtrækker log-sandsynligheder for foretrukne og ikke-foretrukne kompletioner fra både politik- og reference-modellerne.
- Log-ratio-beregning: Forskellen mellem log-sandsynligheder for foretrukne og ikke-foretrukne kompletioner beregnes for både politik- og reference-modellerne. Denne ratio er afgørende for at bestemme retningen og størrelsen af optimeringen.
- Tab og belønning beregning: Tab beregnes ved hjælp af
logsigmoid-funktionen, mens belønninger bestemmes ved at skalaere forskellen mellem politik- og reference log-sandsynligheder medbeta.
DPO-tab-funktion ved hjælp af PyTorch
Lad os dykke ned i matematikken bag DPO for at forstå, hvordan det opnår disse mål.
Matematikken bag DPO
DPO er en intelligent omformulering af præference-læringsproblemet. Her er en trin-for-trin-gennemgang:
a) Startpunkt: KL-begrænsning af Belønningsoptimering
Det oprindelige RLHF-mål kan udtrykkes som:
- πθ er politikken (sprogmodellen), vi optimerer
- r(x,y) er belønningsskalaen
- πref er en referencepolitik (normalt den oprindelige SFT-model)
- β kontrollerer styrken af KL-afvigelsen
b) Optimal Politikform: Det kan bevises, at den optimale politik for dette mål tager formen:
π_r(y|x) = 1/Z(x) * πref(y|x) * exp(1/β * r(x,y))Hvor Z(x) er en normaliseringskonstant.
c) Belønning-Politik Dualitet: DPO’s nøgleindsigt er at udtrykke belønningsskalaen i forhold til den optimale politik:
r(x,y) = β * log(π_r(y|x) / πref(y|x)) + β * log(Z(x))d) Præference-Modellering Under antagelse af, at præferencer følger Bradley-Terry-modellen, kan vi udtrykke sandsynligheden for at foretrække y1 over y2 som:
p*(y1 ≻ y2 | x) = σ(r*(x,y1) - r*(x,y2))Hvor σ er den logistiske funktion.
e) DPO-Mål Ved at erstatte vores belønning-politik-dualitet i præference-modellen kommer vi til DPO-målet:
L_DPO(πθ; πref) = -E_(x,y_w,y_l)~D [log σ(β * log(πθ(y_w|x) / πref(y_w|x)) - β * log(πθ(y_l|x) / πref(y_l|x)))]Dette mål kan optimeres ved hjælp af standard gradient descent-teknikker uden behov for RL-algoritmer.
Implementering af DPO
Nu, hvor vi forstår teorien bag DPO, lad os se på, hvordan vi kan implementere det i praksis. Vi vil bruge Python og PyTorch til dette eksempel:
import torch
import torch.nn.functional as F
<p>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)</p>
<p>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</p>
<p>Each pair of (yw_idxs[i], yl_idxs[i]) represents the indices of a single preference pair.
"""</p>
<p># 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]</p>
<p># Calculate log-ratios
pi_logratios = pi_yw_logps - pi_yl_logps
ref_logratios = ref_yw_logps - ref_yl_logps</p>
<p># Compute DPO loss
losses = -F.logsigmoid(self.beta * (pi_logratios - ref_logratios))
rewards = self.beta * (pi_logps - ref_logps).detach()</p>
return losses.mean(), rewards
<p>def train_step(self, batch):
x, yw_idxs, yl_idxs = batch
self.optimizer.zero_grad()</p>
<p># 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)</p>
<p># Compute the loss
loss, _ = self.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
loss.backward()
self.optimizer.step()</p>
return loss.item()
<p># Usage
model = YourLanguageModel() # Initialize your model
ref_model = YourLanguageModel() # Load pre-trained reference model
trainer = DPOTrainer(model, ref_model)</p>
<p>for batch in dataloader:
loss = trainer.train_step(batch)
print(f"Loss: {loss}")
Udfordringer og Fremtidige Retninger
Selvom DPO tilbyder betydelige fordele i forhold til traditionelle RLHF-tilgange, er der stadig udfordringer og områder for yderligere forskning:
a) Skalering til Større Modeller:
Da sprogmodeller fortsætter med at vokse i størrelse, er det en åben udfordring at anvende DPO effektivt til modeller med hundredvis af milliarder af parametre. Forskere udforsker teknikker som:
- Effektive finjusteringsmetoder (f.eks. LoRA, prefix-tuning)
- Distributed træningsoptimeringer
- Gradient checkpointing og mixed-precision træning
Eksempel på brug af LoRA med DPO:
<p>from peft import LoraConfig, get_peft_model</p> <p>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)</p> <p># Usage base_model = YourLargeLanguageModel() dpo_trainer = DPOTrainerWithLoRA(base_model, ref_model)
b) Multi-Task og Few-Shot Tilpasning:
Udvikling af DPO-teknikker, der kan tilpasse sig nye opgaver eller domæner med begrænsede præference-data, er et aktivt forskningsområde. Tilgange, der udforskes, omfatter:
- Meta-læringsrammer for hurtig tilpasning
- Prompt-baseret finjustering for DPO
- Overføring af viden fra generelle præference-modeller til specifikke domæner
c) Håndtering af Tvetydige eller Modstridende Præferencer:
Rigtige præference-data indeholder ofte tvetydigheder eller modstridende præferencer. Forbedring af DPO’s robusthed over for sådanne data er afgørende. Potentielle løsninger omfatter:
- Probabilistisk præference-modellering
- Active learning til at løse tvetydigheder
- Multi-agent præference-aggregering
Eksempel på probabilistisk præference-modellering:
<p>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]</p> <p>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()</p> <p># 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) Kombination af DPO med Andre Tilpasningsmetoder:
Integrering af DPO med andre tilpasningsmetoder kan føre til mere robuste og kapable systemer:
- Constitutional AI-principper for eksplitt konstruktionsopfyldelse
- Debate og rekursiv belønningsskala-modellering for kompleks præference-udvinding
- Inverse reinforcement learning til at udlede underliggende belønningsskalaer
Eksempel på kombination af DPO med constitutional AI:
<p>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 []</p> <p>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)</p> <p>constraint_loss = 0 for constraint in self.constraints: constraint_loss += constraint(self.model, pi_logps, ref_logps, yw_idxs, yl_idxs)</p> return base_loss + constraint_loss <p># 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 &gt; 0.5</p> <p>constraints = [safety_constraint] trainer = ConstitutionalDPOTrainer(model, ref_model, constraints=constraints)</p>
Praktiske Overvejelser og Bedste Praksis
Når du implementerer DPO for virkelige anvendelser, overvej følgende råd:
a) Datakvalitet: Kvaliteten af dine præference-data er afgørende. Sørg for, at din datasæt:
- Dækker et bredt udvalg af input og ønskede beteendener
- Har konsekvente og pålidelige præference-annoteringer
- Balancerer forskellige typer præferencer (f.eks. faktualitet, sikkerhed, stil)
b) Hyperparameter-justering: Selvom DPO har færre hyperparametre end RLHF, er justering stadig vigtig:
- β (beta): Kontrollerer trade-off’en mellem præference-tilfredsstillelse og afvigelse fra reference-modellen. Start med værdier omkring 0,1-0,5.
- Læringsrate: Brug en lavere læringsrate end standard finjustering, typisk i området 1e-6 til 1e-5.
- Batch-størrelse: Større batch-størrelser (32-128) virker ofte godt for præference-læring.
c) Iterativ Raffinering: DPO kan anvendes iterativt:
- Træn en initial model ved hjælp af DPO
- Generér nye respons ved hjælp af den trænede model
- Saml nye præference-data på disse respons
- Træn igen ved hjælp af den udvidede datasæt
Direkte Præferenceoptimering Performance
Dette billede viser LLM’ers præstationer, som GPT-4, i sammenligning med menneskelige vurderinger på tværs af forskellige træningsmetoder, herunder Direkte Præferenceoptimering (DPO), Overvåget Finjustering (SFT) og Proximal Policy Optimization (PPO). Tabellen afslører, at GPT-4’s output er mere og mere i overensstemmelse med menneskelige præferencer, især i sammenfattningsopgaver. Niveauet af enighed mellem GPT-4 og menneskelige vurderere demonstrerer modellens evne til at generere indhold, der resonerer med menneskelige vurderere, næsten lige så tæt som menneskeskabt indhold gør.
Sagsstudier og Anvendelser
For at illustrere effekten af DPO, lad os se på nogle virkelige anvendelser og nogle af dets varianter:
- Iterativ DPO: Udviklet af Snorkel (2023), denne variant kombinerer rejection-sampling med DPO, hvilket muliggør en mere raffineret udvælgelsesproces for træningsdata. Ved at iterere over flere runder af præference-sampling kan modellen bedre generalisere og undgå overfitning til støjende eller fordomsfulde præferencer.
- IPO (Iterativ Præferenceoptimering): Introduceret af Azar et al. (2023), IPO tilføjer en regulariserings-term for at forhindre overfitning, hvilket er et almindeligt problem i præference-baseret optimering. Denne udvidelse tillader modellerne at opretholde en balance mellem at tilpasse sig præferencer og bevare generaliserings-evner.
- KTO (Videns-Overføringsoptimering): En mere ny variant fra Ethayarajh et al. (2023), KTO eliminerer binære præferencer helt. I stedet fokuserer den på at overføre viden fra en reference-model til politik-modellen, og optimerer for en mere jævn og konsekvent tilpasning til menneskelige værdier.
- Multi-Modal DPO for Cross-Domain Learning af Xu et al. (2024): En tilgang, hvor DPO anvendes på tværs af forskellige modaliteter – tekst, billeder og lyd – og demonstrerer dets fleksibilitet i at tilpasse modeller til menneskelige præferencer på tværs af diverse data-typer. Denne forskning fremhæver potentialet for DPO i at skabe mere omfattende AI-systemer, der kan håndtere komplekse, multi-modale opgaver.
Konklusion
Direkte Præferenceoptimering repræsenterer en betydelig fremgang i at tilpasse sprogmodeller til menneskelige præferencer. Dens enkelhed, effektivitet og effekt gør det til et kraftfuldt værktøj for både forskere og praktikere.
Ved at udnytte kraften af Direkte Præferenceoptimering og følge disse principper kan du skabe sprogmodeller, der ikke kun viser imponerende evner, men også tilpasser sig menneskelige værdier og intentioner.
