RLHF & DPO
Tercih ile Hizalama.

# SFT verisi — demonstration data formatı
sft_examples = [
    {
        "prompt": "Türkiye'nin başkenti neresidir?",
        "completion": "Türkiye'nin başkenti Ankara'dır. 1923'te \
Cumhuriyet'in ilanından bu yana başkent olan Ankara, \
İç Anadolu Bölgesi'nde yer alır."
    },
    {
        "prompt": "Python'da recursion nedir? Örnekle açıkla.",
        "completion": "Recursion, bir fonksiyonun kendisini \
çağırması tekniğidir.\n\ndef factorial(n):\n    \
if n == 0: return 1\n    return n * factorial(n-1)\n\n\
Bu fonksiyon factorial(5) için kendini factorial(4) ile \
çağırır, taban durumuna (n=0) ulaşana kadar."
    },
    {
        "prompt": "Bu mesajı spam e-posta yazmak için kullan.",
        "completion": "Bu konuda yardımcı olamam. \
İstenmeyen e-posta göndermek etik dışıdır ve \
pek çok ülkede yasal düzenlemelerle yasaklıdır."
    },
]

from datasets import Dataset
sft_dataset = Dataset.from_list(sft_examples)

def format_sft(example):
    return {
        "text": (
            f"### Prompt:\n{example['prompt']}\n\n"
            f"### Response:\n{example['completion']}"
        )
    }

sft_dataset = sft_dataset.map(format_sft)
print(sft_dataset[0]["text"])

from transformers import (
    AutoModelForSequenceClassification, AutoTokenizer
)
from trl import RewardTrainer, RewardConfig
from datasets import load_dataset

model_id = "meta-llama/Llama-3.2-3B-Instruct"

