TRL (RLHF/DPO-Training)

TRL TRL (Transformer Reinforcement Learning) ist die offizielle Bibliothek von HuggingFace zum Trainieren von Sprachmodellen mit Reinforcement-Learning-Techniken. Mit über 10.000 GitHub-Sternen bietet sie hochmoderne Implementierungen von RLHF, DPO, PPO, GRPO und anderen Alignment-Algorithmen für LLMs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

---

Was ist TRL?

TRL ist die Bibliothek hinter vielen der heute am besten ausgerichteten Sprachmodelle. Sie bietet:

• SFT (überwachtes Fine-Tuning) — standardmäßiges Instruction-Tuning im ChatML-Format

• RLHF/PPO — klassisches Proximal Policy Optimization mit einem Belohnungsmodell

• DPO — Direct Preference Optimization (kein Belohnungsmodell erforderlich!)

• GRPO — Group Relative Policy Optimization (die Methode von DeepSeek-R1)

• KTO — Kahneman-Tversky Optimization (funktioniert mit ungepaarten Präferenzen)

• Belohnungsmodellierung — trainiere ein Belohnungsmodell aus menschlichen Präferenzdaten

• Iteratives SFT — Online-RL mit einem einfacheren Setup

• ORPO — Odds-Ratio-Präferenzoptimierung

TRL integriert sich nativ in das HuggingFace-Ökosystem: transformers, peft, datasets, accelerate, und bitsandbytes.

Welchen Algorithmus solltest du verwenden?

• DPO — am einfachsten, am stabilsten. Verwende es, wenn du gepaarte Präferenzdaten hast (chosen/rejected).

• PPO — am leistungsstärksten, aber komplex. Verwende es, wenn du ein Belohnungsmodell oder eine Bewertungsfunktion hast.

• GRPO — großartig für Reasoning-/Mathe-Aufgaben. Die Trainingsmethode von DeepSeek-R1.

• SFT — beginne immer hier, bevor du eine RL-Methode anwendest.

---

Serveranforderungen

Komponente	Minimum	Empfohlen
GPU	RTX 3090 (24 GB)	A100 80 GB / H100
VRAM	16 GB (SFT/DPO 7B + LoRA)	80 GB (vollständiges Fine-Tuning 7B)
RAM	32 GB	64 GB+
CPU	8 Kerne	16+ Kerne
Speicher	100 GB	300 GB+
Betriebssystem	Ubuntu 20.04+	Ubuntu 22.04
Python	3.9+	3.11
CUDA	12.8+	12.8+

VRAM je nach Aufgabe

Aufgabe	Modell	Methode	VRAM
SFT	Llama 3 8B	QLoRA 4-bit	~8 GB
DPO	Llama 3 8B	LoRA	~20 GB
PPO	Llama 3 8B	Vollständig	~80 GB (2×A100)
GRPO	Qwen 7B	LoRA	~24 GB
SFT	Llama 3 70B	QLoRA 4-bit	~48 GB
DPO	Llama 3 70B	LoRA	~80 GB

---

Ports

Port	Dienst	Hinweise
22	SSH	Terminalzugriff, Dateitransfer, Überwachung

TRL ist eine Trainingsbibliothek — sie läuft als CLI-/Python-Skript, kein Webserver erforderlich.

---

Installation auf Clore.ai

Schritt 1 — Einen Server mieten

1. Gehe zu Clore.ai-Marktplatz

2. Filtern nach VRAM ≥ 24 GB (RTX 3090, A100 oder H100)

3. Wähle ein PyTorch oder CUDA 12.8 Basis-Image

4. Wähle Speicher ≥ 200 GB für Modelle und Datensätze

5. Port öffnen 22 für SSH-Zugriff

Schritt 2 — Per SSH verbinden

ssh root@<server-ip> -p <ssh-port>

Schritt 3 — TRL installieren

# Python-virtuelle Umgebung erstellen
python3 -m venv /opt/trl
source /opt/trl/bin/activate

# TRL mit allen Abhängigkeiten installieren
pip install trl

# Zusätzliche Abhängigkeiten für vollständige Workflows installieren
pip install \
    transformers \
    datasets \
    peft \
    accelerate \
    bitsandbytes \
    wandb \
    scipy \
    sentencepiece \
    protobuf

