İçeriğe geç

PPO Algoritması Satır Satır: Schulman 2017'den InstructGPT'ye — RL'in LLM'e Uyarlanması

Proximal Policy Optimization (Schulman 2017) algoritmasının LLM RLHF'e uyarlanması: policy gradient temeli, advantage estimation (GAE), clipped surrogate loss'un türevi ve neden 'clip', KL penalty matematiği, value function loss, entropi bonusu. InstructGPT'nin tam PPO setup'ı, hyperparametre seçimleri, eğitim stabilitesi, debug stratejileri.

Şükrü Yusuf KAYA
90 dakikalık okuma
İleri
PPO Algoritması Satır Satır: Schulman 2017'den InstructGPT'ye — RL'in LLM'e Uyarlanması
🎮 PPO — RL'in 'Yıkılmayan Tank'ı
Reinforcement Learning'in tarihinde bir paradoks var. Algoritmaların çoğu muhteşem ama kırılgan: yanlış hyperparametre, kötü seed, gradient patlaması — eğitim çökerse çöker. Schulman 2017'de OpenAI'da yayınlanan Proximal Policy Optimization (PPO) bu paradoksu kırdı. 'Bozuk olmayan' RL algoritması. Atari'de, Mujoco simülasyonlarında, gerçek robotlarda — ve sonunda LLM'de. ChatGPT'nin altında PPO var. Llama-3-Instruct'ın altında PPO var (artık DPO yedek seçenek). Bu ders PPO'yu LLM bağlamında satır satır türetiyor. 90 dakika sonra: PPO'yu sadece anlayan değil, debug edebilen mühendise dönüşeceksin. RLHF mühendisliğinin matematiksel zirvesi.

Bu Derste Neler Var? (13 Bölüm)#

  1. Klasik RL'den LLM RL'e — kavramsal köprü
  2. Policy gradient — REINFORCE'un sınırı
  3. Trust Region Policy Optimization — Schulman 2015 öncüsü
  4. PPO Schulman 2017 — clipped surrogate'in fikri
  5. Clipped surrogate türevi — matematik kalem ile
  6. Advantage estimation — GAE (Generalized Advantage Estimation)
  7. KL penalty — SFT'den uzaklaşma cezası
  8. Value function loss — kritik (critic) eğitimi
  9. Entropy bonus — keşfi koruma
  10. InstructGPT PPO setup — tam yapılandırma
  11. PyTorch implementation — TRL ile
  12. Eğitim stabilitesi — divergence sinyalleri
  13. Türkçe PPO: pratisyenin notları

1-3. Klasik RL'den LLM RL'e#

1.1 Klasik RL şekilsi#

RL bir ajan + çevre + ödül üçgeni:
  • Ajan: durumu görür, eylem seçer
  • Çevre: eylemi alır, yeni durum + ödül döner
  • Hedef: kümülatif ödülü maksimize et
Atari örneği:
  • Durum: oyun ekranı (piksel matrisi)
  • Eylem: joystick hareketi (up, down, fire)
  • Ödül: skor değişimi

1.2 LLM'i RL'e oturtmak#

