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

# 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

# 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

# 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

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

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:

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:

Kostenvergleich

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:

# 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)
• WinBuzzer: R1 Architecture Secrets
• HuggingFace: Open-R1 Reproduction
• GitHub: DeepSeek-R1