# GPU-Unterstützung prüfen
python3 -c "import torch; print(f'CUDA: {torch.cuda.is_available()}, GPU: {torch.cuda.get_device_name(0)}')"

Schritt 4 — HuggingFace-Authentifizierung

# Anmelden, um auf geschützte Modelle zuzugreifen (Llama, Gemma)
huggingface-cli login
# Gib dein HF-Token von https://huggingface.co/settings/tokens ein

# Oder Umgebungsvariable setzen
export HF_TOKEN=hf_your-token-here

Schritt 5 — Optional: Weights-&Biases-Tracking

# Experiment-Tracking einrichten (sehr empfohlen)
pip install wandb
wandb login  # Gib deinen W&B-API-Schlüssel von https://wandb.ai/settings ein

# Oder W&B deaktivieren
export WANDB_DISABLED=true

---

Überwachtes Fine-Tuning (SFT)

SFT ist immer der erste Schritt vor jeder RL-Technik.

Bereite deinen Datensatz vor

# Format: datasets-Bibliothek mit Spalte 'messages' oder 'text'
# ChatML-Format (empfohlen)
from datasets import Dataset

data = [
    {
        "messages": [
            {"role": "system", "content": "Du bist ein hilfreicher Assistent für GPU-Clouds."},
            {"role": "user", "content": "Wie miete ich eine GPU auf Clore.ai?"},
            {"role": "assistant", "content": "Besuche clore.ai/marketplace, filtere nach GPU-Spezifikationen, wähle einen Server und klicke auf Mieten. SSH-Zugriff wird unmittelbar nach der Zahlung bereitgestellt."}
        ]
    },
    # ... weitere Beispiele
]

dataset = Dataset.from_list(data)
dataset.save_to_disk("data/sft_dataset")
dataset.push_to_hub("your-username/my-sft-dataset")  # optional

SFT-Trainingsskript

# sft_train.py
from trl import SFTTrainer, SFTConfig
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model
from datasets import load_dataset
import torch

# Modellkonfiguration
model_name = "meta-llama/Llama-3.2-8B-Instruct"

# QLoRA: 4-Bit-Quantisierungskonfiguration
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

# Modell laden
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

# Tokenizer laden
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

# LoRA-Konfiguration
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

# Datensatz laden
dataset = load_dataset("trl-lib/ultrachat_200k", split="train_sft[:10%]")

# Trainingskonfiguration
training_config = SFTConfig(
    output_dir="./sft_output",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    warmup_ratio=0.05,
    lr_scheduler_type="cosine",
    fp16=False,
    bf16=True,
    max_seq_length=2048,
    dataset_text_field="messages",
    logging_steps=10,
    save_steps=100,
    save_total_limit=3,
    push_to_hub=False,
    report_to="wandb",  # oder "none"
)

# Trainer initialisieren
trainer = SFTTrainer(
    model=model,
    args=training_config,
    train_dataset=dataset,
    peft_config=lora_config,
    tokenizer=tokenizer,
)

# Trainieren
trainer.train()
trainer.save_model("./sft_final")

# Training ausführen
python3 sft_train.py

---

DPO (Direkte Präferenzoptimierung)

DPO ist die beliebteste Alignment-Methode — kein Belohnungsmodell erforderlich, nur Präferenzpaare.

DPO-Datensatz vorbereiten

# Format: Jedes Beispiel hat 'prompt', 'chosen', 'rejected'
from datasets import Dataset

data = [
    {
        "prompt": "Erkläre, wie die GPU-Auslastung optimiert werden kann",
        "chosen": "Um die GPU-Auslastung zu optimieren: 1) Größere Batch-Größen verwenden, um die Auslastung zu maximieren, 2) Mixed Precision (bf16/fp16) aktivieren, 3) Mit nvidia-smi profilieren, um Engpässe zu identifizieren, 4) CUDA-Streams für parallele Operationen verwenden.",
        "rejected": "Verwende einfach mehr GPUs."
    },
    # ... weitere Präferenzpaare
]

dataset = Dataset.from_list(data)

DPO-Trainingsskript

