Modely a platformy AI
Přímá optimalizace preferencí: Úplný průvodce
Přidejte Unite.AI mezi své preferované zdroje na Google
Sladění velkých jazykových modelů (LLM) s lidskými hodnotami a preferencemi je náročné. Tradiční metody, jako je Reinforcement Learning from Human Feedback (RLHF), otevřely cestu integrací lidských vstupů pro rafinování výstupů modelu. Nicméně RLHF může být komplexní a náročná na zdroje, vyžadující podstatnou výpočetní sílu a zpracování dat. Přímá optimalizace preferencí (DPO) se objevuje jako novinka a více streamlinovaná metoda, nabízející efektivní alternativu k těmto tradičním metodám. Zjednodušením procesu optimalizace snižuje DPO nejen výpočetní zátěž, ale také zlepšuje schopnost modelu rychle se přizpůsobit lidským preferencím.
V tomto průvodci se budeme hluboce zabývat DPO, prozkoumáme její základy, implementaci a praktické aplikace.
Potřebnost sladění preferencí
Abychom pochopili DPO, je důležité pochopit, proč je sladění LLM s lidskými preferencemi tak důležité. Navzdory jejich působivým schopnostem mohou LLM vyškolené na rozsáhlých datech někdy produkovat výstupy, které jsou nekonzistentní, zkreslené nebo nesouladné s lidskými hodnotami. Tento nesoulad se může projevit různými způsoby:
- Generování nebezpečného nebo škodlivého obsahu
- Poskytování nesprávných nebo zavádějících informací
- Projevování zkreslení přítomných ve výcvikových datech
Abyste tyto problémy vyřešili, výzkumníci vyvinuli techniky pro jemné ladění LLM pomocí lidské zpětné vazby. Nejvýraznější z těchto přístupů je RLHF.
Pochopení RLHF: Předchůdce DPO
Reinforcement Learning from Human Feedback (RLHF) byl metodou volby pro sladění LLM s lidskými preferencemi. Rozložíme proces RLHF, abychom pochopili jeho složitost:
a) Dozorované jemné ladění (SFT): Proces začíná jemným laděním předem vyškoleného LLM na datasetu vysoce kvalitních odpovědí. Tento krok pomáhá modelu generovat relevantnější a koherentnější výstupy pro cílovou úlohu.
b) Modelování odměn: Zvláštní model odměn je vyškolován, aby předpovídal lidské preference. To zahrnuje:
- Generování párů odpovědí pro dané podněty
- Lidé ohodnotí, kterou odpověď preferují
- Školení modelu, aby předpovídal tyto preference
c) Učení s posilováním: Jemně laděný LLM je poté dále optimalizován pomocí učení s posilováním. Model odměn poskytuje zpětnou vazbu, která řídí LLM k generování odpovědí, které jsou v souladu s lidskými preferencemi.
Zde je zjednodušený Python pseudokód, který ilustruje proces RLHF:
Přestože je RLHF efektivní, má několik nevýhod:
- Vyžaduje školení a údržbu více modelů (SFT, model odměn a model optimalizovaný RL)
- Proces RL může být nestabilní a citlivý na hyperparametry
- Je výpočetně nákladný, vyžadující mnoho vpřed a vzad procházení modely
Tyto omezení vedly k hledání jednodušších a efektivnějších alternativ, což vedlo k vývoji DPO.
Přímá optimalizace preferencí: Základní koncepty
Přímá optimalizace preferencí https://arxiv.org/abs/2305.18290
Tento obrázek kontrastuje dva rozdílné přístupy ke sladění výstupů LLM s lidskými preferencemi: Učení s posilováním z lidské zpětné vazby (RLHF) a Přímá optimalizace preferencí (DPO). RLHF spoléhá na model odměn, aby řídil politiku jazykového modelu prostřednictvím iterativních zpětnovazebních smyček, zatímco DPO přímo optimalizuje výstupy modelu, aby odpovídaly lidským preferencím pomocí preferenčních dat. Tento srovnávací obrázek zdůrazňuje silné a potenciální aplikace každé metody, poskytující vhled do toho, jak budou budoucí LLM vyškoleny tak, aby lépe odpovídaly lidským očekáváním.
Klíčové myšlenky za DPO:
a) Implicitní modelování odměn: DPO eliminuje potřebu samostatného modelu odměn, jelikož považuje jazykový model sám o sobě za implicitní funkci odměn.
b) Formulace založená na politice: Místo optimalizace funkce odměn DPO přímo optimalizuje politiku (jazykový model), aby maximalizovala pravděpodobnost preferovaných odpovědí.
c) Řešení v uzavřené formě: DPO využívá matematického vhledu, který umožňuje řešení v uzavřené formě pro optimální politiku, čímž se vyhýbá potřebě iterativních aktualizací RL.
Implementace DPO: Praktický procházení kódu
Níže uvedený obrázek ukazuje ukázku kódu implementující funkci ztráty DPO pomocí PyTorch. Tato funkce hraje zásadní roli při rafinování, jak jazykové modely priorizují výstupy na základě lidských preferencí. Zde je rozbor klíčových komponent:
- Podpis funkce: Funkce
dpo_lossbere několik parametrů, včetně logaritmových pravděpodobností politiky (pi_logps), logaritmových pravděpodobností referenčního modelu (ref_logps) a indexů reprezentujících preferované a nepreferované dokončení (yw_idxs,yl_idxs). Kromě toho parametrbetakontroluje sílu penalty KL. - Extrakce logaritmových pravděpodobností: Kód extrahuje logaritmové pravděpodobnosti pro preferované a nepreferované dokončení z obou modelů politiky a referenčního modelu.
- Výpočet logaritmového poměru: Rozdíl mezi logaritmovými pravděpodobnostmi pro preferované a nepreferované dokončení je vypočten pro oba modely politiky a referenčního modelu. Tento poměr je kritický pro určení směru a velikosti optimalizace.
- Výpočet ztráty a odměny: Ztráta je vypočtena pomocí
logsigmoidfunkce, zatímco odměny jsou určeny škálou rozdílu mezi logaritmovými pravděpodobnostmi politiky a referenčního modelubeta.
Ponořme se do matematiky za DPO, abychom pochopili, jak dosahuje těchto cílů.
Matematika DPO
DPO je chytrá reformulace problému učení preferencí. Zde je krok za krokem rozbor:
a) Startovní bod: Maximální odměna s omezením KL
Původní cíl RLHF lze vyjádřit jako:
- πθ je politika (jazykový model), kterou optimalizujeme
- r(x,y) je funkce odměn
- πref je referenční politika (obvykle počáteční model SFT)
- β kontroluje sílu omezení divergence KL
b) Optimální forma politiky: Můžeme ukázat, že optimální politika pro tento cíl má formu:
π_r(y|x) = 1/Z(x) * πref(y|x) * exp(1/β * r(x,y))Kde Z(x) je normalizační konstanta.
c) Dualita odměny a politiky: Klíčovým vhledem DPO je vyjádření funkce odměn v termínech optimální politiky:
r(x,y) = β * log(π_r(y|x) / πref(y|x)) + β * log(Z(x))d) Preference Model Předpokládejme, že preference následují model Bradley-Terry, můžeme vyjádřit pravděpodobnost preference y1 nad y2 jako:
p*(y1 ≻ y2 | x) = σ(r*(x,y1) - r*(x,y2))Kde σ je logistická funkce.
e) Cíl DPO Nahrazujeme dualitu odměny a politiky do modelu preference, abychom získali cíl DPO:
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)))]Tento cíl lze optimalizovat pomocí standardních technik gradientového sestupu, bez potřeby algoritmů RL.
Implementace DPO
Teď, když rozumíme teorii za DPO, podívejme se, jak ji implementovat v praxi. Budeme používat Python a PyTorch pro tento příklad:
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: logaritmové pravděpodobnosti politiky, tvar (B,)
ref_logps: logaritmové pravděpodobnosti referenčního modelu, tvar (B,)
yw_idxs: indexy preferovaných dokončení v [0, B-1], tvar (T,)
yl_idxs: indexy nepreferovaných dokončení v [0, B-1], tvar (T,)
beta: teplota kontrolující sílu penalty KL</p>
<p>Každý pár (yw_idxs[i], yl_idxs[i]) reprezentuje indexy jednoho preferenčního páru.
"""</p>
<p># Extrahujte logaritmové pravděpodobnosti pro preferované a nepreferované dokončení
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># Vypočítejte logaritmové poměry
pi_logratios = pi_yw_logps - pi_yl_logps
ref_logratios = ref_yw_logps - ref_yl_logps</p>
<p># Vypočítejte ztrátu DPO
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># Vypočítejte logaritmové pravděpodobnosti pro model a referenční model
pi_logps = self.model(x).log_softmax(-1)
ref_logps = self.ref_model(x).log_softmax(-1)</p>
<p># Vypočítejte ztrátu
loss, _ = self.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
loss.backward()
self.optimizer.step()</p>
return loss.item()
<p># Použití
model = VášJazykovýModel() # Inicializujte váš model
ref_model = VášJazykovýModel() # Načtěte předem vyškolený referenční model
trainer = DPOTrainer(model, ref_model)</p>
<p>for batch in dataloader:
loss = trainer.train_step(batch)
print(f"Ztráta: {loss}")
Výzvy a budoucí směry
Přestože DPO nabízí významné výhody oproti tradičním přístupům RLHF, existují stále výzvy a oblasti pro další výzkum:
a) Škálovatelnost na větší modely:
Jak jazykové modely dále rostou, efektivně aplikovat DPO na modely s stovkami miliard parametrů zůstává otevřenou výzvou. Výzkumníci zkoumají techniky, jako jsou:
- Účinné metody jemného ladění (například LoRA, prefix tuning)
- Distribuované optimalizace školení
- Checkpointing gradientů a školení s proměnnou přesností
Příklad použití LoRA s 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># Použití base_model = VášVelkýJazykovýModel() dpo_trainer = DPOTrainerWithLoRA(base_model, ref_model)
b) Víceúlohová a few-shot adaptace:
Vývoj technik DPO, které mohou efektivně přizpůsobit nové úlohy nebo domény s omezenými preferenčními daty, je aktivní oblastí výzkumu. Přístupy, které jsou zkoumány, zahrnují:
- Meta-učení pro rychlou adaptaci
- Prompt-based jemné ladění pro DPO
- Přenosové učení z obecných modelů preferencí do konkrétních domén
c) Zpracování nejednoznačných nebo rozporuplných preferencí:
Reálná preferenční data často obsahují nejednoznačnosti nebo rozporuplnosti. Zlepšení odolnosti DPO vůči takovým datům je zásadní. Potenciální řešení zahrnují:
- Probabilistické modelování preferencí
- Aktivní učení pro řešení nejednoznačností
- Multi-agentní agregace preferencí
Příklad probabilistického modelování preferencí:
<p>class ProbabilisticDPOTrainer(DPOTrainer): def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob): # Vypočítejte logaritmové poměry 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># Použití trainer = ProbabilisticDPOTrainer(model, ref_model) loss = trainer.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob=0.8) # 80% jistota preference
d) Kombinace DPO s dalšími technikami sladění:
Integrace DPO s dalšími přístupy ke sladění by mohla vést k více robustním a schopným systémům:
- Ústavní principy AI pro explicitní uspokojování omezení
- Debata a rekurzivní modelování odměn pro složitou elicaci preferencí
- Inverzní učení s posilováním pro odhadování základních funkcí odměn
Příklad kombinace DPO s ústavními principy 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># Použití def safety_constraint(model, pi_logps, ref_logps, yw_idxs, yl_idxs): # Implementujte logiku kontroly bezpečnosti unsafe_score = compute_unsafe_score(model, pi_logps, ref_logps) return torch.relu(unsafe_score - 0.5) # Penalizujte, pokud je skóre bezpečnosti > 0.5</p> <p>constraints = [safety_constraint] trainer = ConstitutionalDPOTrainer(model, ref_model, constraints=constraints)</p>
Praktické úvahy a nejlepší postupy
Při implementaci DPO pro reálné aplikace vezměte v úvahu následující tipy:
a) Kvalita dat: Kvalita vašich preferenčních dat je zásadní. Ujistěte se, že váš dataset:
- Pokrývá širokou škálu vstupů a požadovaných chování
- Má konzistentní a spolehlivé anotace preferencí
- Vyvažuje různé typy preferencí (například faktičnost, bezpečnost, styl)
b) Ladění hyperparametrů: Přestože DPO má méně hyperparametrů než RLHF, ladění je stále důležité:
- β (beta): Kontroluje kompromis mezi uspokojením preferencí a odchylkou od referenčního modelu. Začněte s hodnotami kolem 0,1-0,5.
- Learning rate: Použijte nižší learning rate než standardní jemné ladění, obvykle v rozmezí 1e-6 až 1e-5.
- Velikost batche: Larger batche (32-128) často fungují dobře pro učení preferencí.
c) Iterativní rafinování: DPO lze aplikovat iterativně:
- Školejte počáteční model pomocí DPO
- Generujte nové odpovědi pomocí vyškoleného modelu
- Shromážděte nová preferenční data na těchto odpovědích
- Opětovně školejte pomocí rozšířeného datasetu
Přímá optimalizace preferencí
Tento obrázek ukazuje výkon LLM, jako je GPT-4, ve srovnání s lidskými soudy napříč různými trénovacími technikami, včetně Přímé optimalizace preferencí (DPO), Dozorovaného jemného ladění (SFT) a Proximálního policy optimization (PPO). Tabulka odhaluje, že výstupy GPT-4 jsou stále více sladěny s lidskými preferencemi, zejména v úkolech souhrnu. Úroveň shody mezi GPT-4 a lidskými recenzenty demonstruje schopnost modelu generovat obsah, který rezonuje s lidskými hodnotiteli, téměř stejně jako lidsky generovaný obsah.
Případy a aplikace
Abyste ilustrovali účinnost DPO, podívejme se na některé reálné aplikace a některé z jeho variant:
- Iterativní DPO: Vyvinutý Snorkel (2023), tato varianta kombinuje rejection sampling s DPO, umožňující jemnější výběr procesu pro trénovací data. Iterací přes více kol preferenčního vzorkování je model lépe schopen generalizovat a vyhnout se přeučení se na šum nebo zkreslená preference.
- IPO (Iterativní preference optimalizace): Představený Azar et al. (2023), IPO přidává regularizační termín, aby se zabránilo přeučení, což je běžný problém v optimalizaci založené na preferencích. Tato rozšíření umožňuje modelům udržet rovnováhu mezi dodržováním preferencí a zachováním generalizačních schopností.
- KTO (Optimalizace přenositelnosti znalostí): Novější varianta od Ethayarajh et al. (2023), KTO se zbavuje binárních preferencí úplně. Místo toho se zaměřuje na přenos znalostí z referenčního modelu na model politiky, optimalizaci pro hladší a konzistentnější sladění s lidskými hodnotami.
- Multi-modální DPO pro cross-doménové učení od Xu et al. (2024): Přístup, kde se DPO aplikuje napříč různými modality – text, obraz, audio – demonstruje jeho všestrannost při sladění modelů s lidskými preferencemi napříč různými typy dat. Tento výzkum zdůrazňuje potenciál DPO při vytváření komplexnějších AI systémů schopných zpracovávat složitá, multi-modální úkoly.
Závěr
Přímá optimalizace preferencí představuje významný pokrok ve sladění jazykových modelů s lidskými preferencemi. Její jednoduchost, efektivita a účinnost ji činí mocným nástrojem pro výzkumníky i praktiky.
Používáním síly Přímé optimalizace preferencí a dodržováním těchto zásad můžete vytvořit jazykové modely, které nejen vykazují působivé schopnosti, ale také se těsně shodují s lidskými hodnotami a záměry.
