Optimasi Preferensi Langsung: Panduan Lengkap

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

Tantangan dan Arah Masa Depan

Meskipun DPO menawarkan keuntungan yang signifikan dibandingkan pendekatan RLHF tradisional, masih terdapat tantangan dan area yang perlu dilakukan penelitian lebih lanjut:

a) Skalabilitas ke Model yang Lebih Besar:

Seiring dengan bertambahnya ukuran model bahasa, penerapan DPO secara efisien pada model dengan ratusan miliar parameter tetap menjadi tantangan terbuka. Para peneliti sedang mengeksplorasi teknik seperti:

• Metode penyesuaian yang efisien (misalnya, LoRA, penyetelan awalan)
• Optimalisasi pelatihan terdistribusi
• Pos pemeriksaan gradien dan pelatihan presisi campuran

Contoh penggunaan LoRA dengan 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) Adaptasi Multi-Tugas dan Sedikit Pemotretan:

Mengembangkan teknik DPO yang dapat beradaptasi secara efisien terhadap tugas atau domain baru dengan data preferensi terbatas merupakan bidang penelitian yang aktif. Pendekatan yang sedang dieksplorasi meliputi:

• Kerangka kerja meta-learning untuk adaptasi cepat
• Penyempurnaan berbasis cepat untuk DPO
• Transfer pembelajaran dari model preferensi umum ke domain tertentu

c) Menangani Preferensi yang Ambigu atau Bertentangan:

Data preferensi dunia nyata sering kali mengandung ambiguitas atau konflik. Meningkatkan ketahanan DPO terhadap data tersebut sangatlah penting. Solusi potensial meliputi:

• Pemodelan preferensi probabilistik
• Pembelajaran aktif untuk menyelesaikan ambiguitas
• Agregasi preferensi multi-agen

Contoh pemodelan preferensi probabilistik:

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) Menggabungkan DPO dengan Teknik Alignment Lainnya:

Mengintegrasikan DPO dengan pendekatan penyelarasan lainnya dapat menghasilkan sistem yang lebih kuat dan mampu:

• Prinsip AI konstitusional untuk kepuasan batasan eksplisit
• Perdebatan dan pemodelan penghargaan rekursif untuk perolehan preferensi yang kompleks
• Pembelajaran penguatan terbalik untuk menyimpulkan fungsi penghargaan yang mendasarinya

Contoh penggabungan DPO dengan AI konstitusional:

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)

Pertimbangan Praktis dan Praktik Terbaik

Saat menerapkan DPO untuk aplikasi dunia nyata, pertimbangkan tips berikut:

a) Kualitas Data: Kualitas data preferensi Anda sangat penting. Pastikan kumpulan data Anda:

• Mencakup beragam masukan dan perilaku yang diinginkan
• Memiliki anotasi preferensi yang konsisten dan andal
• Menyeimbangkan berbagai jenis preferensi (misalnya, faktualitas, keamanan, gaya)

b) Penyesuaian Hyperparameter: Meskipun DPO memiliki hyperparameter lebih sedikit dibandingkan RLHF, penyetelan tetap penting:

• β (beta): Mengontrol trade-off antara kepuasan preferensi dan perbedaan dari model referensi. Mulailah dengan nilai-nilai di sekitar 0.1-0.5.
• Kecepatan pembelajaran: Gunakan kecepatan pembelajaran yang lebih rendah daripada penyesuaian standar, biasanya dalam kisaran 1e-6 hingga 1e-5.
• Ukuran batch: Ukuran batch lebih besar (32-128) sering kali berfungsi dengan baik untuk pembelajaran preferensi.

c) Penyempurnaan Iteratif: DPO dapat diterapkan secara iteratif:

1. Latih model awal menggunakan DPO
2. Hasilkan respons baru menggunakan model terlatih
3. Kumpulkan data preferensi baru mengenai tanggapan ini
4. Latih kembali menggunakan kumpulan data yang diperluas

 

Kinerja Optimasi Preferensi Langsung

Gambar ini menunjukkan kinerja LLM seperti GPT-4 dibandingkan dengan penilaian manusia di berbagai teknik pelatihan, termasuk Direct Preference Optimization (DPO), Supervised Fine-Tuning (SFT), dan Proximal Policy Optimization (PPO). Tabel tersebut mengungkapkan bahwa keluaran GPT-4 semakin selaras dengan preferensi manusia, terutama dalam tugas-tugas ringkasan. Tingkat kesesuaian antara GPT-4 dan pengulas manusia menunjukkan kemampuan model untuk menghasilkan konten yang sesuai dengan evaluator manusia, hampir sedekat konten yang dihasilkan manusia.

Studi Kasus dan Aplikasi

Untuk mengilustrasikan efektivitas DPO, mari kita lihat beberapa aplikasi dunia nyata dan beberapa variannya:

• DPO berulang: Dikembangkan oleh Snorkel (2023), varian ini menggabungkan pengambilan sampel penolakan dengan DPO, memungkinkan proses seleksi yang lebih baik untuk data pelatihan. Dengan melakukan iterasi pada beberapa putaran pengambilan sampel preferensi, model akan lebih mampu menggeneralisasi dan menghindari penyesuaian yang berlebihan terhadap preferensi yang berisik atau bias.
• penawaran umum perdana (Optimasi Preferensi Iteratif): Diperkenalkan oleh Azar dkk. (2023), IPO menambahkan istilah regularisasi untuk mencegah overfitting, yang merupakan masalah umum dalam optimasi berbasis preferensi. Ekstensi ini memungkinkan model menjaga keseimbangan antara mengikuti preferensi dan mempertahankan kemampuan generalisasi.
• KTO (Optimasi Transfer Pengetahuan): Varian yang lebih baru dari Ethayarajh dkk. (2023), KTO meniadakan preferensi biner sama sekali. Sebaliknya, pendekatan ini berfokus pada transfer pengetahuan dari model referensi ke model kebijakan, mengoptimalkan keselarasan dengan nilai-nilai kemanusiaan yang lebih lancar dan konsisten.
• DPO Multi-Modal untuk Pembelajaran Lintas Domain oleh Xu dkk. (2024): Suatu pendekatan yang menerapkan DPO di berbagai modalitas—teks, gambar, dan audio—yang menunjukkan keserbagunaannya dalam menyelaraskan model dengan preferensi manusia di berbagai jenis data. Penelitian ini menyoroti potensi DPO dalam menciptakan sistem AI yang lebih komprehensif yang mampu menangani tugas-tugas multimodal yang kompleks.

Kesimpulan

Pengoptimalan Preferensi Langsung mewakili kemajuan signifikan dalam menyelaraskan model bahasa dengan preferensi manusia. Kesederhanaan, efisiensi, dan efektivitasnya menjadikannya alat yang ampuh bagi para peneliti dan praktisi.

Dengan memanfaatkan kekuatan Pengoptimalan Preferensi Langsung dan mengingat prinsip-prinsip ini, Anda dapat membuat model bahasa yang tidak hanya menunjukkan kemampuan yang mengesankan tetapi juga selaras dengan nilai-nilai dan niat kemanusiaan.