# Reinforcement Learning ohne SFT: Das DeepSeek-R1-Paradigma

**Meta-Description:** Technische Analyse des DeepSeek-R1 Trainingsansatzes: Pure RL ohne Supervised Fine-Tuning, GRPO-Optimierung und die Implikationen für die KI-Branche.

**Keywords:** DeepSeek R1, Reinforcement Learning, SFT, GRPO, AI Training, Reasoning Models, LLM Training Pipeline

---

## Einführung

DeepSeek-R1-Zero ist ein Meilenstein: Das erste Modell, das **reine Reasoning-Fähigkeiten durch Reinforcement Learning entwickelt** – ohne den traditionellen Supervised Fine-Tuning (SFT) Schritt. Das Paper beweist, dass LLMs Reasoning "lernen" können, nicht nur "nachahmen".

---

## Das traditionelle Training vs. DeepSeek-Ansatz

### Traditioneller Ansatz

```
Pre-Training → SFT → RLHF
              (Human Data)
```

### DeepSeek-R1-Zero

```
Pre-Training → RL (GRPO)
              (Nur Rewards, keine Human-Demos)
```

---

## Die Multi-Stage Pipeline von DeepSeek-R1

DeepSeeks vollständiges Training umfasst **vier Phasen**:

### Stage 1: Cold Start (Dev1) - Instruction Following

```python
# Konzeptuell: Instruction-Following SFT
model.finetune(
    dataset="instruction_following_data",
    objective="follow_user_instructions"
)
# Ergebnis: Bessere Instruktionsbefolgung
# Trade-off: Reasoning-Fähigkeiten sinken
```

### Stage 2: Reasoning Rescue (Dev2) - RL für Reasoning

```python
# GRPO (Group Relative Policy Optimization)
for batch in training_batches:
    # Generiere mehrere Antworten
    responses = model.generate(prompt, n=8)

    # Berechne Rewards
    rewards = [
        accuracy_reward(r) + format_reward(r)
        for r in responses
    ]

    # Relative Optimierung (ohne Baseline-Modell)
    model.grpo_update(responses, rewards)
```

### Stage 3: Quality Refinement (Dev3) - Rejection Sampling + SFT

```python
# Generiere viele Kandidaten
candidates = []
for prompt in prompts:
    for _ in range(64):  # Viele Samples
        response = model.generate(prompt)
        score = evaluate_quality(response)
        candidates.append((prompt, response, score))

# Nur die besten behalten
top_candidates = select_top_percent(candidates, percent=10)

# Zweite SFT-Runde
model.finetune(dataset=top_candidates)
```

### Stage 4: Final RL Alignment

```python
# Finales RL für Human Preferences
model.rl_finetune(
    reward_model=human_preference_rm,
    objective="align_with_human_preferences"
)
```

---

## GRPO: Die technische Innovation

**Group Relative Policy Optimization** eliminiert das Baseline-Modell:

```python
class GRPO:
    def compute_loss(self, responses, rewards):
        # Gruppiere Responses pro Prompt
        groups = group_by_prompt(responses, rewards)

        total_loss = 0
        for group in groups:
            # Normalisiere Rewards innerhalb der Gruppe
            mean_reward = np.mean(group.rewards)
            std_reward = np.std(group.rewards)
            normalized = (group.rewards - mean_reward) / std_reward

            # Policy Gradient mit relativen Rewards
            for response, norm_reward in zip(group.responses, normalized):
                log_prob = self.model.log_prob(response)
                total_loss -= log_prob * norm_reward

        return total_loss
```

**Vorteile:**
- Kein separates Baseline-Modell nötig
- Stabiler als PPO
- Effizienter bei begrenztem Compute

---

## Die Reward-Funktion

DeepSeek verwendet eine **simple aber effektive** Reward-Struktur:

```python
def compute_reward(response, ground_truth):
    reward = 0

    # Accuracy Reward (binär)
    if extract_answer(response) == ground_truth:
        reward += 1.0

    # Format Reward (strukturiertes Denken)
    if has_thinking_tags(response):
        reward += 0.1

    return reward
```

**Wichtig:** Kein komplexes MCTS (Monte Carlo Tree Search). Das Paper bestätigt, dass MCTS für generelles Reasoning **nicht funktioniert hat**.

---

## Was NICHT funktionierte

Das aktualisierte Paper (Januar 2026) enthält einen "Unsuccessful Attempts" Abschnitt:

| Methode | Warum es scheiterte |
|---------|---------------------|
| **MCTS** | Zu hoher Compute, kein klarer Suchraum |
| **Process Reward Models** | Schwer zu trainieren, instabil |
| **Complex Reward Shaping** | Führte zu Reward Hacking |

---

## Kostenvergleich

| Modell | Trainingskosten | Quelle |
|--------|-----------------|--------|
| **DeepSeek R1** | ~$294,000 | DeepSeek Paper |
| **GPT-4** | ~$100M+ | Schätzungen |
| **Claude 3** | Nicht bekannt | - |

Der Faktor **300x günstiger** zeigt: Effizienz schlägt Brute-Force-Compute.

---

## Implikationen für die Branche

1. **Demokratisierung:** Reasoning-Modelle sind nicht mehr nur für Big Tech möglich
2. **Forschungsrichtung:** RL-First statt SFT-First könnte Standard werden
3. **Effizienz:** Spezialisierte Architekturen > Massive Compute
4. **Open Science:** Detaillierte Papiere beschleunigen die gesamte Forschung

---

## Praktische Anwendung: Open-R1

HuggingFace hat eine Open-Source-Reproduktion gestartet:

```bash
# Open-R1 Repository
git clone https://github.com/huggingface/open-r1

# Training starten
python train.py \
  --base_model "meta-llama/Llama-3.1-8B" \
  --method "grpo" \
  --reward_type "accuracy+format"
```

---

## Fazit

DeepSeek-R1 beweist drei fundamentale Dinge:

1. **Reasoning ist lernbar** durch RL, nicht nur imitierbar durch SFT
2. **Einfache Rewards** funktionieren besser als komplexe
3. **Effizienz** ist wichtiger als rohe Compute-Power

Das Paradigma verschiebt sich: Von "mehr Daten, mehr Compute" zu "bessere Algorithmen, klügere Architekturen".

---

## Bildprompts

1. "Neural network learning through trial and error, maze-solving visualization with glowing paths, abstract tech art"
2. "AI model climbing a mountain, each step representing learning iterations, motivational and technical blend"
3. "Laboratory setting with AI model in training, visible reward/penalty signals, scientific illustration style"

---

## Quellen

- [DeepSeek-R1 Paper (arXiv)](https://arxiv.org/abs/2501.12948)
- [WinBuzzer: R1 Architecture Secrets](https://winbuzzer.com/2026/01/09/deepseek-reveals-r1-model-architecture-secrets-ahead-of-v4-model-launch-xcxwbn/)
- [HuggingFace: Open-R1 Reproduction](https://huggingface.co/blog/open-r1)
- [GitHub: DeepSeek-R1](https://github.com/deepseek-ai/DeepSeek-R1)