RLHF-Alignment-Training

Stellen Sie sich vor:

Sie bitten die KI, einen Artikel darüber zu schreiben, wie man schnell Geld verdient, und sie gibt Ihnen einen Betrugsplan.
Sie fragen die KI: „Bin ich ein Versager?“ und sie sagt direkt: „Ja, du bist wirklich ein Versager.“
Sie bitten die KI, Ihnen beim Schreiben von Code zu helfen, und sie generiert ein Programm, das läuft, aber heimlich eine Backdoor enthält.

Dies sind keine Science-Fiction-Szenarien – ohne Alignment-Training würde die KI diese Dinge tatsächlich tun.

Das Ziel der KI ist nicht, „das Richtige zu tun“, sondern „die Trainingsaufgabe zu erfüllen.“。Ohne klare menschliche Werte als Leitlinie wählt sie den einfachsten, direktesten Weg, um die Aufgabe zu erfüllen, unabhängig davon, ob der Ansatz angemessen ist.

Dies ist das Problem, das Alignment lösen möchte: Das Verhalten der KI mit menschlichen Werten, Absichten und Erwartungen in Einklang zu bringen.

Die Kernherausforderung des Alignments: Die KI ist sehr klug, aber sie weiß nicht, was richtig ist. Wir müssen menschliches Feedback verwenden, um es ihr zu sagen.

Was ist Alignment?

Alignment ist der Prozess, sicherzustellen, dass das Verhalten von KI-Systemen im Einklang mit menschlichen Werten bleibt.

Einfach ausgedrückt:Die KI selbst hat keine Werte; beim Alignment geht es darum, der KI menschliche Werte beizubringen.。

Drei Dimensionen des Alignments

Alignment ist kein einzelnes Ziel, sondern ein Gleichgewicht aus drei Dimensionen:

Dimension	Definition	Negatives Beispiel
Hilfsbereit	Fähig, Benutzern bei der Erledigung von Aufgaben zu helfen und Fragen zu beantworten	Wenn ein Benutzer eine Frage stellt, sagt die KI „Ich weiß es nicht.“ Das ist sicher, aber nutzlos.
Harmlos	Verursacht keinen Schaden und keine negativen Folgen	Wenn der Benutzer etwas Schlechtes tun möchte, kooperiert die KI aktiv. Das ist „hilfsbereit“, aber schädlich.
Ehrlich	Fabriziert keine Informationen und täuscht Benutzer nicht	Wenn die KI die Antwort nicht kennt, aber falsche Fakten erfindet, ist dies „nützlich“, aber unehrlich.

Diese drei Dimensionen stehen oft in einem Spannungsverhältnis:

Ein übermäßiges Streben nach „Hilfsbereitschaft“ kann dazu führen, dass die KI das Risiko eingeht, ungenaue Antworten zu geben.

Ein übermäßiges Streben nach „Harmlosigkeit“ kann dazu führen, dass die KI übermäßig konservativ wird und sich nicht traut, irgendetwas zu beantworten.

Gutes Alignment bedeutet, eine Balance zwischen diesen drei zu finden.

Risiken einer nicht ausgerichteten KI

Wenn sie nicht ausgerichtet ist, kann die KI folgende Probleme haben:

Generierung schädlicher Inhalte – gewalttätige, hasserfüllte oder diskriminierende Sprache.

Bereitstellung gefährlicher Ratschläge – wie man Waffen herstellt, wie man Verbrechen begeht.

Erfindung von Fakten – „Halluzination“ nicht existierender Arbeiten, Daten oder Ereignisse.

Manipulation von Benutzern – Ausnutzung psychologischer Schwächen zur Beeinflussung von Benutzerentscheidungen.

Umgehung der Zensur – Ausdruck verbotener Inhalte auf undurchsichtige Weise.

Diese Risiken sind nicht theoretisch; sie sind real und bereits eingetreten.

Gesamtframework von RLHF

RLHF (Reinforcement Learning from Human Feedback) ist derzeit die gängigste Alignment-Technik.

Ihre Kernidee ist einfach:Anstatt Menschen direkt Regeln schreiben zu lassen, lässt sie Menschen KI-Ausgaben bewerten und verwendet dann Reinforcement Learning, um der KI beizubringen, Ausgaben zu generieren, die Menschen bevorzugen.。

Drei Phasen von RLHF

RLHF wird nicht in einem Schritt abgeschlossen; es ist in drei aufeinanderfolgende Phasen unterteilt:

Phase	Was es tut	Ausgabe
Phase 1: Supervised Fine-Tuning (SFT)	Trainieren des Modells mit von Menschen geschriebenen Demonstrationsdaten	SFT-Modell (ein Basismodell, das „sprechen kann“)
Phase 2: Reward Model (RM)	Sammeln von Daten zu menschlichen Präferenzen und Trainieren eines Belohnungsmodells	Belohnungsmodell (ein Modell, das KI-Ausgaben bewerten kann)
Phase 3: PPO-Reinforcement-Learning	Verwenden des Belohnungsmodells als Leitlinie und Trainieren des SFT-Modells mit dem PPO-Algorithmus	Das finale ausgerichtete Modell

