Doğrudan Tercih Optimizasyonu: Eksiksiz Bir Kılavuz

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

Zorluklar ve Gelecekteki Yönler

DPO, geleneksel RLHF yaklaşımlarına göre önemli avantajlar sunarken, hâlâ zorluklar ve daha fazla araştırma yapılması gereken alanlar bulunmaktadır:

a) Daha Büyük Modellere Ölçeklenebilirlik:

Dil modellerinin boyutu büyümeye devam ettikçe, DPO'yu yüz milyarlarca parametreye sahip modellere verimli bir şekilde uygulamak açık bir zorluk olmaya devam ediyor. Araştırmacılar aşağıdaki gibi teknikleri araştırıyorlar:

• Verimli ince ayar yöntemleri (örneğin, LoRA, önek ayarı)
• Dağıtılmış eğitim optimizasyonları
• Gradyan kontrol noktası belirleme ve karma hassasiyetli eğitim

LoRA'yı DPO ile kullanma örneği:

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) Çoklu Görev ve Az Çekim Uyarlaması:

Sınırlı tercih verileriyle yeni görevlere veya alanlara verimli bir şekilde uyum sağlayabilecek DPO tekniklerinin geliştirilmesi aktif bir araştırma alanıdır. Araştırılan yaklaşımlar şunları içerir:

• Hızlı adaptasyon için meta-öğrenme çerçeveleri
• DPO için istem tabanlı ince ayar
• Öğrenimi genel tercih modellerinden belirli alanlara aktarın

c) Belirsiz veya Çatışan Tercihlerin Ele Alınması:

Gerçek dünyadaki tercih verileri genellikle belirsizlikler veya çelişkiler içerir. Veri Koruma Görevlisi'nin bu tür verilere karşı dayanıklılığını artırmak hayati önem taşır. Potansiyel çözümler şunlardır:

• Olasılıksal tercih modellemesi
• Belirsizlikleri çözmek için aktif öğrenme
• Çoklu aracı tercihi toplama

Olasılıksal tercih modelleme örneği:

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'yu Diğer Hizalama Teknikleriyle Birleştirmek:

DPO'yu diğer hizalama yaklaşımlarıyla entegre etmek daha sağlam ve yetenekli sistemlere yol açabilir:

• Açık kısıtlamaların karşılanması için anayasal yapay zeka ilkeleri
• Karmaşık tercihlerin ortaya çıkarılması için tartışma ve yinelemeli ödül modellemesi
• Temel ödül işlevlerinin çıkarımını yapmak için ters takviyeli öğrenme

DPO'yu anayasal yapay zeka ile birleştirme örneği:

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)

Pratik Hususlar ve En İyi Uygulamalar

Gerçek dünya uygulamaları için DPO'yu uygularken aşağıdaki ipuçlarını göz önünde bulundurun:

a) Veri kalitesi: Tercih verilerinizin kalitesi çok önemlidir. Veri kümenizin:

• Çok çeşitli girdileri ve istenen davranışları kapsar
• Tutarlı ve güvenilir tercih açıklamalarına sahiptir
• Farklı tercih türlerini dengeler (örneğin, gerçekçilik, güvenlik, stil)

b) Hiperparametre Ayarı: DPO'nun RLHF'den daha az hiper parametresi olsa da ayarlama hala önemlidir:

• β (beta): Tercih memnuniyeti ile referans modelden sapma arasındaki dengeyi kontrol eder. Etrafındaki değerlerle başlayın 0.1-0.5.
• Öğrenme oranı: Standart ince ayardan daha düşük bir öğrenme oranı kullanın; genellikle 1e-6'dan 1e-5'e.
• Parti büyüklüğü: Daha büyük parti boyutları (32-128) genellikle tercih öğrenimi için iyi çalışır.

c) Yinelemeli İyileştirme: DPO yinelemeli olarak uygulanabilir:

1. DPO kullanarak başlangıç ​​modelini eğitme
2. Eğitilen modeli kullanarak yeni yanıtlar oluşturun
3. Bu yanıtlara ilişkin yeni tercih verileri toplayın
4. Genişletilmiş veri kümesini kullanarak yeniden eğitin

 

Doğrudan Tercih Optimizasyonu Performansı

Bu görsel, GPT-4 gibi LLM programlarının performansını, Doğrudan Tercih Optimizasyonu (DPO), Denetimli İnce Ayar (SFT) ve Yakınsal Politika Optimizasyonu (PPO) dahil olmak üzere çeşitli eğitim tekniklerinde insan yargılarıyla karşılaştırmalı olarak göstermektedir. Tablo, GPT-4 çıktılarının, özellikle özetleme görevlerinde, insan tercihleriyle giderek daha uyumlu hale geldiğini ortaya koymaktadır. GPT-4 ve insan değerlendiriciler arasındaki uyum düzeyi, modelin insan değerlendiricilerle neredeyse insan tarafından oluşturulan içerik kadar uyumlu içerik üretme becerisini göstermektedir.

Vaka Çalışmaları ve Uygulamalar

DPO'nun etkinliğini göstermek için gerçek dünyadaki bazı uygulamalara ve bazı varyantlarına bakalım:

• Yinelemeli DPO: Snorkel (2023) tarafından geliştirilen bu değişken, ret örneklemesini DPO ile birleştirerek eğitim verileri için daha hassas bir seçim süreci sağlar. Tercih örneklemesinin birden fazla turu tekrarlanarak model daha iyi genelleştirilebilir ve gürültülü veya önyargılı tercihlere aşırı uyumdan kaçınılabilir.
• halka arz (Yinelemeli Tercih Optimizasyonu): Azar ve ark. tarafından tanıtıldı. (2023), IPO, tercihe dayalı optimizasyonda yaygın bir sorun olan aşırı uyumu önlemek için bir düzenleme terimi ekler. Bu uzantı, modellerin tercihlere bağlı kalma ve genelleme yeteneklerini koruma arasında bir denge kurmasına olanak tanır.
• KTO (Bilgi Aktarımı Optimizasyonu): Ethayarajh ve ark.'nın daha yeni bir çeşidi. (2023), KTO ikili tercihleri ​​tamamen ortadan kaldırır. Bunun yerine, bilgiyi bir referans modelinden politika modeline aktarmaya, insani değerlerle daha sorunsuz ve daha tutarlı bir uyum için optimizasyona odaklanıyor.
• Etki Alanları Arası Öğrenim için Çok Modlu DPO Xu ve diğerleri tarafından. (2024): DPO'nun farklı yöntemler (metin, görüntü ve ses) genelinde uygulandığı ve modelleri farklı veri türleri genelinde insan tercihleriyle hizalamadaki çok yönlülüğünü gösteren bir yaklaşım. Bu araştırma, karmaşık, çok modlu görevleri yerine getirebilecek daha kapsamlı yapay zeka sistemleri oluşturmada DPO'nun potansiyelini vurguluyor.

Sonuç

Doğrudan Tercih Optimizasyonu, dil modellerinin insan tercihleriyle uyumlu hale getirilmesinde önemli bir ilerlemeyi temsil eder. Basitliği, verimliliği ve etkililiği onu hem araştırmacılar hem de uygulayıcılar için güçlü bir araç haline getiriyor.

Doğrudan Tercih Optimizasyonunun gücünden yararlanarak ve bu ilkeleri akılda tutarak, yalnızca etkileyici yetenekler sergilemekle kalmayıp aynı zamanda insani değerler ve niyetlerle de yakından uyumlu olan dil modelleri oluşturabilirsiniz.