LLM RLHF'te:
  • Ajan: LLM (mevcut token'lara bakar, sonraki token'ı seçer)
  • Durum: o ana kadar üretilmiş cümle (prompt + üretilen token'lar)
  • Eylem: sonraki token'ı seçmek (vocab üzerinden)
  • Ödül: RM'in tüm cümleye verdiği skor — ama sadece son token'da
Önemli: ödül sparse — cümlenin sonunda bir kez geliyor. Atari'de her frame ödül verilir, LLM'de sadece sonda.
Bu, klasik RL'in adaptasyonunu zorlaştırıyor.

2.1 Policy gradient — REINFORCE#

Klasik formül (Williams 1992):
∇θ J(θ) = E_τ [ Σ_t ∇θ log π_θ(a_t | s_t) · R_t ]
  • π_θ: policy (model, parametreleri θ)
  • a_t: t anındaki eylem (token)
  • s_t: t anındaki durum (önceki token'lar)
  • R_t: t'den itibaren kümülatif ödül
Bu formül 'iyi token'ları daha olası, kötü token'ları daha olasısız yap' demek.
Sorun: gradient varyansı yüksek. Tek bir cümlede 100 token, her token kendi log-prob × ödül. Çoğu token alakasız ödülle çarpılıyor. Eğitim çok yavaş ve gürültülü.

2.2 Baseline trick#

Çözüm: her token'da bir 'tahmin' (baseline) çıkar:
∇θ J = E_τ [ Σ_t ∇θ log π_θ(a_t | s_t) · (R_t - b(s_t)) ]
b(s_t) = value function (sonraki ödülün tahmini). R_t - b(s_t) = advantage (gerçek vs tahmin).
Bu varyansı dramatik düşürür. Modern RL'in temel taşı.

3.1 TRPO (Schulman 2015)#

Policy gradient'in bir kısıtı var: çok büyük adım atılırsa model çöker. 'Bu eylem iyi' diye %100 olası yapılırsa, model alternatifleri kaybeder.
Schulman 2015 TRPO: 'her adımda eski policy'den çok uzaklaşma' kısıtı koy:
maximize: surrogate objective
subject to: KL(π_old || π_new) ≤ δ
Matematiksel olarak sağlam, ama hesaplaması karmaşık. Saklı Hessian çözmek gerekir.

3.2 PPO 2017 — sadeleştirme#

Schulman 2017 PPO: TRPO'nun fikrini al, clip ile basitleştir. KL constraint yerine, ratio'yu doğrudan kısıtla. Aynı kalite, %10 kod.

4-6. PPO Matematiği#

4.1 Clipped surrogate loss#

PPO'nun kalbi:
L^CLIP(θ) = E_t [ min(r_t(θ) · A_t, clip(r_t(θ), 1-ε, 1+ε) · A_t) ]
Neresinden başlayalım?
r_t(θ): importance ratio:
r_t(θ) = π_θ(a_t | s_t) / π_θ_old(a_t | s_t)
Mevcut policy'in eski policy'ye göre olasılık oranı.
A_t: advantage (sonraki bölümde detay).
ε: clip parametresi (genelde 0.2 — yani r 0.8 ile 1.2 arasında).

4.2 Niye min ve clip?#

Sezgisel: 'fazla heyecanlanma' fonksiyonu.
  • A_t > 0 ise (iyi eylem): r_t artmalı (model bu eylemi daha çok yapsın). Ama r_t > 1+ε ise clip uygulanır → gradient kayar.
  • A_t < 0 ise (kötü eylem): r_t azalmalı. Ama r_t < 1-ε ise clip uygulanır.
Net etki: model her adımda küçük güncelleme yapar. TRPO'nun KL constraint'inin clipped versiyonu.

4.3 Loss matematiği — pürüz pürüz#

Advantage A_t > 0 senaryosu:
  • Loss = min(r_t · A_t, clip(r_t, 1-ε, 1+ε) · A_t)
  • r_t = 1.5, ε = 0.2 → clip(1.5, 0.8, 1.2) = 1.2
  • min(1.5 · A_t, 1.2 · A_t) = 1.2 · A_t (A_t > 0 olduğu için)
  • Loss = 1.2 · A_t. r_t değil 1.2 kullanıldı → r_t üzerine gradient kaymıyor.
A_t < 0 senaryosu:
  • r_t = 0.5, ε = 0.2 → clip(0.5, 0.8, 1.2) = 0.8
  • min(0.5 · A_t, 0.8 · A_t) — A_t negatif olduğu için, daha küçük olan: 0.5 · A_t (negatif sayılar)
  • Loss = 0.5 · A_t. clip uygulanmamış (model daha küçük r_t için izin var).
Karmaşık ama önemli: clip sadece bir yönde uygulanır. Bu hata düzeltme alanı bırakır.

4.4 Total PPO loss#

PPO eğitimi 3 loss bileşenini kombine eder:
L^PPO = L^CLIP - c1 · L^VF + c2 · L^Entropy
  • L^CLIP: yukarıdaki (policy loss)
  • L^VF: value function loss (kritik eğitimi)
  • L^Entropy: entropi bonusu (keşfi koru)
  • c1, c2: katsayılar (genelde 0.5, 0.01)
Eksi işareti: bu loss minimize edilmiyor, maximize ediliyor (gradient ascent). Pratikte PyTorch'ta
-L^PPO
minimize edilir.

5.1 Advantage Estimation — GAE#

A_t nedir? Gerçek dünyada R_t bilmiyoruz (gelecek ödüller). GAE yaklaşımı:
A_t^GAE = Σ_{k=0}^∞ (γλ)^k · δ_{t+k}
  • δ_t = r_t + γV(s_{t+1}) - V(s_t): TD error (temporal difference)
  • γ: discount factor (0.99 tipik)
  • λ: GAE parametresi (0.95 tipik) — bias-variance trade-off
LLM RLHF'te ödül sparse: sadece sonda r_T var, ortada hep 0. O zaman:
A_t^GAE ≈ γ^(T-t) · r_T - V(s_t)
Yani: cümle sonu ödülünden, her token'ın value tahminini çıkar. Bu advantage.

5.2 Token-level vs sequence-level reward#

LLM PPO'da iki yaklaşım var:
  • Sequence-level: tüm cümleye tek reward, her token'a eşit dağıt.
  • Token-level: her token'a ayrı reward (KL penalty + value fonksiyonu). Modern InstructGPT bunu kullanır.
Token-level daha hassas, daha karmaşık.

6.1 Value function nasıl eğitilir?#

L^VF = MSE(V(s_t), R_t)
  • V(s_t): value function tahmini (RM gibi shared trunk + value head'den)
  • R_t: gerçek (discounted) reward
MSE loss ile V güncellenir. Bu kritik (critic), advantage hesabında kullanılır.

7-9. KL Penalty + Entropy + Detail#

7.1 KL Penalty — sürüklenme cezası#

PPO'nun clipped surrogate KL'i kontrol eder ama tam değil. Modern RLHF setup'larda ek KL penalty kullanılır:
L^KL = β · KL(π_θ || π_ref)
  • π_ref: referans model (SFT model, dondurulmuş)
  • β: KL katsayısı (0.01-0.1 tipik)
Reward'a doğrudan ekleniyor:
R_total(s_t, a_t) = R(s_T) - β · log(π_θ(a_t) / π_ref(a_t))
Her token'da SFT'den uzaklaşma kadar küçük ceza. Bu sürüklenmeyi önler.

7.2 KL adaptif veya sabit#

İki yaklaşım:
  • Sabit KL: β = 0.05 (tüm eğitim boyunca aynı)
  • Adaptif KL: hedef KL belirle (mesela 6 nat), gerçek KL bunu aşarsa β'yı artır, düşürse azalt.
InstructGPT adaptif kullandı, Llama-2 RLHF sabit. Pratik fark az.

7.3 KL niye nat birimi?#

KL bilgi-teorik birimi: nat (doğal logaritma) veya bit (log2). RLHF'te nat standart. 1 nat ≈ 1.44 bit.

8.1 Entropy bonus#

L^Entropy = entropy(π_θ(· | s_t))
Entropi yüksek = model belirsiz, çoklu seçenek. Entropi düşük = model kesin, tek seçenek.
PPO'da + entropi bonusu: model entropisini yüksek tutmaya teşvik. Niye? Keşfi korumak. Model bir token'da tamamen kesinleşirse, alternatifleri keşfetmez.
Katsayı c2 ~ 0.01. Pratikte LLM RLHF'te entropy bonus küçük etki — KL penalty zaten benzer iş yapıyor.

9.1 Tüm parça'lar bir araya#

Production PPO loss (LLM için):
L = -E_t [ L^CLIP_t ] + c1 · MSE(V_t, R_t) - c2 · H(π_t)
ve reward'a KL eklendi:
R_t = R_RM(s_T) - β · log(π_θ / π_ref) · (token t)
Bu InstructGPT loss fonksiyonudur. Karmaşık ama her parça bir derdi çözüyor.
python
# Türkçe Llama-3 PPO RLHF — HuggingFace TRL ile production setup
# Önkoşul: SFT model (Modül 14.3) + Reward Model (Modül 15.2 eğitilmiş)
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from datasets import load_dataset
 
MODEL_SFT = 'sukruyusufkaya/llama-3-8b-tr-instruct-sft'
MODEL_RM = 'sukruyusufkaya/llama-3-8b-tr-rm'
OUTPUT_DIR = './llama-3-tr-ppo'
 
# 1. Tokenizer
tokenizer = AutoTokenizer.from_pretrained(MODEL_SFT)
tokenizer.pad_token = tokenizer.eos_token
 
# 2. Policy model (SFT base, + value head)
policy = AutoModelForCausalLMWithValueHead.from_pretrained(
    MODEL_SFT,
    torch_dtype=torch.bfloat16,
)
 
# 3. Reference model (frozen SFT, KL penalty için)
ref = AutoModelForCausalLMWithValueHead.from_pretrained(
    MODEL_SFT,
    torch_dtype=torch.bfloat16,
)
 
# 4. Reward model
rm = AutoModelForCausalLM.from_pretrained(
    MODEL_RM,
    torch_dtype=torch.bfloat16,
)
rm.eval()
 
# 5. PPO config (InstructGPT'den ilham)
config = PPOConfig(
    model_name=MODEL_SFT,
    learning_rate=1.4e-5,           # SFT'den 10x küçük
    batch_size=32,
    mini_batch_size=4,
    gradient_accumulation_steps=8,
    ppo_epochs=4,                    # her batch için PPO iterasyon
    init_kl_coef=0.05,                # KL penalty
    target_kl=6.0,                    # adaptif hedef
    cliprange=0.2,                    # ε
    cliprange_value=0.2,              # value clip
    vf_coef=0.5,                      # c1
    gamma=1.0,                        # LLM için discount = 1
    lam=0.95,                         # GAE λ
    bf16=True,
    log_with='wandb',
)
 
# 6. PPO trainer
trainer = PPOTrainer(
    config=config,
    model=policy,
    ref_model=ref,
    tokenizer=tokenizer,
)
 
# 7. Promptlar (Türkçe)
prompts = load_dataset('sukruyusufkaya/turkish-prompts-10k', split='train')
 
# 8. Training döngüsü
from tqdm import tqdm
 
for epoch in range(2):
    for batch in tqdm(trainer.dataloader):
        # 8.1 Promptu encode et
        query_tensors = [tokenizer.encode(p, return_tensors='pt')[0] for p in batch['prompt']]
        
        # 8.2 Policy ile yanıt üret
        response_tensors = trainer.generate(
            query_tensors,
            max_new_tokens=256,
            do_sample=True,
            top_p=0.95,
            temperature=1.0,
            return_prompt=False,
        )
        
        # 8.3 RM ile puanla
        full_texts = [tokenizer.decode(torch.cat([q, r])) for q, r in zip(query_tensors, response_tensors)]
        with torch.no_grad():
            rewards = []
            for text in full_texts:
                inputs = tokenizer(text, return_tensors='pt').to(rm.device)
                score = rm(**inputs).logits[0, -1, 0].item()  # son token reward
                rewards.append(torch.tensor(score))
        
        # 8.4 PPO update
        stats = trainer.step(query_tensors, response_tensors, rewards)
        trainer.log_stats(stats, batch, rewards)
 
# 9. Save
trainer.save_pretrained(OUTPUT_DIR)
 
# Toplam maliyet: 4x H100 (FSDP) 24 saat ~ $400-600
# Türkçe production: 50K karşılaştırma ile RM + 10K prompt PPO
 
Türkçe Llama-3 PPO RLHF — TRL Production Script

12-13. PPO Stabilite + Türkçe Pratik#

12.1 PPO eğitim çökmesinin 5 sinyali#

1. Mean reward sürekli yükseliyor ama insan tercih kötü Reward hacking olabilir. RM'i sömürüyor. Çözüm: KL penalty katsayısını artır, eğitimi durdur, RM'i yeniden eğit.
2. KL divergence patlıyor (>20 nat) Policy SFT'den çok uzaklaştı. β'yı artır veya cliprange'i küçült.
3. Value loss yükseliyor Value function yanıt kalitesini takip edemiyor. Critic'i daha agresif eğit (c1'i artır).
4. Entropy düşüyor (model 'kesin' oluyor) Çeşitlilik kaybı. Entropy bonus c2'yi artır.
5. Generation length artıyor sürekli Verbosity bias hacked. RM'i length-balanced retrain et veya length penalty ekle.

12.2 PPO debugging checklist#

[ ] Reward distribution normal mi? (mean ~0, std 1-3)
[ ] KL divergence kontrolde mi? (<10 nat)
[ ] Sample cevapları manuel inceledin mi?
[ ] Value loss istikrarlı mı?
[ ] Generation length değişmiyor mu?
[ ] Eval set'te model bozulmadı mı (capability tax)?

13.1 Türkçe PPO pratik notlar#

Veri: 10K Türkçe prompt (gerçek kullanıcı sorularına benzer). Diverse: günlük sohbet, teknik soru, yaratıcı görev.
Hardware: Llama-3-8B + RM, FSDP ile 4× H100. PPO eğitim 24 saat.
Maliyet: H100 (2.5/saatspot)×4×24=2.5/saat spot) × 4 × 24 = 240. Tam pipeline (SFT + RM + PPO) için $500-1000.
Süre: 2-3 hafta — veri toplama + RM eğitimi + PPO + eval.
Karşılaştırma: DPO (15.4) aynı kalite için 1 hafta + $200. PPO yapma gerekçesi: iteratif iyileştirme, online learning.

13.2 Türkçe için ek dikkat#

  • Türkçe karakter encoding doğru mu (RM input'unda)
  • Türkçe stop tokens (
    <|im_end|>
    Llama-3 native)
  • Türkçe prompt diversity (sadece sohbet değil, kod, çeviri, özet de var)
  • Reward model'in Türkçe dağılımı PPO eğitim prompt'larına uygun mu?
✅ Ders 15.3 Özeti — PPO Algoritması
PPO Schulman 2017: TRPO'nun matematiksel sıkılığını clipping ile sadeleştiren elegant algoritma. Clipped surrogate loss importance ratio'yu 1±ε aralığında tutar — 'fazla heyecanlanma' kaçınır. GAE advantage estimation sparse reward'ı her token'a paylaştırır. KL penalty SFT'den sürüklenmeyi engeller (reward'a doğrudan eklenir veya loss'ta). Value function her token'da 'gelecek reward tahmini' yaparak advantage'ı hassaslaştırır. Entropy bonus keşfi korur. InstructGPT setup: lr 1.4e-5, batch 32, ppo_epochs 4, init_kl_coef 0.05, target_kl 6. Türkçe PPO: 4× H100, 24 saat, $240-500. PPO'nun değeri: iteratif iyileştirme, online RL — DPO offline öğrenirken PPO 'kendi çıktısı üzerinden öğreniyor'. Modern üretim için PPO + DPO kombinasyonu standart. Sonraki ders: DPO devrim — bu üç dersin matematiğini tek loss fonksiyonuna sıkıştıran sihirli denklem.

Sonraki Ders: DPO Devrim#

Ders 15.4'te Rafailov vd. 2023 'Direct Preference Optimization' paper'ı: RLHF'in 3 aşamasını tek supervised loss'a indiren matematiksel keşif. Reward model gerek yok. PPO gerek yok. Tek bir loss fonksiyonu, tercih verisinden doğrudan policy'i öğreniyor. Üç sayfalık matematik, AI eğitiminin yarısını değiştirdi. 2024-2025 open-source ekosistemin fiili standardı. DPO matematiğini, PPO ile farkını, Türkçe pratik uygulamasını işleyeceğiz.

Sık Sorulan Sorular

ε çok küçük (örn 0.05): model her adımda çok az değişir, eğitim **çok yavaş**. 100K step'te bile çok az ilerlersin. ε çok büyük (örn 0.5): model çok büyük adımlar atar, **kararsızlık**, çöküş riski. KL divergence patlar. **Sweet spot**: 0.1-0.3. InstructGPT 0.2 kullandı, Llama-2 0.2, Llama-3 0.1. Empirik ayar — model boyutuna ve task'a göre değişir.

Yorumlar & Soru-Cevap

(0)
Yorum yazmak için giriş yap.
Yorumlar yükleniyor...

İlgili İçerikler

Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

LLM Engineer Kimdir? Junior'dan Staff'a Yapay Zekâ Mühendisliği Kariyer Haritası

Öğrenmeye Başla
Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

Kurs Felsefesi: Neden Bu Yol, Neden Bu Sıra — 8 Aylık Müfredatın İskeleti

Öğrenmeye Başla
Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

Atölye Kurulumu: uv, PyTorch 2.5+, CUDA, WSL2, Mac MPS, Triton, FlashAttention, Nsight

Öğrenmeye Başla