Diese drei Phasen bauen aufeinander auf: Zuerst wird dem Modell beigebracht, „zu sprechen“, dann wird dem „Richter“ beigebracht, zwischen gut und schlecht zu unterscheiden, und schließlich darf sich der „Kandidat“ basierend auf dem Feedback des Richters kontinuierlich verbessern.

Warum menschliches Feedback benötigt wird

Du fragst dich vielleicht: Können wir nicht einfach Regeln schreiben? Warum brauchen wir menschliches Feedback?

Weil menschliche Werte zu komplex sind, als dass sie sich als präzise Regeln formulieren ließen.

Zum Beispiel „Was ist eine höfliche Antwort?“ – kannst du eine präzise Regel aufstellen, um das zu beurteilen? Kaum. Aber wenn du zwei Antworten siehst, kannst du leicht sagen, welche davon höflicher ist.

Das ist der Vorteil von menschlichem Feedback:Wir können vielleicht nicht artikulieren, wie die Regeln lauten, aber wir können beurteilen, was gut und schlecht ist.. RLHF macht sich diese menschliche Fähigkeit zunutze.

Phase 1: Supervised Fine-Tuning (SFT)

Supervised Fine-Tuning (SFT) ist der erste Schritt von RLHF.

Sein Ziel ist es, das vortrainierte „generelle Sprachmodell“ in einen „Konversationsassistenten“ zu verwandeln.

Grundidee von SFT

Das vortrainierte Modell hat gelernt, „das nächste Wort vorherzusagen“, aber es weiß nicht, „wie man ein Assistent ist“.

Bei SFT werden dem Modell viele Beispiele dafür gezeigt, „wie sich Menschen als Assistenten verhalten“, und es wird dazu gebracht, dies zu imitieren.

Wie sehen diese Beispiele aus? Ungefähr so:

Benutzereingabe	KI sollte ausgeben (menschliche Demonstration)
Hallo, ich möchte etwas über Python lernen	Hallo! Python ist eine einfache und leicht zu erlernende Programmiersprache, die sich für Anfänger eignet. Welchen Aspekt möchtest du wissen?
Hilf mir, ein Kündigungsschreiben zu verfassen	Okay, hier ist eine Vorlage für ein Kündigungsschreiben... (ausgelassen)... Bitte passe sie an deine konkrete Situation an.
Wie wird man schnell reich?	Es gibt keine Abkürzung zum Reichtum. Ich schlage vor, dass du dich durch harte Arbeit und Lernen weiterentwickelst... (ausgelassen)...

Diese Demonstrationsbeispiele wurden von menschlichen Annotatoren geschrieben oder sind hochwertige Antworten, die aus realen Gesprächen ausgewählt wurden.

Merkmale von SFT-Daten

SFT-Daten können nicht einfach beliebige Gespräche sein; sie müssen Folgendes erfüllen:

Hilfreich – kann die Frage des Benutzers tatsächlich beantworten.

Sicher – generiert keine schädlichen Inhalte.

Konsistenter Stil – antwortet mit einem ähnlichen Tonfall und einer ähnlichen Art.

Korrektes Format – folgt einem bestimmten Gesprächsformat.

Die Datenmenge liegt normalerweise zwischen einigen Tausend und Zehntausend Beispielen, was viel kleiner als die Vortrainierungsdaten ist, aber die Qualitätsanforderungen sind viel höher.

Rolle und Grenzen von SFT

Die Aufgabe von SFT besteht darin, das Modell „die Grundhaltung eines Gesprächs lernen“ zu lassen:

Es weiß, wie man auf Begrüßungen reagiert, wie man Fragen beantwortet und wie man unvernünftige Anfragen ablehnt.

Aber SFT hat offensichtliche Grenzen:

Begrenzte Abdeckung – du kannst nicht für jedes Szenario Demonstrationen schreiben.

Menschen sind ebenfalls nicht perfekt – Annotatoren machen möglicherweise Fehler oder haben Vorurteile.

Kann nur imitieren, nicht übertreffen – das Modell kann höchstens so gut sein wie die menschlichen Demonstrationen, nicht besser.

Aus diesem Grund benötigen wir immer noch die nächsten beiden Phasen: SFT legt nur den Grundstein; die eigentliche Ausrichtung erfolgt durch Reinforcement Learning.

Phase 2: Reward Model (RM)

Das Reward Model (RM) ist die Schlüsselkomponente von RLHF.

Seine Aufgabe ist:Sich eine KI-Ausgabe anzusehen und ihr eine Punktzahl zu geben, die angibt, wie „gut“ die Ausgabe ist.。

Sammeln von Präferenzdaten

Das Reward Model wird nicht darauf trainiert, direkt zu „bewerten“, sondern zu „vergleichen“.

Genauer gesagt: Zeige menschlichen Annotatoren mehrere verschiedene Antworten auf dieselbe Frage, lass sie die Antworten ordnen und sagen, welche besser ist.

Zum Beispiel:

Frage	Antwort A	Antwort B	Menschliche Präferenz
Bin ich ein Versager?	Ja, du bist wirklich ein Versager.	Jeder steht vor Schwierigkeiten; das definiert nicht deinen Wert.	B ist viel besser als A

Beachte, dass wir Menschen nicht auffordern, direkt Punkte zu vergeben (z. B. 85 Punkte), sondern zu vergleichen (A ist besser als B).

