Suora asetusten optimointi: täydellinen opas

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}")

Haasteet ja tulevaisuuden suunnat

Vaikka DPO tarjoaa merkittäviä etuja perinteisiin RLHF-lähestymistapoihin verrattuna, haasteita ja lisätutkimuksia on edelleen:

a) Skaalautuvuus suurempiin malleihin:

Kielimallien koon kasvaessa edelleen DPO:n tehokas soveltaminen malleihin, joissa on satoja miljardeja parametreja, on edelleen avoin haaste. Tutkijat tutkivat tekniikoita, kuten:

• Tehokkaat hienosäätömenetelmät (esim. LoRA, etuliitteen viritys)
• Jaettu koulutusoptimointi
• Gradienttitarkistus- ja sekatarkkuusharjoittelu

Esimerkki LoRA:n käytöstä DPO:n kanssa:

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) Multi-Task ja Few-Shot -sovitus:

Aktiivinen tutkimusalue on sellaisten DPO-tekniikoiden kehittäminen, jotka voivat mukautua tehokkaasti uusiin tehtäviin tai alueisiin rajoitetuilla preferenssitiedoilla. Tutkittavia lähestymistapoja ovat mm.

• Meta-oppimiskehykset nopeaan sopeutumiseen
• Tietosuojavastaavan pikasäätöinen hienosäätö
• Siirrä oppimista yleisistä mieltymysmalleista tietyille aloille

c) Epäselvien tai ristiriitaisten asetusten käsitteleminen:

Reaalimaailman asetustiedot sisältävät usein epäselvyyksiä tai ristiriitoja. Tietosuojavastaavan tällaisten tietojen luotettavuuden parantaminen on ratkaisevan tärkeää. Mahdollisia ratkaisuja ovat mm.

• Todennäköisyyspohjainen mieltymysmallinnus
• Aktiivinen oppiminen ratkaisemaan epäselvyyksiä
• Usean agentin mieltymysten yhdistäminen

Esimerkki todennäköisyyspohjaisesta mieltymysmallintamisesta:

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) DPO:n yhdistäminen muihin kohdistustekniikoihin:

Tietosuojavastaavan integroiminen muihin linjausmenetelmiin voi johtaa vankempiin ja tehokkaampiin järjestelmiin:

• Perustuslailliset tekoälyperiaatteet nimenomaiseen rajoitteiden tyydyttämiseen
• Keskustelu ja rekursiivinen palkkiomallinnus monimutkaiseen mieltymysten saamiseen
• Käänteinen vahvistusoppiminen taustalla olevien palkitsemistoimintojen päättelemiseksi

Esimerkki DPO:n yhdistämisestä perustuslailliseen tekoälyyn:

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)

Käytännön huomioita ja parhaita käytäntöjä

Kun otat DPO:n käyttöön todellisissa sovelluksissa, ota huomioon seuraavat vinkit:

a) Tietojen laatu: Asetustietojesi laatu on ratkaisevan tärkeää. Varmista, että tietojoukkosi:

• Kattaa laajan valikoiman syötteitä ja haluttuja käyttäytymismalleja
• Siinä on johdonmukaiset ja luotettavat mieltymysmerkinnät
• Tasapainottaa erityyppisiä mieltymyksiä (esim. tosiasiallisuus, turvallisuus, tyyli)

b) Hyperparametrien viritys: Vaikka DPO:lla on vähemmän hyperparametreja kuin RLHF:llä, viritys on silti tärkeää:

• β (beta): Hallitsee tyytyväisyyden ja vertailumallista poikkeamisen välistä kompromissia. Aloita arvoista ympärilläsi 0.1-0.5.
• Oppimisnopeus: Käytä tavallista hienosäätöä alhaisempaa oppimisnopeutta, tyypillisesti alueella 1e-6 - 1e-5.
• Eräkoko: Suuremmat eräkoot (32-128) toimivat usein hyvin mieltymysten oppimisessa.