# dpo_train.py
from trl import DPOTrainer, DPOConfig
from transformers import AutoTokenizer, AutoModelForCausalLM
from datasets import load_dataset
import torch

model_name = "./sft_final"  # Starte mit deinem SFT-Modell!

# SFT-Modell laden (die auszurichtende Policy)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Referenzmodell (eingefrorene Kopie des SFT-Modells)
ref_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

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

# Präferenzdatensatz laden
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train[:5%]")

# DPO-Konfiguration
dpo_config = DPOConfig(
    output_dir="./dpo_output",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=5e-7,           # Viel niedriger als SFT
    beta=0.1,                     # KL-Strafkoeffizient
    loss_type="sigmoid",          # Standard-DPO-Loss
    max_length=2048,
    max_prompt_length=512,
    bf16=True,
    logging_steps=10,
    save_steps=50,
    report_to="wandb",
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=dpo_config,
    train_dataset=dataset,
    tokenizer=tokenizer,
)

trainer.train()
trainer.save_model("./dpo_final")

---

PPO (Proximal Policy Optimization)

PPO ist der klassische RLHF-Ansatz — verwende ihn, wenn du ein Belohnungssignal hast:

# ppo_train.py
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from transformers import AutoTokenizer, pipeline
from datasets import load_dataset
import torch

model_name = "./sft_final"

# Policy-Modell (mit Value-Head für PPO)
model = AutoModelForCausalLMWithValueHead.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
)

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

# Belohnungsmodell (kann jede beliebige Bewertungsfunktion sein)
sentiment_pipe = pipeline(
    "sentiment-analysis",
    model="distilbert/distilbert-base-uncased-finetuned-sst-2-english",
    device=0,
)

def reward_fn(texts):
    """Bewerte jede Antwort. Gib eine Liste von Reward-Tensoren zurück."""
    results = sentiment_pipe(texts)
    rewards = []
    for result in results:
        score = result["score"] if result["label"] == "POSITIVE" else -result["score"]
        rewards.append(torch.tensor(score))
    return rewards

ppo_config = PPOConfig(
    output_dir="./ppo_output",
    learning_rate=1.41e-5,
    mini_batch_size=1,
    batch_size=4,
    gradient_accumulation_steps=4,
    kl_penalty="kl",
    target_kl=6.0,
    cliprange=0.2,
    vf_coef=0.1,
)

trainer = PPOTrainer(
    config=ppo_config,
    model=model,
    ref_model=None,  # Kopiert das Ausgangsmodell automatisch als Referenz
    tokenizer=tokenizer,
)

# Trainingsschleife
dataset = load_dataset("imdb", split="train[:1000]")
for epoch in range(3):
    for batch in trainer.dataloader:
        queries = batch["input_ids"]
        
        # Antworten generieren
        responses = trainer.generate(queries, max_new_tokens=100)
        
        # Antworten bewerten
        texts = tokenizer.batch_decode(responses, skip_special_tokens=True)
        rewards = reward_fn(texts)
        
        # PPO-Update
        stats = trainer.step(queries, responses, rewards)
        trainer.log_stats(stats, batch, rewards)

---

GRPO (Group Relative Policy Optimization)

GRPO wird in DeepSeek-R1 für Reasoning-Training verwendet:

# grpo_train.py
from trl import GRPOTrainer, GRPOConfig
from transformers import AutoTokenizer, AutoModelForCausalLM
from datasets import Dataset
import re, torch

model_name = "Qwen/Qwen2.5-7B-Instruct"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Mathematik-Datensatz
def make_math_dataset():
    examples = [
        {"prompt": "Was ist 2+2?", "answer": "4"},
        {"prompt": "Was ist 15 * 7?", "answer": "105"},
        # ... weitere Mathematikaufgaben
    ]
    return Dataset.from_list(examples)

dataset = make_math_dataset()

def correctness_reward(completions, answer, **kwargs):
    """Belohnung 1.0, wenn die Antwort korrekt ist, sonst 0.0."""
    rewards = []
    for completion in completions:
        # Die letzte Zahl aus der Completion extrahieren
        numbers = re.findall(r'\d+', completion[-1]["content"])
        if numbers and numbers[-1] == answer:
            rewards.append(1.0)
        else:
            rewards.append(0.0)
    return rewards