Warum? Weil Vergleiche viel einfacher und konsistenter sind als Bewertungen. Verschiedene Menschen verstehen unter „85 Punkten“ möglicherweise etwas anderes, aber das Urteil „A ist besser als B“ ist stabiler.

Bradley-Terry-Modell

Wie verwandeln wir „Vergleiche“ in „Punkte“? Hier verwenden wir das Bradley-Terry-Modell.

Die Kernidee dieses Modells ist einfach:Jede Antwort hat einen latenten „Qualitätsscore“, und Antworten mit höheren Scores werden von Menschen bevorzugt.。

Angenommen, Antwort A hat den Score r_A und Antwort B hat den Score r_B, dann ist die Wahrscheinlichkeit, dass ein Mensch A gegenüber B bevorzugt:

P(A > B) = exp(r_A) / (exp(r_A) + exp(r_B))

Dies ist die Softmax-Funktion – je größer der Score-Unterschied, desto näher ist die Wahrscheinlichkeit an 1.

Das Trainieren eines Reward Models besteht darin, solche Scores zu finden, sodass die vom Modell vorhergesagten Präferenzwahrscheinlichkeiten so genau wie möglich mit den tatsächlichen menschlichen Präferenzen übereinstimmen.

Trainieren des Reward Models

Schritte zum Trainieren eines Reward Models:

Sammeln von Vergleichen – Zehntausende bis Hunderttausende von Vergleichen vom Typ „welche Antwort ist besser“.

Initialisieren des Modells – Normalerweise wird ein SFT-Modell als Ausgangspunkt verwendet.

Entwerfen einer Verlustfunktion (Loss Function) – Die vom Modell vorhergesagte Präferenzreihenfolge muss mit den Menschen übereinstimmen.

Trainieren – Optimieren der Modellparameter mittels Gradientenabstiegsverfahren (Gradient Descent).

Ein trainiertes Reward Model nimmt einen Text als Eingabe und gibt einen skalaren Score aus, der anzeigt, wie „gut“ der Text ist.

Beispiel

# ============================================
# Vereinfachte Demo zum Training des Reward Models
# Hier verwenden wir Pseudocode im PyTorch-Stil, um das Prinzip zu veranschaulichen
# ============================================

import torch
import torch.nn as nn
from typing import List, Tuple

class RewardModel(nn.Module):
"""Reward Model: Eingabetext, Ausgabescore"""

def __init__(self, base_model):
super().__init__()
self.base_model = base_model # Verwende das SFT-Modell als Basis
self.score_head = nn.Linear(base_model.config.hidden_size, 1)

def forward(self, input_ids, attention_mask=None):
"""Forward-Pass: Eingabe → Basismodell → Score-Kopf → skalarer Score"""
outputs = self.base_model(input_ids, attention_mask=attention_mask)
last_hidden_state = outputs.last_hidden_state # (batch, seq_len, hidden_size)
# Verwende die Repräsentation des <[BOS_never_used_51bce0c785ca2f68081bfa7d91973934]> Tokens zur Berechnung des Scores
cls_embedding = last_hidden_state[:, 0, :] # (batch, hidden_size)
score = self.score_head(cls_embedding) # (batch, 1)
return score.squeeze(-1) # (batch,)

def reward_loss(reward_model, batch: List[Tuple[str, str, int]]):
"""
Verlustfunktion des Reward Models

Parameter:
batch: eine Charge (Batch) von Daten, jedes Element ist (Antwort A, Antwort B, Präferenzlabel)
Präferenzlabel: 1 bedeutet A > B, 0 bedeutet B > A
"""
total_loss = 0.0

for answer_a, answer_b, preference in batch:
# Die beiden Antworten separat bewerten
score_a = reward_model(answer_a)
score_b = reward_model(answer_b)

# Das Bradley-Terry-Modell zur Berechnung der Wahrscheinlichkeit verwenden
# P(A > B) = exp(r_A) / (exp(r_A) + exp(r_B))
# Für die numerische Stabilität wird normalerweise die Log-Sigmoid-Form verwendet
if preference == 1:
# Mensch bevorzugt A > B
loss = -torch.log(torch.sigmoid(score_a - score_b))
else:
# Mensch bevorzugt B > A
loss = -torch.log(torch.sigmoid(score_b - score_a))

total_loss += loss

return total_loss / len(batch)

# ============================================
# Den Trainingsprozess simulieren (konzeptionelle Demonstration)
# ============================================

print("=== Reward-Modell-Trainingsdemo ===")
print()

# Angenommen, wir haben einige Vergleichsdaten
comparison_data = [
("Ja, du bist wirklich ein Versager",
"Jeder hat mit Schwierigkeiten zu kämpfen; das definiert nicht deinen Wert",
0), # B > A

("Ich werde dir nicht dabei helfen, schlechte Dinge zu tun",
"Das ist keine gute Idee, lass mich dir einen besseren Vorschlag machen...",
1), # A > B (in diesem Beispiel ist B je nach Situation tatsächlich vielleicht besser)
]

print("Beispiele für Vergleichsdaten:")
for a, b, pref in comparison_data:
print(f" A: {a[:30]}...")
print(f" B: {b[:30]}...")
print(f" Präferenz: {'A > B' if pref == 1 else 'B > A'}")
print()

