Policy Model

Policy Model im Überblick

Das Policy Model ist das Sprachmodell, das bei RLHF trainiert wird. Es lernt, Antworten zu generieren, die vom Reward Model hoch bewertet werden – und damit menschlichen Präferenzen entsprechen.

Der RLHF-Prozess:

┌─────────────────┐
│   SFT Model     │  Startpunkt: Kann Instruktionen befolgen
└────────┬────────┘
         │ Kopie
         ▼
┌─────────────────┐     ┌─────────────────┐
│  Policy Model   │ ←── │  Reward Model   │
│  (wird trainiert)│     │  (bewertet)     │
└────────┬────────┘     └─────────────────┘
         │
         ▼
┌─────────────────┐
│ Aligned Model   │  Ergebnis: Hilfreich, harmlos, ehrlich
└─────────────────┘

Training-Loop:

1. Policy Model generiert Antwort auf Prompt
2. Reward Model bewertet die Antwort (Score 0-1)
3. PPO-Algorithmus aktualisiert Policy Model
4. Wiederhole bis Policy gute Rewards bekommt

Technisch betrachtet

Policy im RL-Kontext

Reinforcement Learning Begriffe:

State (s):     Der bisherige Kontext (Prompt + generierte Tokens)
Action (a):    Das nächste Token
Policy π(a|s): Wahrscheinlichkeitsverteilung über Tokens
Reward (r):    Bewertung der vollständigen Antwort

Das LLM IST die Policy:
π(token | context) = softmax(logits)

PPO-Training

from trl import PPOTrainer, PPOConfig

# Konfiguration
config = PPOConfig(
    learning_rate=1e-5,
    batch_size=64,
    ppo_epochs=4,
)

# Policy Model (wird trainiert)
policy_model = AutoModelForCausalLM.from_pretrained("sft-model")

# Reference Model (eingefroren, für KL-Penalty)
ref_model = AutoModelForCausalLM.from_pretrained("sft-model")

trainer = PPOTrainer(
    config=config,
    model=policy_model,
    ref_model=ref_model,
    tokenizer=tokenizer,
)

# Training Loop
for batch in dataloader:
    # 1. Policy generiert Antworten
    responses = trainer.generate(batch["prompts"])
    
    # 2. Reward Model bewertet
    rewards = reward_model(batch["prompts"], responses)
    
    # 3. PPO Update
    stats = trainer.step(batch["prompts"], responses, rewards)

KL-Divergenz Penalty

# Verhindert, dass Policy zu weit vom Reference abweicht
def compute_kl_penalty(policy_logprobs, ref_logprobs, kl_coef=0.1):
    kl_div = policy_logprobs - ref_logprobs
    return kl_coef * kl_div

# Gesamter Reward
total_reward = reward_from_rm - kl_penalty

Warum KL-Penalty?

• Ohne: Policy könnte “hacken” und unrealistische Antworten generieren
• Mit: Policy bleibt nahe am SFT-Modell, nur gezielte Verbesserungen

Policy vs. Reference vs. Reward

DPO: Ohne explizites Reward Model

# DPO trainiert Policy direkt auf Präferenzdaten
# Kein separates Reward Model nötig

from trl import DPOTrainer

trainer = DPOTrainer(
    model=policy_model,
    ref_model=ref_model,
    train_dataset=preference_dataset,  # (prompt, chosen, rejected)
)

trainer.train()

Bei DPO ist das Reward Model implizit in der Loss-Funktion kodiert.