grpo_config = GRPOConfig(
    output_dir="./grpo_output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    num_generations=8,       # GRPO generiert G Antworten pro Prompt
    learning_rate=5e-7,
    bf16=True,
    logging_steps=10,
)

trainer = GRPOTrainer(
    model=model,
    args=grpo_config,
    train_dataset=dataset,
    reward_funcs=correctness_reward,
    tokenizer=tokenizer,
)

trainer.train()

---

Multi-GPU-Training

Verwende accelerate für verteiltes Training:

# accelerate für Multi-GPU konfigurieren
accelerate config

# Beispielkonfiguration für 4 GPUs:
# - compute_environment: LOCAL_MACHINE
# - distributed_type: MULTI_GPU
# - num_processes: 4
# - mixed_precision: bf16

# Training auf allen GPUs starten
accelerate launch sft_train.py
accelerate launch dpo_train.py

# Oder GPUs explizit angeben
CUDA_VISIBLE_DEVICES=0,1,2,3 accelerate launch \\
  --num_processes 4 \\
  --mixed_precision bf16 \\
  sft_train.py

---

Die TRL-CLI verwenden

TRL bietet praktische CLI-Befehle:

# SFT per CLI
trl sft \\
  --model_name_or_path meta-llama/Llama-3.2-8B-Instruct \\
  --dataset_name trl-lib/ultrachat_200k \\
  --dataset_text_field messages \\
  --output_dir ./cli_sft_output \\
  --num_train_epochs 3 \\
  --per_device_train_batch_size 2 \\
  --gradient_accumulation_steps 4 \\
  --learning_rate 2e-4 \\
  --bf16 \\
  --use_peft \\
  --lora_r 16 \\
  --lora_alpha 32

# DPO per CLI
trl dpo \\
  --model_name_or_path ./cli_sft_output \\
  --dataset_name trl-lib/ultrafeedback_binarized \\
  --output_dir ./cli_dpo_output \\
  --num_train_epochs 1 \\
  --beta 0.1 \\
  --bf16

---

Training überwachen

# GPU-Auslastung beobachten
watch -n 1 nvidia-smi

# Trainingsverlust überwachen (wenn W&B verwendet wird)
# Öffnen Sie https://wandb.ai/your-username im Browser

# Ausgabeverzeichnis nach Checkpoints prüfen
ls -lh sft_output/checkpoint-*/

# Vom Checkpoint fortsetzen
python3 sft_train.py --resume_from_checkpoint sft_output/checkpoint-500/

---

GPU-Empfehlungen für Clore.ai

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

Das TRL-Training ist eine der VRAM-intensivsten Arbeitslasten. Wählen Sie Ihre GPU anhand der Modellgröße und der Methode aus:

Aufgabe	GPU	Hinweise
SFT / DPO auf 7–8B (QLoRA)	RTX 3090 24 GB	~8 GB für QLoRA 4-bit; passt bequem; $0.07–0.21/Std. auf Clore.ai
SFT / DPO auf 7–8B (LoRA bf16)	RTX 4090 24 GB	Gleicher VRAM wie die 3090, aber 30% schneller in der Berechnung; großartig für schnelle Iterationen
Volles SFT auf 7B oder DPO auf 13B	A100 40 GB	40 GB reichen für 7B-Training in voller Präzision; ECC-Speicher vermeidet stille Fehler
PPO / vollständiges Finetuning von 7B oder beliebiges 70B QLoRA	A100 80 GB	PPO benötigt 2× Policy- + Ref-Modell im VRAM; 80 GB betreibt beide ohne OOM

Praktischer Tipp: Starten Sie zum Experimentieren mit einer RTX 3090 und QLoRA — trainieren Sie Llama 3 8B in ~2 Std. mit 10K Beispielen. Sobald Sie die Pipeline validiert haben, wechseln Sie zu A100 80GB für Full-Precision-Läufe oder 70B-Modelle.

Geschwindigkeitswerte (Llama 3 8B SFT, QLoRA, batch=4, seq=2048):

• RTX 3090: ~1.100 Token/Sek. Trainingsdurchsatz

• RTX 4090: ~1.450 Token/Sek.