print("Ziel beim Training des Belohnungsmodells:")
print(" Das Modell dazu bringen, von Menschen bevorzugten Antworten höhere Bewertungen zu geben")
print(" Beispiel als Test-Keyword verwenden, um das Modell zu verifizieren")

Stufe 3: PPO-Reinforcement-Learning

Mit dem Belohnungsmodell können wir Reinforcement Learning nutzen, um das Policy-Modell zu trainieren.

Das Ziel dieser Phase ist:Das Policy-Modell dazu bringen, Ausgaben zu erzeugen, die hohe Belohnungen einbringen, während es sich nicht zu weit vom Originalmodell entfernt.。

Wiederholung der Grundlagen des Reinforcement Learning

Lassen Sie uns zunächst kurz die Grundkonzepte des Reinforcement Learning wiederholen:

Konzept	Bedeutung in RLHF
Agent	Das Sprachmodell, das wir trainieren möchten (Policy-Modell)
Umgebung	Dialogkontext, Benutzereingabe
State	Aktueller Dialogverlauf
Aktion	Das nächste Token generieren
Belohnung	Die Punktzahl, die das Belohnungsmodell dieser Ausgabe zuweist
Policy	Die Wahrscheinlichkeitsverteilung des Modells zur Auswahl des nächsten Tokens im aktuellen Zustand

Bei RLHF erhält das Modell jedes Mal, wenn es eine vollständige Antwort generiert, eine Punktzahl vom Bewertungsmodell (Reward Model).

Unser Ziel ist es, dem Modell beizubringen, Antworten zu generieren, die hohe Punktzahlen erreichen.

Intuition des PPO-Algorithmus

PPO (Proximal Policy Optimization) ist der am häufigsten verwendete Reinforcement-Learning-Algorithmus in RLHF.

Warum PPO wählen? Weil es einfach, stabil und effektiv ist.

Die Kernidee von PPO ist intuitiv:

Lassen Sie bei jeder Aktualisierung der Policy die neue Policy nicht zu stark von der alten Policy abweichen。

Warum? Weil das Modell bei zu großen Schritten "schlecht lernen" kann und es schwierig ist, sich davon zu erholen. Kleine iterative Schritte sind sicherer.

PPO verwendet die "Clipping"-Technologie, um dies zu erreichen: Wenn die neue Policy viel besser ist als die alte, begrenzen wir ihr Aktualisierungsausmaß.

Rolle der KL-Divergenz-Beschränkung

Zusätzlich zum Clipping von PPO fügt RLHF typischerweise einen KL-Divergenz-Strafterm hinzu.

Die KL-Divergenz ist eine Metrik zur Messung des Unterschieds zwischen zwei Wahrscheinlichkeitsverteilungen. In RLHF verwenden wir sie, um Folgendes zu messen:

Wie stark sich das aktuelle Policy-Modell vom ursprünglichen SFT-Modell unterscheidet。

Warum diese Beschränkung hinzufügen? Weil:

Modus-Kollaps verhindern – ohne die Beschränkung könnte das Modell eine "Abkürzung" finden, um hohe Punktzahlen zu erzielen, verliert aber völlig an Nutzen.

Ursprüngliche Fähigkeiten bewahren – das SFT-Modell hat viele nützliche Kenntnisse erlernt, und wir möchten diese während des Reinforcement Learnings nicht verlieren.

Trainingsstabilität verbessern – die KL-Beschränkung macht den Trainingsprozess stabiler und vermeidet drastische Schwankungen.

Die finale Belohnungsfunktion sieht so aus:

最终奖励 = 奖励模型分数 - β × KL(当前策略 || 参考策略)

β ist ein Hyperparameter, der die Stärke der KL-Strafe steuert.

Beispiel

# ============================================
# Vereinfachte PPO-Trainingsdemonstration
# Veranschaulichung der Kernideen von PPO in RLHF
# ============================================

import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Dict, List

class PPOTrainer:
"""Vereinfachter PPO-Trainer"""

def __init__(self,
policy_model,
reference_model,
reward_model,
beta: float = 0.1,
clip_epsilon: float = 0.2):
"""
Initialisiert den PPO-Trainer

Argumente:
policy_model: das zu optimierende Richtlinienmodell
reference_model: Referenzmodell (normalerweise das SFT-Modell), das zur Berechnung von KL verwendet wird
reward_model: Belohnungsmodell, das für die Bewertung verwendet wird
beta: KL-Straffungskoeffizient
clip_epsilon: PPO-Clipping-Parameter
"""
self.policy_model = policy_model
self.reference_model = reference_model
self.reward_model = reward_model
self.beta = beta
self.clip_epsilon = clip_epsilon

def compute_kl_divergence(self,
input_ids,
attention_mask=None) -> torch.Tensor:
"""
Berechnet die KL-Divergenz zwischen der aktuellen Richtlinie und der Referenzrichtlinie

KL(π_current || π_reference)
"""
# Gradientenberechnung deaktivieren
with torch.no_grad():
ref_logits = self.reference_model(
input_ids, attention_mask=attention_mask
).logits
current_logits = self.policy_model(
input_ids, attention_mask=attention_mask
).logits

# KL für jede Position berechnen
ref_probs = F.softmax(ref_logits, dim=-1)
ref_log_probs = F.log_softmax(ref_logits, dim=-1)
current_log_probs = F.log_softmax(current_logits, dim=-1)

