> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/training/trl.md).

# 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.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

***

## 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`.

{% hint style="info" %}
**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.
  {% endhint %}

***

## 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](https://clore.ai/marketplace)
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

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

### Schritt 3 — TRL installieren

```bash
# 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

```bash
# 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

```bash
# 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

```python
# 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

```python
# 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")
```

```bash
# 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

```python
# 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

```python
# 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:

```python
# 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:

```python
# 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:

```bash
# 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:

```bash
# 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

```bash
# 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

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/training/trl.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.