• A100 80GB: ~2.800 Token/Sek. (volles bf16, keine Quantisierung)

---

Fehlerbehebung

CUDA Out of Memory

# Batch-Größe reduzieren
per_device_train_batch_size=1
gradient_accumulation_steps=16  # Effektive Batchgröße gleich halten

# 4-Bit-Quantisierung verwenden (QLoRA)
# BitsAndBytesConfig mit load_in_4bit=True hinzufügen

# Gradient Checkpointing aktivieren
gradient_checkpointing=True

# Sequenzlänge reduzieren
max_seq_length=1024  # statt 2048+

# GPU-Speicher prüfen
nvidia-smi --query-gpu=memory.used,memory.total --format=csv

Loss ist NaN

# Häufige Ursache: zu hohe Lernrate
learning_rate=1e-5  # Niedriger versuchen

# Häufige Ursache: schlechte Daten (leere Strings, None-Werte)
# Datensatz validieren:
python3 -c "
from datasets import load_from_disk
ds = load_from_disk('data/sft_dataset')
print(ds[0])
print(f'Length: {len(ds)}')
# Auf None prüfen
none_count = sum(1 for x in ds if x.get('messages') is None)
print(f'None count: {none_count}')
"

# bf16 statt fp16 aktivieren (stabiler)
bf16=True
fp16=False

DPO: chosen_rewards > rejected_rewards ist False

# Das bedeutet, dass das Modell abgelehnte Antworten bevorzugt — Overfitting oder schlechte Daten
# Lösungen:
# 1. Überprüfen Sie die Qualität Ihres Datensatzes
# 2. Beta reduzieren (weniger KL-Strafe)
# 3. Lernrate reduzieren
# 4. Vor DPO mehr SFT-Training hinzufügen
beta=0.05  # Kleinere Werte ausprobieren

Das Training ist sehr langsam

# Flash Attention 2 aktivieren
pip install flash-attn --no-build-isolation

# In Ihrem Code:
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    attn_implementation="flash_attention_2",
    torch_dtype=torch.bfloat16,
)

# bf16 statt fp16 auf Ampere+-GPUs verwenden (A100, RTX 3000+)
bf16=True

# DataLoader-Worker erhöhen
dataloader_num_workers=4

# Prüfen, ob die GPU tatsächlich verwendet wird
nvidia-smi  # Sollte eine hohe GPU-Auslastung anzeigen

tokenizer.pad_token Warnung

# Standardlösung für Llama-/Mistral-Tokenizer
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"  # Wichtig für die Trainingsstabilität

Zugriff verweigert / HuggingFace 401

# Erneut anmelden
huggingface-cli login

# Token in der Umgebung setzen
export HF_TOKEN=hf_your-token

# Für private Modelle/Datensätze stellen Sie sicher, dass Sie Zugriff haben:
# Gehen Sie zu https://huggingface.co/meta-llama/Llama-3.2-8B-Instruct
# Klicken Sie auf "Request access" und akzeptieren Sie die Lizenz

---

Ihr Modell speichern und teilen

# LoRA-Gewichte in das Basismodell zusammenführen
python3 << 'EOF'
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-8B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
model = PeftModel.from_pretrained(base_model, "./sft_final")
merged = model.merge_and_unload()
merged.save_pretrained("./merged_model")

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-8B-Instruct")
tokenizer.save_pretrained("./merged_model")
print("Zusammengeführtes Modell gespeichert!")
EOF

# Zu HuggingFace hochladen
huggingface-cli upload your-username/my-trl-model ./merged_model

---

Nützliche Links

• GitHub: https://github.com/huggingface/trl ⭐ 10K+

• Dokumentation: https://huggingface.co/docs/trl

• DPO-Paper: https://arxiv.org/abs/2305.18290

• GRPO / DeepSeek-R1: https://arxiv.org/abs/2501.12599

• PPO-Paper (RLHF): https://arxiv.org/abs/2203.02155

• HuggingFace PEFT: https://github.com/huggingface/peft

• Weights & Biases: https://wandb.ai

• Flash Attention: https://github.com/Dao-AILab/flash-attention

• Clore.ai-Marktplatz: https://clore.ai/marketplace