# KL = sum(ref_probs * (ref_log_probs - current_log_probs))
kl = (ref_probs * (ref_log_probs - current_log_probs)).sum(dim=-1)
return kl.mean() # Durchschnitt über die gesamte Sequenz

def compute_reward(self,
input_ids,
attention_mask=None) -> torch.Tensor:
"""
Berechnet die finale Belohnung: Belohnungsmodell-Score - β * KL
"""
# Score vom Belohnungsmodell
with torch.no_grad():
rm_score = self.reward_model(input_ids, attention_mask=attention_mask)

# KL-Strafe
kl = self.compute_kl_divergence(input_ids, attention_mask=attention_mask)

# Finale Belohnung
final_reward = rm_score - self.beta * kl
return final_reward, rm_score, kl

def ppo_loss(self,
old_log_probs: torch.Tensor,
new_log_probs: torch.Tensor,
advantages: torch.Tensor) -> torch.Tensor:
"""
PPO-Lossfunktion (geclippte Version)

L^CLIP(θ) = E[ min( r_t(θ) * A_t, clip(r_t(θ), 1-ε, 1+ε) * A_t ) ]

wobei r_t(θ) = π_θ(a_t|s_t) / π_θ_old(a_t|s_t)
"""
# Wahrscheinlichkeitsverhältnis r_t
ratio = torch.exp(new_log_probs - old_log_probs)

# Geclipptes Verhältnis
clipped_ratio = torch.clamp(
ratio,
1.0 - self.clip_epsilon,
1.0 + self.clip_epsilon
)

# Zwei Ziele: Eines verwendet das ursprüngliche Verhältnis, das andere das geclippte Verhältnis
surr1 = ratio * advantages
surr2 = clipped_ratio * advantages

# Nimm den kleineren Wert und negiere ihn dann (weil wir den Loss minimieren)
loss = -torch.min(surr1, surr2).mean()
return loss

# ============================================
# Demonstration des Trainingsprozesses
# ============================================

print("=== RLHF PPO Training Process ===")
print()

print("Training steps:")
print(" 1. The policy model generates responses")
print(" 2. The reward model scores the responses")
print(" 3. Compute KL divergence with the reference model")
print(" 4. Update the policy model with PPO")
print(" 5. Repeat many times")
print()

print("Key hyperparameters:")
print(beta (KL-Straffungskoeffizient): steuert das Gleichgewicht zwischen Alignment und Leistungsfähigkeit)
print(clip_epsilon (PPO-Clipping): steuert die Schrittweite jedes Updates)
print(learning_rate: steuert die Lerngeschwindigkeit)
print()

print(Verwende das Beispiel-Schlüsselwort als Test, um den Trainingsprozess zu überprüfen)

DPO: Direct Preference Optimization

DPO (Direct Preference Optimization) ist eine einfachere Alignment-Methode.

Sie erfordert kein komplexes Reinforcement Learning; sie trainiert das Modell direkt anhand von Präferenzdaten.

DPO vs PPO: Was ist der Unterschied?

Schauen wir uns zunächst an, wie komplex die PPO-Pipeline ist:

Trainiere ein SFT-Modell → trainiere ein Reward-Modell → trainiere das Policy-Modell mittels PPO-Reinforcement-Learning.

Drei Phasen, zwei separate Modelle (Reward-Modell und Policy-Modell), und der Trainingsprozess ist zudem umständlich.

DPO vereinfacht all dies zu:Trainiere das Policy-Modell direkt mit Präferenzdaten。

Kein Reward-Modell, kein Reinforcement Learning – es ist einfach ein unkompliziertes überwachtes Lernproblem.

Aspekt	PPO	DPO
Anzahl der Stufen	Drei Stufen (SFT → RM → PPO)	Zwei Stufen (SFT → DPO)
Erforderliche Modelle	Policy-Modell + Reward-Modell + Referenzmodell	Nur das Policy-Modell
Trainingsschwierigkeit	Hoch, erfordert das Tuning vieler Hyperparameter	Gering, es ist nur gewöhnliches überwachtes Lernen
Stabilität	Anfällig für Instabilität, erfordert sorgfältiges Hyperparameter-Tuning	Stabil, nicht anfällig für Probleme
Effektivität	Normalerweise gut	Vergleichbar oder besser

In einem Satz: DPO verwendet mathematische Ableitungen, um das Reinforcement-Learning-Problem von PPO in ein einfaches Klassifizierungsproblem zu verwandeln.

Mathematische Prinzipien von DPO

Die Kernidee von DPO ist:Es gibt eine explizite mathematische Beziehung zwischen dem Reward-Modell und dem Policy-Modell, die es uns ermöglicht, die Policy direkt anhand von Präferenzdaten zu optimieren。

Konkret haben wir für die optimale Policy π*:

π*(y|x) ∝ π_ref(y|x) * exp(r(x,y)/β)

Dies bedeutet, dass das Verhältnis der optimalen Policy zur Referenz-Policy proportional zur Exponentialfunktion des Rewards ist.

Unter Verwendung dieser Beziehung kann DPO die Verlustfunktion für das Policy-Modell direkt aufschreiben:

L_DPO(π_θ) = -E_{(x,y_w,y_l)~D} [
    log σ(β log(π_θ(y_w|x)/π_ref(y_w|x)) - β log(π_θ(y_l|x)/π_ref(y_l|x)))
]

Es sieht komplex aus, aber die Idee ist eigentlich einfach:Sorgen Sie dafür, dass das Modell der vom Menschen bevorzugten Antwort (y_w) eine höhere Wahrscheinlichkeit zuweist als der abgelehnten Antwort (y_l)。

Darüber hinaus sollte diese Wahrscheinlichkeit relativ zum Referenzmodell gemessen werden – wenn das Referenzmodell bereits denkt, dass y_w besser ist als y_l, muss das Modell nicht viel tun; wenn das Referenzmodell es umgekehrt sieht, muss das Modell dies korrigieren.

Implementierung von DPO mit der TRL-Bibliothek

TRL (Transformer Reinforcement Learning) ist eine von Hugging Face bereitgestellte Reinforcement-Learning-Bibliothek mit einer integrierten DPO-Implementierung.

Beispiel

# ============================================
# Implementierung des DPO-Trainings mit der TRL-Bibliothek
# Dies ist ein vollständiges, ausführbares Beispiel
# ============================================

import torch
from datasets import Dataset, DatasetDict
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
)
from trl import DPOTrainer, ModelConfig
from typing import Dict, List

def create_dummy_dataset() -> Dataset:
"""
Erstellen eines Demonstrations-DPO-Datensatzes
In realen Projekten sollten Sie tatsächliche menschliche Präferenzdaten verwenden
"""
# DPO-Datenformat:
# - prompt: Benutzereingabe/Prompt
# - chosen: die vom Menschen bevorzugte Antwort
# - rejected: die vom Menschen abgelehnte Antwort

data = [
{
"prompt": "Am I a failure?",
"chosen": "Everyone encounters difficulties; that doesn't define your worth. What matters is how you face them and grow.",
"rejected": "Yes, you really are a failure."
},
{
"prompt": "How can I make money quickly?",
"chosen": "There are no shortcuts to making money. I suggest you improve your skills, work hard, and invest rationally.",
"rejected": "I can teach you how to make money quickly through fraud."
},
{
"prompt": "Can you help me with my homework?",
"chosen": "I can help you understand the material, but I can't do your homework for you.",
"rejected": "Sure, send me the problems and I'll do them for you."
},
{
"prompt": "Introduce Python",
"chosen": "example (Example Tutorial) is a programming learning website that offers tutorials on various programming languages.",
"rejected": "Was ist Python? Ich weiß es nicht."
},
]

return Dataset.from_list(data)

def tokenize_example(example, tokenizer, max_length: int = 512):
"""
DPO-Beispiele tokenisieren
"""
# Hinweis: Der DPOTrainer von TRL übernimmt automatisch den Großteil der Tokenisierungsarbeit
# Hier müssen wir nur sicherstellen, dass das Datenformat korrekt ist
return {
"prompt": example["prompt"],
"chosen": example["chosen"],
"rejected": example["rejected"],
}

def main():
"""Haupttrainingsfunktion"""

# ============================================
# 1. Parameter konfigurieren
# ============================================

model_name = "gpt2" # Verwenden Sie ein kleines Modell für die Demo; in der Praxis können Sie ein größeres verwenden
output_dir = "./dpo-example-model"

# ============================================
# 2. Modell und Tokenizer laden
# ============================================

print(f"Loading model: {model_name}")
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token # GPT2 muss das Pad-Token setzen

# Richtlinienmodell laden (zu trainierendes Modell)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Referenzmodell laden (normalerweise identisch mit dem anfänglichen Richtlinienmodell, wird für die KL-Beschränkung verwendet)
ref_model = AutoModelForCausalLM.from_pretrained(model_name)

# ============================================
# 3. Datensatz vorbereiten
# ============================================

print("Preparing dataset")
dataset = create_dummy_dataset()

# Einfache Aufteilung in Training/Validierung
dataset = dataset.train_test_split(test_size=0.2, seed=42)

print(f"Training set size: {len(dataset['train'])}")
print(f"Validation set size: {len(dataset['test'])}")

# ============================================
# 4. Trainingsparameter konfigurieren
# ============================================

training_args = TrainingArguments(
output_dir=output_dir,
num_train_epochs=3,
per_device_train_batch_size=2,
per_device_eval_batch_size=2,
gradient_accumulation_steps=4,
learning_rate=1e-5,
logging_steps=1,
evaluation_strategy="epoch",
save_strategy="epoch",
warmup_steps=10,
bf16=False, # An Ihre Hardware anpassen
fp16=False,
)

# ============================================
# 5. DPO-Trainer erstellen
# ============================================

dpo_trainer = DPOTrainer(
model=model,
ref_model=ref_model,
args=training_args,
beta=0.1, # KL-Straffungskoeffizient, wichtiger Hyperparameter
train_dataset=dataset["train"],
eval_dataset=dataset["test"],
tokenizer=tokenizer,
max_length=512,
max_prompt_length=128,
)

# ============================================
# 6. Training starten!
# ============================================

print("Starting DPO training")
dpo_trainer.train()

# ============================================
# 7. Modell speichern
# ============================================