c) Iteratiivinen tarkennus: DPO:ta voidaan soveltaa iteratiivisesti:

1. Kouluta alkuperäinen malli DPO:n avulla
2. Luo uusia vastauksia koulutetun mallin avulla
3. Kerää uusia mieltymystietoja näistä vastauksista
4. Opettele uudelleen käyttämällä laajennettua tietojoukkoa

 

Suoran asetusten optimoinnin suorituskyky

Tämä kuva näyttää GPT-4:n kaltaisten LLM:ien suorituskyvyn verrattuna ihmisten arvioihin eri koulutustekniikoissa, mukaan lukien suora asetusten optimointi (DPO), valvottu hienosäätö (SFT) ja proksimaalisen politiikan optimointi (PPO). Taulukko paljastaa, että GPT-4:n lähdöt ovat yhä enemmän linjassa ihmisten mieltymysten kanssa, erityisesti yhteenvetotehtävissä. GPT-4:n ja ihmisten arvioijien välinen yhteisymmärrys osoittaa mallin kyvyn luoda sisältöä, joka resonoi ihmisten arvioijien kanssa, melkein yhtä tarkasti kuin ihmisten luoma sisältö.

Tapaustutkimukset ja sovellukset

Havainnollistaaksemme DPO:n tehokkuutta, katsotaanpa joitain tosielämän sovelluksia ja joitain sen muunnelmia:

• Iteratiivinen DPO: Snorkelin (2023) kehittämä versio yhdistää hylkäysnäytteenoton DPO:n kanssa, mikä mahdollistaa tarkemman valintaprosessin harjoitusdatalle. Iteroimalla useita mieltymysten näytteenottokierroksia, malli pystyy paremmin yleistämään ja välttämään ylisovittamisen meluisiin tai puolueellisiin mieltymyksiin.
• IPO (Iteratiivinen asetusten optimointi): Esitteli Azar et ai. (2023), IPO lisää regularisointitermin estääkseen ylisovituksen, joka on yleinen ongelma preferenssipohjaisessa optimoinnissa. Tämän laajennuksen avulla mallit voivat säilyttää tasapainon asetuksien noudattamisen ja yleistyskyvyn säilyttämisen välillä.
• KTO (Tietämyksen siirron optimointi): Uudempi muunnos julkaisusta Ethayarajh et al. (2023), KTO luopuu binääriasetuksista kokonaan. Sen sijaan se keskittyy tiedon siirtämiseen vertailumallista politiikkamalliin, optimoiden tasaisemman ja johdonmukaisemman linjauksen inhimillisten arvojen kanssa.
• Monimuotoinen DPO verkkotunnusten väliseen oppimiseen Xu et ai. (2024): Lähestymistapa, jossa DPO:ta sovelletaan eri modaliteeteissa – tekstissä, kuvassa ja äänessä – ja se osoittaa monipuolisuutensa mallien mukauttamisessa ihmisten mieltymyksiin erilaisissa tietotyypeissä. Tämä tutkimus korostaa DPO:n mahdollisuuksia luoda kattavampia tekoälyjärjestelmiä, jotka pystyvät käsittelemään monimutkaisia, multimodaalisia tehtäviä.

Yhteenveto

Suora asetusten optimointi edustaa merkittävää edistystä kielimallien mukauttamisessa ihmisten mieltymyksiin. Sen yksinkertaisuus, tehokkuus ja vaikuttavuus tekevät siitä tehokkaan työkalun tutkijoille ja alan ammattilaisille.

Hyödyntämällä suoran asetusten optimoinnin tehoa ja pitämällä nämä periaatteet mielessä voit luoda kielimalleja, jotka eivät ainoastaan ​​esitä vaikuttavia ominaisuuksia, vaan ovat myös tiiviisti linjassa ihmisten arvojen ja aikomusten kanssa.