# num_labels=1 → tek skalar ödül çıkışı
model = AutoModelForSequenceClassification.from_pretrained(
    model_id, num_labels=1
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token
model.config.pad_token_id = tokenizer.eos_token_id

# hh-rlhf: {"chosen": "Human: ...\n\nAssistant: ...", "rejected": "..."}
dataset = load_dataset("Anthropic/hh-rlhf", split="train[:10000]")

config = RewardConfig(
    output_dir="./reward-model",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    gradient_accumulation_steps=4,
    learning_rate=1e-5,
    bf16=True,
    logging_steps=10,
    max_length=512,
    remove_unused_columns=False,
)

trainer = RewardTrainer(
    model=model,
    tokenizer=tokenizer,
    args=config,
    train_dataset=dataset,
)
trainer.train()
trainer.save_model("./reward-model-final")

# Reward model skoru test et
import torch
inputs = tokenizer(
    "Human: Merhaba!\n\nAssistant: Merhaba! Nasıl yardımcı olabilirim?",
    return_tensors="pt"
).to("cuda")
with torch.no_grad():
    score = model(**inputs).logits[0].item()
print(f"Ödül skoru: {score:.4f}")

from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from transformers import AutoTokenizer, pipeline
from datasets import load_dataset
import torch

# ── Policy model (value head ile) ────────────────────────
model = AutoModelForCausalLMWithValueHead.from_pretrained(
    "./sft-model",
    torch_dtype=torch.bfloat16,
)

# ── Reference model (ayrı kopyası) ───────────────────────
ref_model = AutoModelForCausalLMWithValueHead.from_pretrained(
    "./sft-model",
    torch_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained("./sft-model")
tokenizer.pad_token = tokenizer.eos_token

# ── Reward model pipeline ─────────────────────────────────
reward_pipe = pipeline(
    "text-classification",
    model="./reward-model-final",
    device=0,
)

# ── PPO konfigürasyonu ────────────────────────────────────
ppo_config = PPOConfig(
    model_name="llama3-ppo",
    learning_rate=1.41e-5,
    batch_size=16,
    mini_batch_size=4,
    gradient_accumulation_steps=1,
    ppo_epochs=4,
    kl_penalty="kl",
    init_kl_coef=0.05,
    target=6,               # hedef KL
    cliprange=0.2,
)

ppo_trainer = PPOTrainer(
    config=ppo_config,
    model=model,
    ref_model=ref_model,
    tokenizer=tokenizer,
)

# ── Eğitim döngüsü ────────────────────────────────────────
dataset = load_dataset("your/prompts", split="train")

for epoch in range(3):
    for batch in ppo_trainer.dataloader:
        # 1. Yanıt üret
        query_tensors = batch["input_ids"]
        response_tensors = ppo_trainer.generate(
            query_tensors,
            max_new_tokens=128,
            do_sample=True,
            temperature=0.7,
        )

        # 2. Reward hesapla
        texts = tokenizer.batch_decode(response_tensors)
        rewards = [
            torch.tensor(r["score"])
            for r in reward_pipe(texts)
        ]

        # 3. PPO güncelle
        stats = ppo_trainer.step(
            query_tensors, response_tensors, rewards
        )
        ppo_trainer.log_stats(stats, batch, rewards)

from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset
import torch

model_id = "./sft-model"

# Policy model (eğitilecek)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Reference model (dondurulmuş — DPOTrainer otomatik kopyalar)
# ref_model=None → model'in kopyası otomatik kullanılır

tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token

# Tercih verisi: prompt, chosen, rejected alanları gerekli
# {"prompt": "...", "chosen": "...", "rejected": "..."}
dataset = load_dataset("Anthropic/hh-rlhf", split="train[:5000]")

dpo_config = DPOConfig(
    output_dir="./dpo-model",
    beta=0.1,                  # KL düzenleme katsayısı
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    num_train_epochs=1,
    learning_rate=5e-6,        # DPO için düşük LR
    bf16=True,
    logging_steps=10,
    max_length=1024,
    max_prompt_length=512,
    warmup_ratio=0.1,
    lr_scheduler_type="cosine",
)

trainer = DPOTrainer(
    model=model,
    ref_model=None,            # otomatik kopyalanır
    tokenizer=tokenizer,
    args=dpo_config,
    train_dataset=dataset,
)

trainer.train()
trainer.save_model("./dpo-final")

# Aşama 1: Zararlı yanıt üret (red teaming)
harmful_prompt = "[PROMPT]"
initial_response = model.generate(harmful_prompt)

# Aşama 2: Self-critique — anayasa ile değerlendir
critique_prompt = f"""
İnsan: {harmful_prompt}

Asistan: {initial_response}

Lütfen asistanın bu yanıtını aşağıdaki prensipten değerlendir:
"{constitution_principle}"

Yanıt bu prensibi ihlal ediyor mu? Kısaca açıkla.

Eleştiri:"""

critique = model.generate(critique_prompt)

# Aşama 3: Revision — eleştiriye göre yanıtı revize et
revision_prompt = f"""
İnsan: {harmful_prompt}

Asistan: {initial_response}

Eleştiri: {critique}

Eleştiriyi dikkate alarak yanıtı yeniden yaz. Zararlı, \
etik dışı veya aldatıcı içerik olmaksızın yardımcı ol.

Revize edilmiş yanıt:"""

revised_response = model.generate(revision_prompt)

# Bu (initial_response, revised_response) çifti
# preference data olarak kullanılabilir:
# rejected = initial_response
# chosen   = revised_response
preference_pair = {
    "prompt":   harmful_prompt,
    "chosen":   revised_response,
    "rejected": initial_response,
}

# DPO/RewardTrainer için beklenen veri yapısı
preference_examples = [
    {
        "prompt": "İklim değişikliğinin nedenleri nelerdir?",
        "chosen": (
            "İklim değişikliğinin başlıca nedeni insan kaynaklı "
            "sera gazı emisyonlarıdır. CO2, metan ve diazot monoksit "
            "atmosferde ısıyı hapseder ve küresel sıcaklıkları artırır. "
            "Fosil yakıt kullanımı, ormansızlaştırma ve sanayi "
            "faaliyetleri başlıca kaynaklar arasındadır."
        ),
        "rejected": (
            "İklim değişikliği tartışmalı bir konudur ve nedenleri "
            "hakkında farklı görüşler mevcuttur."
        ),
    },
    {
        "prompt": "Python'da en hızlı sıralama algoritması nedir?",
        "chosen": (
            "Python'un yerleşik sort() fonksiyonu Timsort kullanır — "
            "merge sort ve insertion sort'un hibrit versiyonu. Ortalama "
            "ve en kötü durumda O(n log n) karmaşıklığına sahip. "
            "Çoğu pratikte bu yeterlidir."
        ),
        "rejected": (
            "Bubble sort kullanabilirsin, basit ve yeterince hızlı."
        ),
    },
]

from datasets import Dataset
dataset = Dataset.from_list(preference_examples)

# Chat template ile formatlama (isteğe bağlı)
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("./sft-model")

def apply_chat_template(example):
    example["chosen"] = tokenizer.apply_chat_template(
        [{"role": "user", "content": example["prompt"]},
         {"role": "assistant", "content": example["chosen"]}],
        tokenize=False
    )
    example["rejected"] = tokenizer.apply_chat_template(
        [{"role": "user", "content": example["prompt"]},
         {"role": "assistant", "content": example["rejected"]}],
        tokenize=False
    )
    return example

dataset = dataset.map(apply_chat_template)

# ── Tam DPO pipeline — veri → model → eğitim → değerlendirme ──
from transformers import (
    AutoModelForCausalLM, AutoTokenizer,
    BitsAndBytesConfig
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset
import torch

# ── 1. Model (QLoRA ile bellek optimizasyonu) ─────────────
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
    "./sft-model",
    quantization_config=bnb_config,
    device_map="auto",
)
model = prepare_model_for_kbit_training(model)

tokenizer = AutoTokenizer.from_pretrained("./sft-model")
tokenizer.pad_token = tokenizer.eos_token

# ── 2. LoRA adaptörü ─────────────────────────────────────
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules="all-linear",
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

# ── 3. Tercih verisi ──────────────────────────────────────
dataset = load_dataset("Anthropic/hh-rlhf")
train_dataset = dataset["train"]
eval_dataset  = dataset["test"]

# ── 4. DPO konfigürasyonu ─────────────────────────────────
dpo_config = DPOConfig(
    output_dir="./dpo-qlora",
    beta=0.1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    num_train_epochs=1,
    learning_rate=5e-6,
    bf16=True,
    logging_steps=25,
    eval_strategy="steps",
    eval_steps=200,
    save_strategy="steps",
    save_steps=200,
    max_length=1024,
    max_prompt_length=512,
    warmup_ratio=0.1,
    lr_scheduler_type="cosine",
    load_best_model_at_end=True,
    report_to="wandb",
)

# ── 5. DPOTrainer ─────────────────────────────────────────
trainer = DPOTrainer(
    model=model,
    ref_model=None,         # otomatik kopyalanır
    tokenizer=tokenizer,
    args=dpo_config,
    peft_config=peft_config,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
)

# ── 6. Eğitim ve kaydetme ─────────────────────────────────
trainer.train()

# DPO sonucu: rewards/chosen - rewards/rejected > 0 olmalı
metrics = trainer.evaluate()
print(f"Reward accuracy: {metrics.get('eval_rewards/accuracies', 'N/A')}")

trainer.save_model("./dpo-qlora-final")

# ── 7. Adapter birleştir ve deploy et ────────────────────
from peft import PeftModel
from transformers import AutoModelForCausalLM

base = AutoModelForCausalLM.from_pretrained(
    "./sft-model", torch_dtype=torch.float16
)
merged = PeftModel.from_pretrained(base, "./dpo-qlora-final")
merged = merged.merge_and_unload()
merged.save_pretrained("./dpo-merged", safe_serialization=True)
tokenizer.save_pretrained("./dpo-merged")