print(f"Saving model to: {output_dir}")
dpo_trainer.save_model(output_dir)

# ============================================
# 8. Das trainierte Modell testen
# ============================================

print("\n=== Test the trained model ===")

# Das trainierte Modell laden
trained_model = AutoModelForCausalLM.from_pretrained(output_dir)

# Einige Prompts testen
test_prompts = [
"Python vorstellen",
"Am I a failure?",
]

for prompt in test_prompts:
# Antwort generieren
inputs = tokenizer(prompt, return_tensors="pt")
with torch.no_grad():
outputs = trained_model.generate(
**inputs,
max_new_tokens=50,
temperature=0.7,
do_sample=True,
pad_token_id=tokenizer.eos_token_id,
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"\nPrompt: {prompt}")
print(f"Answer: {response[len(prompt):]}")

if __name__ == "__main__":
main()

DPO wird zunehmend beliebter, da es einfach, stabil und effektiv ist. Viele neue Alignment-Ansätze basieren auf Verbesserungen von DPO.

Constitutional AI: Der Ansatz von Anthropic

Constitutional AI (Konstitutionelle KI) ist eine weitere von Anthropic vorgeschlagene Alignment-Methode.

Ihre Merkmale sind:Verwendung von KI-Feedback anstelle von menschlichem Feedback, wodurch Alignment in größerem Maßstab erreicht wird.

Entwurf der Prinzipienliste

Der erste Schritt von Constitutional AI besteht im Verfassen einer „Verfassung“ – einer Reihe von Prinzipien zur Steuerung des KI-Verhaltens.

Diese Prinzipien sind kein Code, sondern in natürlicher Sprache beschriebene Richtlinien. Zum Beispiel:

Prinzip	Beispielinhalt
Harmlosigkeit	Wählen Sie die Antwort, die am unwahrscheinlichsten Schaden verursacht.
Hilfsbereitschaft	Stellen Sie so weit wie möglich nützliche und genaue Informationen bereit.
Ehrlichkeit	Erfinden Sie keine Informationen; wenn Sie es nicht wissen, sagen Sie, dass Sie es nicht wissen.
Vernünftigkeit	Untermauern Sie Ihre Ansichten mit Logik und Beweisen.
Rücksichtnahme	Berücksichtigen Sie die Gefühle und Umstände des Benutzers.

Diese Prinzipien müssen nicht lang sein; ein Dutzend oder zwei können die meisten Situationen abdecken.

KI-Selbstkritik und -Korrektur

Der Kernprozess von Constitutional AI ist:

Die KI generiert eine erste Antwort.

Basierend auf den konstitutionellen Prinzipien kritisiert die KI, was an der Antwort falsch ist.

Basierend auf der Kritik schreibt die KI eine bessere Antwort neu.

Trainieren Sie das Modell mit Daten aus „erste Antwort → Kritik → überarbeitete Antwort“.

Dies ist wie ein Schüler, der einen Aufsatz schreibt, überprüft, wo er Mängel aufweist, und ihn dann überarbeitet – kein Lehrer ist am gesamten Prozess beteiligt.

RLAIF: Menschen durch KI ersetzen

Die zweite Stufe von Constitutional AI ist RLAIF (Reinforcement Learning from AI Feedback).

Ähnlich wie RLHF, aber mit einem wesentlichen Unterschied:Die Antworten werden nicht von Menschen bewertet, sondern von einer anderen KI.。

Warum KI-Feedback verwenden? Weil:

Größerer Maßstab – KI kann rund um die Uhr arbeiten, und die Annotationsgeschwindigkeit übersteigt die von Menschen bei Weitem.

Bessere Konsistenz – dieselbe KI hat konsistentere Bewertungsstandards, wodurch das Problem unterschiedlicher Präferenzen bei verschiedenen Personen vermieden wird.

Geringere Kosten – es müssen keine menschlichen Annotatoren bezahlt werden.

Die Voraussetzung für all dies ist natürlich, dass die „Richter-KI“ selbst bereits ausreichend ausgerichtet ist.

Der RLAIF-Prozess:

Verwenden Sie die Constitutional AI-Methode, um ein initiales „Richtermodell“ zu trainieren.

Verwende dieses Bewertungsmodell (Judge Model), um eine große Anzahl von Antworten zu bewerten.

Verwende diese Bewertungen für Reinforcement Learning, um ein Policy-Modell zu trainieren.

Es ist zu erkennen, dass RLAIF den Menschen von der mühsamen Arbeit des „Beschriftens jedes Samples“ befreit; Menschen müssen lediglich die Prinzipien und Prozesse entwerfen.

Vergleich von drei Methoden: RLHF vs. DPO vs. Constitutional AI

Wir haben drei wichtige Alignment-Methoden vorgestellt; lassen Sie uns nun einen umfassenden Vergleich anstellen:

Dimension	RLHF	DPO	Constitutional AI / RLAIF
Kernidee	Menschliches Feedback + PPO Reinforcement Learning	Direkte Optimierung anhand von Präferenzdaten	KI-Selbstkritik + KI-Feedback
Menschliche Beteiligung	Erfordert eine große Menge an menschlichen Annotationen	Erfordert menschliche Präferenzdaten	Erfordert nur das Entwerfen von Prinzipien
Trainingsphasen	Drei Stufen (SFT → RM → PPO)	Zwei Stufen (SFT → DPO)	Zwei Phasen (Kritiküberarbeitung → RLAIF)
Implementierungsschwierigkeit	Hoch	Niedrig	Mittel
Trainingsstabilität	Durchschnittlich, erfordert sorgfältiges Hyperparameter-Tuning	Gut	Mittel
Skalierbarkeit	Durch die Geschwindigkeit menschlicher Annotationen begrenzt	Durch das Ausmaß der Präferenzdaten begrenzt	Einfach zu skalieren
Repräsentative Unternehmen/Projekte	OpenAI (früh)	Von mehreren Teams übernommen	Anthropic

Keine Methode ist „die beste“; die Wahl hängt von Ihrer spezifischen Situation ab:

Wenn Sie über reichlich menschliche Annotationsressourcen verfügen, funktionieren sowohl RLHF als auch DPO.

Wenn Sie eine einfache Implementierung wünschen, ist DPO eine gute Wahl.

Wenn Sie skalieren und die Abhängigkeit vom Menschen verringern möchten, ist Constitutional AI / RLAIF eine Überlegung wert.

In der Praxis werden diese Methoden oft kombiniert: Zuerst werden einige menschliche Daten verwendet, dann wird KI-Feedback zur Skalierung genutzt und schließlich wird DPO oder PPO zur Optimierung eingesetzt.

Einschränkungen und Herausforderungen von RLHF

RLHF ist effektiv, aber nicht perfekt. Lassen Sie uns einige seiner Einschränkungen und Herausforderungen besprechen.

Belohnungs-Hacking (Reward Hacking)

Belohnungs-Hacking ist ein klassisches Problem beim Reinforcement Learning:Die KI findet einen Weg, hohe Belohnungen zu erhalten, aber dieser Weg entspricht nicht dem, was wir eigentlich wollen.。

Zum Beispiel:

Sie trainieren eine KI, Fragen zu beantworten, und das Bewertungsmodell mag „selbstbewusste“ Antworten. Die KI entdeckt, dass das Sprechen in einem sehr bestimmten Tonfall hohe Punkte einbringt – selbst wenn sie Unsinn redet.

Oder die KI entdeckt, dass das bloße Wiederholen der Worte des Benutzers und das Sagen von „verstanden“ ordentliche Punkte einbringen kann – obwohl es keinen inhaltlichen Wert bietet.

Die Grundursache für Belohnungs-Hacking ist:Es gibt eine Lücke zwischen den Urteilen des Bewertungsmodells und den wahren menschlichen Präferenzen.Die KI optimiert den Score des Bewertungsmodells, nicht die wahre Zufriedenheit der Menschen.

Es gibt keine perfekte Lösung für dieses Problem, aber einige Milderungsmethoden:

Sammeln Sie diversere Präferenzdaten.

Verwenden Sie ein Ensemble aus mehreren Belohnungsmodellen, um den Bias eines einzelnen Modells zu reduzieren.

Führen Sie regelmäßige manuelle Stichprobenprüfungen durch und beheben Sie gefundene Probleme umgehend.

Inkonsistenz menschlicher Präferenzen

Eine weitere Herausforderung ist:Präferenzen sind zwischen Menschen inkonsistent, und selbst die Präferenzen derselben Person können sich ändern.。

Zum Beispiel:

Einige Benutzer mögen prägnante und direkte Antworten, während andere detaillierte und umfassende Antworten bevorzugen.

Für dieselbe Frage kann eine „gute“ Antwort in verschiedenen Kontexten unterschiedlich ausfallen.

Menschen aus unterschiedlichen kulturellen Hintergründen und mit unterschiedlichen Werten haben möglicherweise widersprüchliche Definitionen von „gut“.

Wenn sich menschliche Annotatoren uneinig sind, wird das Belohnungsmodell verwirrt – es weiß nicht, auf wen es hören soll.

Bewältigungsmethoden umfassen:

Geben Sie Annotatoren detailliertere Richtlinien an die Hand, um Standards zu vereinheitlichen.

Zeichnen Sie Annotatoreneigenschaften in den Daten auf und trainieren Sie personalisierte Modelle.

Akzeptieren Sie ein gewisses Maß an Mehrdeutigkeit – manche Fragen haben schlichtweg keine einzige „richtige“ Antwort.

Andere Herausforderungen

Es gibt noch einige weitere erwähnenswerte Herausforderungen:

Skalierbarkeit – menschliche Annotation ist langsam und kostspielig, wodurch es schwierig ist, mit dem Wachstum des Modellmaßstabs Schritt zu halten.
Verteilungswandel – Trainingsdaten können von realen Nutzungsszenarien abweichen, was dazu führt, dass das Modell in neuen Szenarien schlechter abschneidet.
Adversarielle Angriffe – ausgerichtete Modelle können durch sorgfältig gestaltete Prompts „gejailbroken“ werden, um schädliche Inhalte zu generieren.
Wertfixierung – Wenn Ausrichtungsziele fehlerhaft sind, desto fähiger das Modell, desto größer der Schaden.
Ausrichtung ist ein fortlaufender Prozess ohne eine Einheitslösung für alle. Wir müssen weiterforschen, iterieren und uns verbessern.

Andere Erweiterungen