Add blog posts, cleanup unused files, update components

- Add 100 blog posts covering AI, development, and tech topics - Add .env.example for environment configuration - Add accessibility and lighthouse audit scripts - Remove obsolete SEO reports and temporary files - Remove dev-dist build artifacts and backup files - Remove unused portrait images (moved/consolidated elsewhere) - Update contact form and component improvements Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-25 11:42:11 +01:00
parent cba6c66ccc
commit 43484c5023
164 changed files with 60969 additions and 23346 deletions
@@ -0,0 +1,227 @@
+# 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)